feat: add support for native checksums (#100)

Author: lauzadis

.github/workflows/ci.yaml

@@ -33,6 +33,7 @@ jobs:
       - name: Test with ${{ matrix.java-version }}
         shell: bash
         run: |
+          ./gradlew apiCheck
           ./gradlew -Ptest.java.version=${{ matrix.java-version }} -Paws.sdk.kotlin.crt.disableCrossCompile=true jvmTest --stacktrace 
       - name: Save Test Reports
         if: failure()

aws-crt-kotlin/api/aws-crt-kotlin.api

@@ -177,6 +177,7 @@ kotlin {
     val xcrun = "/usr/bin/xcrun"
 
     tasks.register<Exec>("bootIosSimulatorDevice") {
+        isIgnoreExitValue = true
         commandLine(xcrun, "simctl", "boot", simulatorDeviceName)
 
         doLast {

aws-crt-kotlin/build.gradle.kts

@@ -5,12 +5,11 @@
 
 package aws.sdk.kotlin.crt.util
 
-import kotlin.test.Ignore
+import aws.sdk.kotlin.crt.CrtTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
-class DigestTest {
-    @Ignore // FIXME Enable when Kotlin/Native implementation is complete
+class DigestTest : CrtTest() {
     @Test
     fun testSha256() {
         val buffer = "I don't know half of you half as well as I should like; and I like less than half of you half as well as you deserve.".encodeToByteArray()

aws-crt-kotlin/common/test/aws/sdk/kotlin/crt/util/DigestTest.kt

@@ -19,8 +19,10 @@ headers = aws/common/allocator.h \
         aws/http/connection_manager.h \
         aws/http/request_response.h \
         aws/http/proxy.h \
-        aws/compression/compression.h
-headerFilter = aws/common/* aws/io/* aws/http/* aws/compression/*
+        aws/compression/compression.h \
+        aws/cal/hash.h \
+        aws/checksums/crc.h
+headerFilter = aws/common/* aws/io/* aws/http/* aws/compression/* aws/cal/* aws/checksums/*
 
 linkerOpts.osx = -framework Security
 linkerOpts.ios = -framework Security

aws-crt-kotlin/native/interop/crt.def

@@ -5,14 +5,16 @@
 
 package aws.sdk.kotlin.crt.util
 
+import Sha256
+
 /**
  * Utility object for various hash functions
  */
 public actual object Digest {
     /**
      * Calculate the SHA-256 hash of the input [buffer]
      */
-    public actual fun sha256(buffer: ByteArray): ByteArray {
-        TODO("Not yet implemented")
-    }
+    public actual fun sha256(buffer: ByteArray): ByteArray = Sha256().apply {
+        update(buffer, 0, buffer.size)
+    }.digest()
 }

aws-crt-kotlin/native/src/aws/sdk/kotlin/crt/util/DigestNative.kt

@@ -0,0 +1,56 @@
+import kotlinx.cinterop.*
+import libcrt.aws_checksums_crc32
+import libcrt.aws_checksums_crc32c
+import platform.posix.uint32_t
+import platform.posix.uint8_tVar
+
+/**
+ * A typealias to CRT's aws_checksums_<crc32/crc32c> functions
+ */
+internal typealias AwsChecksumsCrcFunction = (
+    input: CValuesRef<uint8_tVar>?,
+    length: Int,
+    previousCrc32: uint32_t
+) -> uint32_t
+
+internal class Crc(val checksumFn: AwsChecksumsCrcFunction) : HashFunction {
+    private var crc = 0U
+
+    override fun update(input: ByteArray, offset: Int, length: Int) {
+        val offsetInput = input.usePinned {
+            it.addressOf(offset)
+        }
+        crc = checksumFn(offsetInput.reinterpret(), length.convert(), crc)
+    }
+
+    override fun digest(): ByteArray = byteArrayOf(
+        ((crc shr 24) and 0xffu).toByte(),
+        ((crc shr 16) and 0xffu).toByte(),
+        ((crc shr 8) and 0xffu).toByte(),
+        (crc and 0xffu).toByte(),
+    ).also { reset() }
+
+    override fun reset() {
+        crc = 0U
+    }
+}
+
+/**
+ * A CRC32 [HashFunction] implemented using bindings to CRT.
+ */
+public class Crc32 : HashFunction {
+    private val crc32 = Crc(::aws_checksums_crc32)
+    override fun update(input: ByteArray, offset: Int, length: Int) { crc32.update(input, offset, length) }
+    override fun digest(): ByteArray = crc32.digest()
+    override fun reset() { crc32.reset() }
+}
+
+/**
+ * A CRC32C [HashFunction] implemented using bindings to CRT.
+ */
+public class Crc32c : HashFunction {
+    private val crc32c = Crc(::aws_checksums_crc32c)
+    override fun update(input: ByteArray, offset: Int, length: Int) { crc32c.update(input, offset, length) }
+    override fun digest(): ByteArray = crc32c.digest()
+    override fun reset() { crc32c.reset() }
+}

aws-crt-kotlin/native/src/aws/sdk/kotlin/crt/util/hashing/CrcNative.kt

@@ -0,0 +1,19 @@
+/**
+ * A function which calculates the hash of given data
+ */
+public interface HashFunction {
+    /**
+     * Update the hash content with [length] bytes from [input] starting from [offset]
+     */
+    public fun update(input: ByteArray, offset: Int, length: Int)
+
+    /**
+     * Digest the hash content, returning [ByteArray] and resetting the hash
+     */
+    public fun digest(): ByteArray
+
+    /**
+     * Reset the content of the hash
+     */
+    public fun reset()
+}

aws-crt-kotlin/native/src/aws/sdk/kotlin/crt/util/hashing/HashFunctionNative.kt

@@ -0,0 +1,81 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import aws.sdk.kotlin.crt.Allocator
+import aws.sdk.kotlin.crt.CrtRuntimeException
+import aws.sdk.kotlin.crt.awsAssertOpSuccess
+import kotlinx.cinterop.*
+import libcrt.*
+
+/**
+ * A typealias to CRT's aws_<checksum_algorithm>_new functions (i.e. aws_sha1_new, aws_sha256_new))
+ */
+internal typealias InitializeHashFn = (
+    allocator: CValuesRef<aws_allocator>?,
+) -> CPointer<aws_hash>?
+
+/**
+ * SHA-1 hash function implemented using bindings to CRT
+ */
+public class Sha1 : HashFunction {
+    private val sha1 = Sha(::aws_sha1_new)
+    override fun update(input: ByteArray, offset: Int, length: Int) { sha1.update(input, offset, length) }
+    override fun digest(): ByteArray = sha1.digest()
+    override fun reset() { sha1.reset() }
+}
+
+/**
+ * SHA-256 hash function implemented using bindings to CRT
+ */
+public class Sha256 : HashFunction {
+    private val sha256 = Sha(::aws_sha256_new)
+    override fun update(input: ByteArray, offset: Int, length: Int) { sha256.update(input, offset, length) }
+    override fun digest(): ByteArray = sha256.digest()
+    override fun reset() { sha256.reset() }
+}
+
+internal class Sha(val initializeFn: InitializeHashFn) : HashFunction {
+    private var hash: CPointer<aws_hash>
+
+    init {
+        hash = initializeHash()
+    }
+
+    // aws_hash_update
+    override fun update(input: ByteArray, offset: Int, length: Int) {
+        val inputCursor = input.usePinned {
+            aws_byte_cursor_from_array(it.addressOf(offset), length.convert())
+        }
+        awsAssertOpSuccess(aws_hash_update(hash, inputCursor)) {
+            "aws_hash_update"
+        }
+    }
+
+    // aws_hash_finalize
+    override fun digest(): ByteArray {
+        val output = ByteArray(hash.pointed.digest_size.toInt())
+
+        val byteBuf = output.usePinned {
+            cValue<aws_byte_buf> {
+                capacity = output.size.convert()
+                len = 0U
+                buffer = it.addressOf(0).reinterpret()
+            }
+        }
+
+        awsAssertOpSuccess(aws_hash_finalize(hash, byteBuf, 0U)) { "aws_hash_finalize" }
+
+        return output.also { reset() }
+    }
+
+    // aws_hash_destroy
+    override fun reset() {
+        aws_hash_destroy(hash)
+        hash = initializeHash()
+    }
+
+    private fun initializeHash() = checkNotNull(initializeFn(Allocator.Default.allocator)) {
+        "failed to initialize hash"
+    }
+}

aws-crt-kotlin/native/src/aws/sdk/kotlin/crt/util/hashing/ShaNative.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import aws.sdk.kotlin.crt.util.encodeToHex
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class HashFunctionTest {
+    @Test
+    fun testUpdate() {
+        // algorithm -> listOf(hash("uh"), hash(""))
+        val tests = listOf(
+            (Sha1() to listOf("80c3d7b3f509a5ac8bb29d7f8c4a94af14f7d244", "da39a3ee5e6b4b0d3255bfef95601890afd80709")),
+            (Sha256() to listOf("beba745afae8503925089cc2f3cc9b87e849e81c07531e83c5c341a63bcaaed9", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")),
+            (Crc32() to listOf("50f87626", "00000000")),
+            (Crc32c() to listOf("f80f9153", "00000000")),
+        )
+
+        tests.forEach { (hash, expected) ->
+            val data = "uh".encodeToByteArray()
+            hash.update(data, 0, data.size)
+
+            // hash of "uh"
+            assertEquals(expected[0], hash.digest().encodeToHex())
+
+            // hash of an empty string
+            assertEquals(expected[1], hash.digest().encodeToHex())
+        }
+    }
+
+    @Test
+    fun testMultipleUpdatesWithOffset() {
+        // algorithm -> hash("uh" + "huh")
+        val tests = listOf(
+            (Sha1() to "c093098e7a1a8ec547e82a399d63f331760e9a57"),
+            (Sha256() to "b474fb57f69c1b5aa00aa27ad0b36c03fe9915cc497344d6a55a86b2e9bd1b72"),
+            (Crc32() to "5e67b90f"),
+            (Crc32c() to "a3249200"),
+        )
+
+        tests.forEach { (hash, expected) ->
+            val data = "ahuhi".encodeToByteArray()
+            hash.update(data, 2, 2) // uh
+
+            hash.update(data, 1, 3) // huh
+
+            assertEquals(expected, hash.digest().encodeToHex())
+        }
+    }
+}