From 5d61858f81a475144669dff0248381f780cda90b Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sat, 8 Aug 2020 19:54:48 +0200 Subject: [PATCH] All platforms working with a smoke test, seems theres a bug with JS compiler (TODO in smoke test desccribes it) --- .../libsodium/definitions/DefinitionTypes.kt | 2 + .../LibsodiumGenericHashDefinitions.kt | 5 +- .../definitions/LibsodiumHashDefinitions.kt | 3 + .../generator/JsLibsodiumGenerator.kt | 8 +- .../generator/JvmLibsodiumGenerator.kt | 129 ++++++++++++++---- .../generator/NativeLibsodiumGenerator.kt | 2 +- .../libsodium/generator/SharedCreators.kt | 10 ++ .../commonMain/kotlin/debug/test/DebugTest.kt | 4 +- .../com/ionspin/kotlin/crypto/SmokeTest.kt | 30 ++++ .../ionspin/kotlin/crypto/util/TestUtil.kt | 36 +++++ .../src/jsMain/kotlin/debug/test/DebugTest.kt | 4 +- .../jvmMain/kotlin/debug/test/DebugTest.kt | 38 +++--- .../nativeMain/kotlin/debug/test/DebugTest.kt | 13 +- .../kotlin/crypto/{util => }/UtilTest.kt | 9 +- 14 files changed, 231 insertions(+), 62 deletions(-) create mode 100644 multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/SmokeTest.kt create mode 100644 multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/TestUtil.kt rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{util => }/UtilTest.kt (90%) diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/DefinitionTypes.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/DefinitionTypes.kt index 3036706..dfd1175 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/DefinitionTypes.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/DefinitionTypes.kt @@ -72,6 +72,7 @@ class ParameterDefinition( val isActuallyAnOutputParam: Boolean = false, val isStateType: Boolean = false, val dropParameterFromDefinition: Boolean = false, + val specificJvmInitializer: String? = null, ) interface GeneralTypeDefinition { @@ -108,6 +109,7 @@ fun innerClassDef( javaName: String, jsName: String, nativeName: String, + specificConstructor : String? = null, body: InnerClassDefinition.() -> Unit = {} ): InnerClassDefinition { val genClass = InnerClassDefinition( diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumGenericHashDefinitions.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumGenericHashDefinitions.kt index 1aec8e6..d6d47fd 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumGenericHashDefinitions.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumGenericHashDefinitions.kt @@ -14,7 +14,7 @@ fun ClassDefinition.defineGenericHashFunctions() { +innerClassDef( "GenericHashState", - "ByteArray", + "kotlin.ByteArray", "Uint8Array", "crypto_generichash_blake2b_state" ) @@ -29,7 +29,8 @@ fun ClassDefinition.defineGenericHashFunctions() { "state", CustomTypeDefinition((withPackageName("GenericHashState"))), isStateType = true, - dropParameterFromDefinition = true + dropParameterFromDefinition = true, + specificJvmInitializer = "sodium.crypto_generichash_statebytes()" ) +ParameterDefinition("key", TypeDefinition.ARRAY_OF_UBYTES) +ParameterDefinition("outlen", TypeDefinition.INT, modifiesReturn = true) diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumHashDefinitions.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumHashDefinitions.kt index b196ecf..ec02290 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumHashDefinitions.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/definitions/LibsodiumHashDefinitions.kt @@ -18,6 +18,9 @@ fun ClassDefinition.defineHashFunctions() { "crypto_hash_sha256_state" ) +funcDef( + "crypto_hash_sha256_init_spec", + "crypto_hash_sha256_init", + "crypto_hash_sha256_init", "crypto_hash_sha256_init", CustomTypeDefinition(ClassName(packageName, "Sha256State")), dynamicJsReturn = true, diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JsLibsodiumGenerator.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JsLibsodiumGenerator.kt index a70402d..82a4e59 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JsLibsodiumGenerator.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JsLibsodiumGenerator.kt @@ -73,19 +73,19 @@ object JsLibsodiumGenerator { val constructJsCall = StringBuilder() when (methodDefinition.returnType) { TypeDefinition.ARRAY_OF_UBYTES -> { - constructJsCall.append("return getSodium().${methodDefinition.javaName}") + constructJsCall.append("return getSodium().${methodDefinition.jsName}") constructJsCall.append(paramsToString(methodDefinition) + ".toUByteArray()") } TypeDefinition.INT -> { - constructJsCall.append("return getSodium().${methodDefinition.javaName}") + constructJsCall.append("return getSodium().${methodDefinition.jsName}") constructJsCall.append(paramsToString(methodDefinition)) } TypeDefinition.UNIT -> { - constructJsCall.append("getSodium().${methodDefinition.javaName}") + constructJsCall.append("getSodium().${methodDefinition.jsName}") constructJsCall.append(paramsToString(methodDefinition)) } is CustomTypeDefinition -> { - constructJsCall.append("return getSodium().${methodDefinition.javaName}") + constructJsCall.append("return getSodium().${methodDefinition.jsName}") constructJsCall.append(paramsToString(methodDefinition)) } } diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JvmLibsodiumGenerator.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JvmLibsodiumGenerator.kt index d0ba99a..2636747 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JvmLibsodiumGenerator.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/JvmLibsodiumGenerator.kt @@ -1,7 +1,18 @@ package com.ionspin.kotlin.crypto.generator.libsodium.generator -import com.ionspin.kotlin.crypto.generator.libsodium.definitions.* -import com.squareup.kotlinpoet.* +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.CustomTypeDefinition +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.FunctionDefinition +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.InnerClassDefinition +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.KotlinFileDefinition +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.ParameterDefinition +import com.ionspin.kotlin.crypto.generator.libsodium.definitions.TypeDefinition +import com.squareup.kotlinpoet.ClassName +import com.squareup.kotlinpoet.CodeBlock +import com.squareup.kotlinpoet.FileSpec +import com.squareup.kotlinpoet.FunSpec +import com.squareup.kotlinpoet.ParameterSpec +import com.squareup.kotlinpoet.PropertySpec +import com.squareup.kotlinpoet.TypeAliasSpec /** * Created by Ugljesa Jovanovic @@ -49,10 +60,17 @@ object JvmLibsodiumGenerator { methodBuilder.modifiers += MultiplatformModifier.ACTUAL.modifierList var returnModifierFound = false var returnModifierName = "" + lateinit var actualReturnParameterDefinition: ParameterDefinition + var actualReturnTypeFound: Boolean = false for (paramDefinition in methodDefinition.parameterList) { - val parameterSpec = - ParameterSpec.builder(paramDefinition.parameterName, paramDefinition.parameterType.typeName) - methodBuilder.addParameter(parameterSpec.build()) + if (paramDefinition.isStateType && methodDefinition.isStateCreationFunction) { + createStateParam(paramDefinition, methodBuilder) + } + if ((paramDefinition.isStateType.not() || methodDefinition.isStateCreationFunction.not()) && paramDefinition.isActuallyAnOutputParam.not()) { + val parameterSpec = + ParameterSpec.builder(paramDefinition.parameterName, paramDefinition.parameterType.typeName) + methodBuilder.addParameter(parameterSpec.build()) + } if (paramDefinition.modifiesReturn) { if (returnModifierFound == true) { throw RuntimeException("Return modifier already found") @@ -60,33 +78,98 @@ object JvmLibsodiumGenerator { returnModifierFound = true returnModifierName = paramDefinition.parameterName } + if (paramDefinition.isActuallyAnOutputParam) { + actualReturnParameterDefinition = paramDefinition + actualReturnTypeFound = true + } + } + if (actualReturnTypeFound) { + if (returnModifierFound) { + createOutputParam( + actualReturnParameterDefinition, + returnModifierName, + methodBuilder + ) + } else { + if (methodDefinition.outputLengthWhenArray == -1) { + throw RuntimeException("Function definition lacks a way to define output array length, function ${methodDefinition.name}") + } + createOutputParam( + actualReturnParameterDefinition, + methodDefinition.outputLengthWhenArray.toString(), + methodBuilder + ) + } } - methodBuilder.addStatement("println(\"Debug\")") val constructJvmCall = StringBuilder() - when (methodDefinition.returnType) { - TypeDefinition.ARRAY_OF_UBYTES -> { - constructJvmCall.append("return sodium.${methodDefinition.nativeName}") - constructJvmCall.append(paramsToString(methodDefinition)) - } - TypeDefinition.INT -> { - constructJvmCall.append("return sodium.${methodDefinition.nativeName}") - constructJvmCall.append(paramsToString(methodDefinition)) - } - TypeDefinition.UNIT -> { - constructJvmCall.append("sodium.${methodDefinition.nativeName}") - constructJvmCall.append(paramsToString(methodDefinition)) - } - is CustomTypeDefinition -> { - constructJvmCall.append("return sodium.${methodDefinition.nativeName}") - constructJvmCall.append(paramsToString(methodDefinition)) + if (methodDefinition.isStateCreationFunction) { + constructJvmCall.append("sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + methodBuilder.addStatement("return state") + } else if (actualReturnTypeFound) { + constructJvmCall.append("sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + methodBuilder.addStatement("return out") + } else { + when (methodDefinition.returnType) { + TypeDefinition.ARRAY_OF_UBYTES -> { + constructJvmCall.append("val result = sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + methodBuilder.addStatement("return result") + } + TypeDefinition.INT -> { + constructJvmCall.append("val result = sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + methodBuilder.addStatement("return result") + } + TypeDefinition.UNIT -> { + constructJvmCall.append("sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + } + is CustomTypeDefinition -> { + constructJvmCall.append("val result = sodium.${methodDefinition.nativeName}") + constructJvmCall.append(paramsToString(methodDefinition)) + methodBuilder.addStatement(constructJvmCall.toString()) + methodBuilder.addStatement("return result") + } } } - methodBuilder.addStatement(constructJvmCall.toString()) methodBuilder.returns(methodDefinition.returnType.typeName) return methodBuilder.build() } + fun createOutputParam(outputParam: ParameterDefinition, length: String?, methodBuilder: FunSpec.Builder) { + /* + val hashed = ByteArray(Sha256Properties.MAX_HASH_BYTES) + sodium.crypto_hash_sha256_final(state, hashed) + return hashed.asUByteArray() + */ + when (outputParam.parameterType) { + TypeDefinition.ARRAY_OF_UBYTES, TypeDefinition.ARRAY_OF_UBYTES_NO_SIZE, TypeDefinition.ARRAY_OF_UBYTES_LONG_SIZE -> { + methodBuilder.addStatement("val out = UByteArray($length)") + } + else -> { + throw RuntimeException("Unhandled native output param type: ${outputParam.parameterType.typeName}") + } + + + } + } + + fun createStateParam(stateParameterDefinition: ParameterDefinition, methodBuilder: FunSpec.Builder) { + /* + val state = Hash.State256() + */ + val specificInitializer = stateParameterDefinition.specificJvmInitializer ?: "" + methodBuilder.addStatement("val state = ${stateParameterDefinition.parameterType.typeName}($specificInitializer)") + } + fun paramsToString(methodDefinition: FunctionDefinition) : String { val paramsBuilder = StringBuilder() paramsBuilder.append("(") diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/NativeLibsodiumGenerator.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/NativeLibsodiumGenerator.kt index 756821d..320e9d3 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/NativeLibsodiumGenerator.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/NativeLibsodiumGenerator.kt @@ -49,7 +49,7 @@ object NativeLibsodiumGenerator { val byteEmitter = PropertySpec.builder("_emitByte", Byte::class.asTypeName()) byteEmitter.initializer(CodeBlock.of("0")) val byteArrayEmitter = PropertySpec.builder("_emitByteArray", ByteArray::class.asTypeName()) - byteArrayEmitter.initializer(CodeBlock.of("ByteArray(0) {}")) + byteArrayEmitter.initializer(CodeBlock.of("ByteArray(0)")) commonClassSpec.addProperty(byteEmitter.build()) commonClassSpec.addProperty(byteArrayEmitter.build()) fileBuilder.addType(commonClassSpec.build()) diff --git a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/SharedCreators.kt b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/SharedCreators.kt index 14af224..189561b 100644 --- a/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/SharedCreators.kt +++ b/kotlin-multiplatform-libsodium-generator/src/main/kotlin/com/ionspin/kotlin/crypto/generator/libsodium/generator/SharedCreators.kt @@ -4,6 +4,7 @@ import com.ionspin.kotlin.crypto.generator.libsodium.definitions.ClassDefinition import com.ionspin.kotlin.crypto.generator.libsodium.definitions.FunctionDefinition import com.ionspin.kotlin.crypto.generator.libsodium.definitions.InnerClassDefinition import com.squareup.kotlinpoet.FunSpec +import com.squareup.kotlinpoet.KModifier import com.squareup.kotlinpoet.TypeSpec /** @@ -17,6 +18,15 @@ fun createClass( methodCreator: (FunctionDefinition) -> FunSpec ): TypeSpec.Builder { val commonClassBuilder = TypeSpec.classBuilder(classDefinition.name) + // Ugly + val primaryConstructor = FunSpec.constructorBuilder() + if (multiplatformModifier == MultiplatformModifier.EXPECT) { + primaryConstructor.addModifiers(KModifier.INTERNAL) + } else { + primaryConstructor.addModifiers(KModifier.INTERNAL, KModifier.ACTUAL) + } + + commonClassBuilder.primaryConstructor(primaryConstructor.build()) commonClassBuilder.modifiers += multiplatformModifier.modifierList for (methodDefinition in classDefinition.methods) { commonClassBuilder.addFunction(methodCreator(methodDefinition)) diff --git a/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/debug/test/DebugTest.kt b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/debug/test/DebugTest.kt index 28a0634..e28a1ca 100644 --- a/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/debug/test/DebugTest.kt +++ b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/debug/test/DebugTest.kt @@ -9,8 +9,8 @@ expect class Sha512State expect class GenericHashState -expect class Crypto { - fun crypto_hash_sha256_init(): Sha256State +expect class Crypto internal constructor() { + fun crypto_hash_sha256_init_spec(): Sha256State fun crypto_hash_sha256_update(state: Sha256State, input: UByteArray) diff --git a/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/SmokeTest.kt b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/SmokeTest.kt new file mode 100644 index 0000000..2c2d1fe --- /dev/null +++ b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/SmokeTest.kt @@ -0,0 +1,30 @@ +package com.ionspin.kotlin.crypto + +import com.ionspin.kotlin.crypto.hash.encodeToUByteArray +import com.ionspin.kotlin.crypto.util.testBlocking +import com.ionspin.kotlin.crypto.util.toHexString +import debug.test.Crypto +import kotlin.test.Test +import kotlin.test.assertTrue + +/** + * Created by Ugljesa Jovanovic + * ugljesa.jovanovic@ionspin.com + * on 08-Aug-2020 + */ +class SmokeTest { + @Test + fun testIfLibraryIsNotOnFire() = testBlocking { + Initializer.initialize() + val crypto = Crypto() + val state256 = crypto.crypto_hash_sha256_init_spec() //TODO seems to be a bug in JS compiler, if we have the same method name in crypto an in JsSodiumInterface, method tries to call wrong method name (unneeded suffix _0) + crypto.crypto_hash_sha256_update(state256, "Hello".encodeToUByteArray()) + val result = crypto.crypto_hash_sha256_final(state256).toHexString() + println("Result: $result") + assertTrue { + "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" == result + } + + + } +} diff --git a/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/TestUtil.kt b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/TestUtil.kt new file mode 100644 index 0000000..3cb5304 --- /dev/null +++ b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/TestUtil.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2019 Ugljesa Jovanovic + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.ionspin.kotlin.crypto.util + +import kotlin.coroutines.Continuation +import kotlin.coroutines.EmptyCoroutineContext +import kotlin.coroutines.startCoroutine + +/** + * Created by Ugljesa Jovanovic + * ugljesa.jovanovic@ionspin.com + * on 20-Jul-2019 + */ +fun testBlocking(block : suspend () -> Unit) { + val continuation = Continuation(EmptyCoroutineContext) { + //Do nothing + if (it.isFailure) { + throw it.exceptionOrNull()!! + } + } + block.startCoroutine(continuation) +} diff --git a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/debug/test/DebugTest.kt b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/debug/test/DebugTest.kt index 0a4c717..4ebfc23 100644 --- a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/debug/test/DebugTest.kt +++ b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/debug/test/DebugTest.kt @@ -13,8 +13,8 @@ actual typealias Sha512State = Any actual typealias GenericHashState = Any -actual class Crypto { - actual fun crypto_hash_sha256_init(): dynamic { +actual class Crypto internal actual constructor() { + actual fun crypto_hash_sha256_init_spec(): dynamic { println("Debug") return getSodium().crypto_hash_sha256_init() } diff --git a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/debug/test/DebugTest.kt b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/debug/test/DebugTest.kt index 0acbbe5..022d395 100644 --- a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/debug/test/DebugTest.kt +++ b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/debug/test/DebugTest.kt @@ -1,8 +1,8 @@ package debug.test -import ByteArray import com.goterl.lazycode.lazysodium.SodiumJava import com.goterl.lazycode.lazysodium.interfaces.Hash +import kotlin.ByteArray import kotlin.Int import kotlin.UByteArray @@ -14,10 +14,12 @@ actual typealias Sha512State = Hash.State512 actual typealias GenericHashState = ByteArray -actual class Crypto { - actual fun crypto_hash_sha256_init(state: Sha256State): Sha256State { +actual class Crypto internal actual constructor() { + actual fun crypto_hash_sha256_init_spec(): Sha256State { + val state = debug.test.Sha256State() println("Debug") - return sodium.crypto_hash_sha256_init(state) + sodium.crypto_hash_sha256_init(state) + return state } actual fun crypto_hash_sha256_update(state: Sha256State, input: UByteArray) { @@ -25,14 +27,18 @@ actual class Crypto { sodium.crypto_hash_sha256_update(state, input.asByteArray(), input.size.toLong()) } - actual fun crypto_hash_sha256_final(state: Sha256State, out: UByteArray): UByteArray { + actual fun crypto_hash_sha256_final(state: Sha256State): UByteArray { + val out = UByteArray(32) println("Debug") - return sodium.crypto_hash_sha256_final(state, out.asByteArray()) + sodium.crypto_hash_sha256_final(state, out.asByteArray()) + return out } - actual fun crypto_hash_sha512_init(state: Sha512State): Sha512State { + actual fun crypto_hash_sha512_init(): Sha512State { + val state = debug.test.Sha512State() println("Debug") - return sodium.crypto_hash_sha512_init(state) + sodium.crypto_hash_sha512_init(state) + return state } actual fun crypto_hash_sha512_update(state: Sha512State, input: UByteArray) { @@ -40,17 +46,17 @@ actual class Crypto { sodium.crypto_hash_sha512_update(state, input.asByteArray(), input.size.toLong()) } - actual fun crypto_hash_sha512_final(state: Sha512State, out: UByteArray): UByteArray { + actual fun crypto_hash_sha512_final(state: Sha512State): UByteArray { + val out = UByteArray(64) println("Debug") - return sodium.crypto_hash_sha512_final(state, out.asByteArray()) + sodium.crypto_hash_sha512_final(state, out.asByteArray()) + return out } - actual fun crypto_generichash_init( - state: GenericHashState, - key: UByteArray, - outlen: Int - ): GenericHashState { + actual fun crypto_generichash_init(key: UByteArray, outlen: Int): GenericHashState { + val state = debug.test.GenericHashState(sodium.crypto_generichash_statebytes()) println("Debug") - return sodium.crypto_generichash_init(state, key.asByteArray(), key.size, outlen) + sodium.crypto_generichash_init(state, key.asByteArray(), key.size, outlen) + return state } } diff --git a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/debug/test/DebugTest.kt b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/debug/test/DebugTest.kt index 64285c9..0509ab6 100644 --- a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/debug/test/DebugTest.kt +++ b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/debug/test/DebugTest.kt @@ -22,28 +22,25 @@ actual typealias Sha512State = crypto_hash_sha512_state actual typealias GenericHashState = crypto_generichash_blake2b_state -actual class Crypto { +actual class Crypto internal actual constructor() { val _emitByte: Byte = 0 - val _emitByteArray: ByteArray = ByteArray(0) {} + val _emitByteArray: ByteArray = ByteArray(0) - actual fun crypto_hash_sha256_init(): Sha256State { + actual fun crypto_hash_sha256_init_spec(): Sha256State { val allocated = sodium_malloc(debug.test.Sha256State.size.convert())!! val state = allocated.reinterpret().pointed - println("Debug") libsodium.crypto_hash_sha256_init(state.ptr) return state } actual fun crypto_hash_sha256_update(state: Sha256State, input: UByteArray) { - println("Debug") val pinnedInput = input.pin() libsodium.crypto_hash_sha256_update(state.ptr, pinnedInput.addressOf(0), input.size.convert()) pinnedInput.unpin() } actual fun crypto_hash_sha256_final(state: Sha256State): UByteArray { - println("Debug") val out = UByteArray(32) val pinnedOut = out.pin() libsodium.crypto_hash_sha256_final(state.ptr, pinnedOut.addressOf(0)) @@ -54,20 +51,17 @@ actual class Crypto { actual fun crypto_hash_sha512_init(): Sha512State { val allocated = sodium_malloc(debug.test.Sha512State.size.convert())!! val state = allocated.reinterpret().pointed - println("Debug") libsodium.crypto_hash_sha512_init(state.ptr) return state } actual fun crypto_hash_sha512_update(state: Sha512State, input: UByteArray) { - println("Debug") val pinnedInput = input.pin() libsodium.crypto_hash_sha512_update(state.ptr, pinnedInput.addressOf(0), input.size.convert()) pinnedInput.unpin() } actual fun crypto_hash_sha512_final(state: Sha512State): UByteArray { - println("Debug") val out = UByteArray(64) val pinnedOut = out.pin() libsodium.crypto_hash_sha512_final(state.ptr, pinnedOut.addressOf(0)) @@ -78,7 +72,6 @@ actual class Crypto { actual fun crypto_generichash_init(key: UByteArray, outlen: Int): GenericHashState { val allocated = sodium_malloc(debug.test.GenericHashState.size.convert())!! val state = allocated.reinterpret().pointed - println("Debug") val pinnedKey = key.pin() libsodium.crypto_generichash_init(state.ptr, pinnedKey.addressOf(0), key.size.convert(), outlen.convert()) diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/UtilTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/UtilTest.kt similarity index 90% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/UtilTest.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/UtilTest.kt index a72224d..aa90414 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/UtilTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/UtilTest.kt @@ -14,8 +14,13 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.util +package com.ionspin.kotlin.crypto +import com.ionspin.kotlin.crypto.util.chunked +import com.ionspin.kotlin.crypto.util.fromBigEndianArrayToULong +import com.ionspin.kotlin.crypto.util.fromLittleEndianArrayToULong +import com.ionspin.kotlin.crypto.util.toBigEndianUByteArray +import com.ionspin.kotlin.crypto.util.toLittleEndianTypedUByteArray import kotlin.test.Test import kotlin.test.assertTrue @@ -106,4 +111,4 @@ class UtilTest { } } -} \ No newline at end of file +}