YoungBlood/libsodium_wasm_experimental
3
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Memory rework

Browse Source
This commit is contained in:
Ugljesa Jovanovic 2020-05-19 23:12:24 +02:00 committed by Ugljesa Jovanovic
parent 799a9bb74e
commit d2c52e02e8
No known key found for this signature in database
GPG Key ID: 178E6DFCECCB0E0F
19 changed files with 312 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
jvmSample/build.gradle.kts Normal file
View File

@ -0,0 +1,27 @@
plugins {
kotlin("jvm")
}
group = "com.ionspin.kotlin"
version = "unspecified"
repositories {
maven("https://dl.bintray.com/kotlin/kotlin-eap")
mavenCentral()
}
dependencies {
implementation(kotlin("stdlib-jdk8"))
implementation(project(path = ":multiplatform-crypto"))
testImplementation(kotlin(Deps.Jvm.test))
testImplementation(kotlin(Deps.Jvm.testJUnit))
}
tasks {
compileKotlin {
kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
kotlinOptions.jvmTarget = "1.8"
}
}

BIN
jvmSample/out/production/classes/JvmSample$Companion.class Normal file
View File

Binary file not shown.

BIN
jvmSample/out/production/classes/JvmSample.class Normal file
View File

Binary file not shown.

BIN
jvmSample/out/production/classes/META-INF/jvmSample.kotlin_module Normal file
View File

Binary file not shown.

BIN
jvmSample/out/test/classes/JvmTest$testNothing$1.class Normal file
View File

Binary file not shown.

BIN
jvmSample/out/test/classes/JvmTest.class Normal file
View File

Binary file not shown.

BIN
jvmSample/out/test/classes/META-INF/jvmSample.kotlin_module Normal file
View File

Binary file not shown.

28
jvmSample/src/main/kotlin/JvmSample.kt Normal file
View File

@ -0,0 +1,28 @@
/*
* 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.
*/
/**
* Created by Ugljesa Jovanovic
* ugljesa.jovanovic@ionspin.com
* on 19-May-2020
*/
class JvmSample {
companion object {
fun nothing() {
println("Nothing")
}
}
}

63
jvmSample/src/test/kotlin/JvmTest.kt Normal file
View File

@ -0,0 +1,63 @@
@file:Suppress("EXPERIMENTAL_UNSIGNED_LITERALS", "EXPERIMENTAL_API_USAGE")
import com.ionspin.kotlin.crypto.keyderivation.argon2.Argon2
import com.ionspin.kotlin.crypto.keyderivation.argon2.ArgonType
import org.jetbrains.annotations.TestOnly
import org.junit.Test
import kotlin.test.assertTrue
/*
* 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.
*/
/**
* Created by Ugljesa Jovanovic
* ugljesa.jovanovic@ionspin.com
* on 19-May-2020
*/
@ExperimentalStdlibApi
class JvmTest {
@Test
fun testNothing() {
JvmSample.nothing()
assertTrue { true }
}
@Test
fun argon2StringExample() {
val argon2Instance = Argon2(
password = "Password",
salt = "RandomSalt",
parallelism = 4,
tagLength = 64U,
requestedMemorySize = 25U * 1024U, //Travis build on mac fails with higher values
numberOfIterations = 4,
key = "",
associatedData = "",
argonType = ArgonType.Argon2id
)
val tag = argon2Instance.derive()
val tagString = tag.map { it.toString(16).padStart(2, '0') }.joinToString(separator = "")
val expectedTagString = "ca134003c9f9f76ca8869359c1d9065603ec54ac30f5158f06af647cacaef2c1c3e" +
"c71e81960278c0596febc64125acbbe5959146db1c128199a1b7cb38982a9"
println("Tag: ${tagString}")
// assertEquals(tagString, expectedTagString)
}
}

123
multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/keyderivation/argon2/Argon2.kt
View File

@ -19,14 +19,14 @@
package com.ionspin.kotlin.crypto.keyderivation.argon2
import com.ionspin.kotlin.bignum.integer.toBigInteger
import com.ionspin.kotlin.crypto.SRNG
import com.ionspin.kotlin.crypto.hash.blake2b.Blake2b
import com.ionspin.kotlin.crypto.keyderivation.KeyDerivationFunction
import com.ionspin.kotlin.crypto.keyderivation.argon2.Argon2Utils.argonBlake2bArbitraryLenghtHash
import com.ionspin.kotlin.crypto.keyderivation.argon2.Argon2Utils.compressionFunctionG
import com.ionspin.kotlin.crypto.keyderivation.argon2.Argon2Utils.validateArgonParameters
import com.ionspin.kotlin.crypto.util.fromLittleEndianArrayToUInt
import com.ionspin.kotlin.crypto.util.hexColumsPrint
import com.ionspin.kotlin.crypto.util.toLittleEndianUByteArray
import com.ionspin.kotlin.crypto.util.toLittleEndianTypedUByteArray
/**
* Created by Ugljesa Jovanovic
@ -45,9 +45,11 @@ data class SegmentPosition(
)
data class ArgonResult(
val hashBytes: Array<UByte>
val hashBytes: Array<UByte>,
val salt: Array<UByte>
) {
val hashString by lazy { hashBytes.map { it.toString(16).padStart(2, '0') }.joinToString(separator = "") }
val saltString by lazy { salt.map { it.toString(16).padStart(2, '0') }.joinToString(separator = "") }
}
@ -58,7 +60,7 @@ class Argon2(
private val parallelism: Int = 1,
private val tagLength: UInt = 64U,
requestedMemorySize: UInt = 0U,
private val numberOfIterations: UInt = 1U,
private val numberOfIterations: Int = 1,
private val key: Array<UByte> = emptyArray(),
private val associatedData: Array<UByte> = emptyArray(),
private val argonType: ArgonType = ArgonType.Argon2id
@ -67,11 +69,28 @@ class Argon2(
companion object {
fun derive(
password: String,
salt: String? = null,
key: String,
associatedData: String,
parallelism: Int = 16,
memory : Int = 4096,
numberOfIterations : Int = 10
) : ArgonResult {
return ArgonResult(emptyArray())
tagLength: Int = 64,
memory: Int = 4096,
numberOfIterations: Int = 10,
): ArgonResult {
val salt = SRNG.getRandomBytes(64)
val argon = Argon2(
password.encodeToByteArray().map { it.toUByte() }.toList().toTypedArray(),
salt,
parallelism,
tagLength.toUInt(),
memory.toUInt(),
numberOfIterations,
key.encodeToByteArray().map { it.toUByte() }.toList().toTypedArray(),
associatedData.encodeToByteArray().map { it.toUByte() }.toList().toTypedArray(),
ArgonType.Argon2id
)
val resultArray = argon.derive()
return ArgonResult(resultArray, salt)
}
}
@ -81,7 +100,7 @@ class Argon2(
parallelism: Int = 1,
tagLength: UInt = 64U,
requestedMemorySize: UInt = 0U,
numberOfIterations: UInt = 10U,
numberOfIterations: Int = 10,
key: String = "",
associatedData: String = "",
argonType: ArgonType = ArgonType.Argon2id
@ -97,20 +116,6 @@ class Argon2(
argonType
)
init {
validateArgonParameters(
password,
salt,
parallelism,
tagLength,
requestedMemorySize,
numberOfIterations,
key,
associatedData,
argonType
)
}
//We support only the latest version
private val versionNumber: UInt = 0x13U
@ -126,12 +131,27 @@ class Argon2(
private val useIndependentAddressing = argonType == ArgonType.Argon2id || argonType == ArgonType.Argon2i
// State
private val matrix = Array(parallelism) {
Array(columnCount) {
Array<UByte>(1024) { 0U }
private val matrix: Array<Array<UByteArray>>
init {
matrix = Array(parallelism) {
Array(columnCount) {
UByteArray(1024)
}
}
validateArgonParameters(
password,
salt,
parallelism,
tagLength,
requestedMemorySize,
numberOfIterations,
key,
associatedData,
argonType
)
}
private fun clearMatrix() {
@ -154,13 +174,13 @@ class Argon2(
//Calculate first pass
val firstPass = compressionFunctionG(
Array<UByte>(1024) { 0U },
iteration.toULong().toLittleEndianUByteArray() +
lane.toULong().toLittleEndianUByteArray() +
slice.toULong().toLittleEndianUByteArray() +
blockCount.toULong().toLittleEndianUByteArray() +
numberOfIterations.toULong().toLittleEndianUByteArray() +
argonType.typeId.toULong().toLittleEndianUByteArray() +
addressCounter.toLittleEndianUByteArray() +
iteration.toULong().toLittleEndianTypedUByteArray() +
lane.toULong().toLittleEndianTypedUByteArray() +
slice.toULong().toLittleEndianTypedUByteArray() +
blockCount.toULong().toLittleEndianTypedUByteArray() +
numberOfIterations.toULong().toLittleEndianTypedUByteArray() +
argonType.typeId.toULong().toLittleEndianTypedUByteArray() +
addressCounter.toLittleEndianTypedUByteArray() +
Array<UByte>(968) { 0U },
addressBlock,
false
@ -196,7 +216,8 @@ class Argon2(
Pair(first32Bit, second32Bit)
}
ArgonType.Argon2i -> {
val selectedAddressBlock = addressBlock!!.sliceArray((independentIndex * 8) until (independentIndex * 8) + 8)
val selectedAddressBlock =
addressBlock!!.sliceArray((independentIndex * 8) until (independentIndex * 8) + 8)
val first32Bit = selectedAddressBlock.sliceArray(0 until 4).fromLittleEndianArrayToUInt()
val second32Bit = selectedAddressBlock.sliceArray(4 until 8).fromLittleEndianArrayToUInt()
Pair(first32Bit, second32Bit)
@ -280,31 +301,32 @@ class Argon2(
override fun derive(): Array<UByte> {
val h0 = Blake2b.digest(
parallelism.toUInt()
.toLittleEndianUByteArray() + tagLength.toLittleEndianUByteArray() + memorySize.toLittleEndianUByteArray() +
numberOfIterations.toLittleEndianUByteArray() + versionNumber.toLittleEndianUByteArray() + argonType.typeId.toUInt()
.toLittleEndianUByteArray() +
password.size.toUInt().toLittleEndianUByteArray() + password +
salt.size.toUInt().toLittleEndianUByteArray() + salt +
key.size.toUInt().toLittleEndianUByteArray() + key +
associatedData.size.toUInt().toLittleEndianUByteArray() + associatedData
.toLittleEndianTypedUByteArray() + tagLength.toLittleEndianTypedUByteArray() + memorySize.toLittleEndianTypedUByteArray() +
numberOfIterations.toUInt()
.toLittleEndianTypedUByteArray() + versionNumber.toLittleEndianTypedUByteArray() + argonType.typeId.toUInt()
.toLittleEndianTypedUByteArray() +
password.size.toUInt().toLittleEndianTypedUByteArray() + password +
salt.size.toUInt().toLittleEndianTypedUByteArray() + salt +
key.size.toUInt().toLittleEndianTypedUByteArray() + key +
associatedData.size.toUInt().toLittleEndianTypedUByteArray() + associatedData
)
//Compute B[i][0]
for (i in 0 until parallelism.toInt()) {
for (i in 0 until parallelism) {
matrix[i][0] =
argonBlake2bArbitraryLenghtHash(
h0 + 0.toUInt().toLittleEndianUByteArray() + i.toUInt().toLittleEndianUByteArray(),
h0 + 0.toUInt().toLittleEndianTypedUByteArray() + i.toUInt().toLittleEndianTypedUByteArray(),
1024U
)
).toUByteArray()
}
//Compute B[i][1]
for (i in 0 until parallelism.toInt()) {
for (i in 0 until parallelism) {
matrix[i][1] =
argonBlake2bArbitraryLenghtHash(
h0 + 1.toUInt().toLittleEndianUByteArray() + i.toUInt().toLittleEndianUByteArray(),
h0 + 1.toUInt().toLittleEndianTypedUByteArray() + i.toUInt().toLittleEndianTypedUByteArray(),
1024U
)
).toUByteArray()
}
executeArgonWithSingleThread()
@ -326,7 +348,7 @@ class Argon2(
}
private fun executeArgonWithSingleThread() {
for (iteration in 0 until numberOfIterations.toInt()) {
for (iteration in 0 until numberOfIterations) {
for (slice in 0 until 4) {
for (lane in 0 until parallelism) {
val segmentPosition = SegmentPosition(iteration, lane, slice)
@ -366,7 +388,6 @@ class Argon2(
if (useIndependentAddressing && segmentIndex != 0 && segmentIndex % 128 == 0) {
addressBlock = populateAddressBlock(iteration, slice, lane, addressBlock!!, addressCounter)
addressCounter++
addressBlock.hexColumsPrint(16)
}
val previousColumn = if (column == 0) {
columnCount - 1
@ -386,7 +407,7 @@ class Argon2(
matrix[l][z],
matrix[lane][column],
true
)
).toUByteArray()
}
}

4
multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/keyderivation/argon2/Argon2Exceptions.kt
View File

@ -23,8 +23,8 @@ package com.ionspin.kotlin.crypto.keyderivation.argon2
*/
class Argon2TagTooShort(tagLength: UInt) : RuntimeException("Too short tag (output) requested. Requested: $tagLength")
class Argon2TagTooLong(tagLength: UInt) : RuntimeException("Too long tag (output) requested. Requested: $tagLength")
class Argon2TimeTooShort(iterations: UInt) : RuntimeException("Too short time parameter (Too few iterations). Requested iterations: $iterations")
class Argon2TimeTooLong(iterations: UInt) : RuntimeException("Too long time parameter (Too many iterations). Requested iterations: $iterations")
class Argon2TimeTooShort(iterations: Int) : RuntimeException("Too short time parameter (Too few iterations). Requested iterations: $iterations")
class Argon2TimeTooLong(iterations: Int) : RuntimeException("Too long time parameter (Too many iterations). Requested iterations: $iterations")
class Argon2MemoryTooLitlle(requestedMemorySize: UInt) : RuntimeException("Requested memory size must be larger than 8 * parallelism. Requested size: $requestedMemorySize")
class Argon2MemoryTooMuch(requestedMemorySize: UInt) : RuntimeException("Requested memory size too large. Requested size: $requestedMemorySize")
class Argon2LanesTooFew(parallelism: Int) : RuntimeException("Too few, or invalid number of threads requested $parallelism")

67
multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/keyderivation/argon2/Argon2Utils.kt
View File

@ -33,9 +33,21 @@ object Argon2Utils {
const val R3 = 16
const val R4 = 63
//based on Blake2b mixRound
private fun mixRound(input: Array<UByte>): Array<ULong> {
var v = input.chunked(8).map { it.fromLittleEndianArrayToULong() }.toTypedArray()
private fun mixInPlace(input: UByteArray, startPosition: Int) {
var v = input.arrayChunked(8).map { it.fromLittleEndianArrayToULong() }.toTypedArray()
v = mix(v, 0, 4, 8, 12)
v = mix(v, 1, 5, 9, 13)
v = mix(v, 2, 6, 10, 14)
v = mix(v, 3, 7, 11, 15)
v = mix(v, 0, 5, 10, 15)
v = mix(v, 1, 6, 11, 12)
v = mix(v, 2, 7, 8, 13)
v = mix(v, 3, 4, 9, 14)
}
//based on Blake2b mixRound //TODO rework so it's in place mix
private fun mixRound(input: UByteArray): Array<ULong> {
var v = input.arrayChunked(8).map { it.fromLittleEndianArrayToULong() }.toTypedArray()
v = mix(v, 0, 4, 8, 12)
v = mix(v, 1, 5, 9, 13)
v = mix(v, 2, 6, 10, 14)
@ -47,6 +59,10 @@ object Argon2Utils {
return v
}
private fun inPlaceMix(v: UByteArray, a: Int, b: Int, c: Int, d: Int) {
}
//Based on Blake2b mix
private fun mix(v: Array<ULong>, a: Int, b: Int, c: Int, d: Int): Array<ULong> {
v[a] = (v[a] + v[b] + 2U * (v[a] and 0xFFFFFFFFUL) * (v[b] and 0xFFFFFFFFUL))
@ -60,8 +76,8 @@ object Argon2Utils {
return v
}
private fun extractColumnFromGBlock(gBlock: Array<UByte>, columnPosition: Int): Array<UByte> {
val result = Array<UByte>(128) { 0U }
private fun extractColumnFromGBlock(gBlock: UByteArray, columnPosition: Int): UByteArray {
val result = UByteArray(128) { 0U }
for (i in 0..7) {
gBlock.copyOfRange(i * 128 + (columnPosition * 16), i * 128 + (columnPosition * 16) + 16)
.copyInto(result, i * 16)
@ -69,7 +85,7 @@ object Argon2Utils {
return result
}
private fun copyIntoGBlockColumn(gBlock: Array<UByte>, columnPosition: Int, columnData: Array<UByte>) {
private fun copyIntoGBlockColumn(gBlock: UByteArray, columnPosition: Int, columnData: UByteArray) {
for (i in 0..7) {
val column = columnData.copyOfRange(i * 16, i * 16 + 16)
column.copyInto(gBlock, i * 128 + columnPosition * 16)
@ -77,24 +93,21 @@ object Argon2Utils {
}
internal fun compressionFunctionG(
previousBlock: Array<UByte>,
referenceBlock: Array<UByte>,
currentBlock: Array<UByte>,
previousBlock: UByteArray,
referenceBlock: UByteArray,
currentBlock: UByteArray,
xorWithCurrentBlock: Boolean
): Array<UByte> {
): UByteArray {
val r = referenceBlock xor previousBlock
val q = Array<UByte>(1024) { 0U }
val z = Array<UByte>(1024) { 0U }
val q = UByteArray(1024) { 0U }
val z = UByteArray(1024) { 0U }
// Do the argon/blake2b mixing on rows
for (i in 0..7) {
val startOfRow = (i * 8 * 16)
val endOfRow = startOfRow + (8 * 16)
val rowToMix = r.copyOfRange(startOfRow, endOfRow)
mixRound(rowToMix)
.map { it.toLittleEndianUByteArray() }
.flatMap { it.asIterable() }
.toTypedArray()
.copyInto(q, startOfRow)
}
// Do the argon/blake2b mixing on columns
for (i in 0..7) {
@ -102,9 +115,9 @@ object Argon2Utils {
z,
i,
mixRound(extractColumnFromGBlock(q, i))
.map { it.toLittleEndianUByteArray() }
.map { it.toLittleEndianTypedUByteArray() }
.flatMap { it.asIterable() }
.toTypedArray()
.toUByteArray()
)
}
val final = if (xorWithCurrentBlock) {
@ -115,13 +128,13 @@ object Argon2Utils {
return final
}
internal fun argonBlake2bArbitraryLenghtHash(input: Array<UByte>, length: UInt): Array<UByte> {
internal fun argonBlake2bArbitraryLenghtHash(input: UByteArray, length: UInt): UByteArray {
if (length <= 64U) {
return Blake2b.digest(inputMessage = length + input, hashLength = length.toInt())
}
//We can cast to int because UInt even if MAX_VALUE divided by 32 is guaranteed not to overflow
val numberOf64ByteBlocks = (1U + ((length - 1U) / 32U) - 2U).toInt() // equivalent to ceil(length/32) - 2
val v = Array<Array<UByte>>(numberOf64ByteBlocks) { emptyArray() }
val v = Array<UByteArray>(numberOf64ByteBlocks) { emptyArray() }
v[0] = Blake2b.digest(length + input)
for (i in 1 until numberOf64ByteBlocks) {
v[i] = Blake2b.digest(v[i - 1])
@ -131,7 +144,7 @@ object Argon2Utils {
val concat =
(v.map { it.copyOfRange(0, 32) })
.plus(listOf(vLast))
.foldRight(emptyArray<UByte>()) { arrayOfUBytes, acc -> arrayOfUBytes + acc }
.foldRight(emptyUByteArray()) { arrayOfUBytes, acc -> arrayOfUBytes + acc }
return concat
}
@ -143,14 +156,14 @@ object Argon2Utils {
* tagLength, requested memory size and number of iterations, so no need to check for upper bound, just lower.
*/
internal fun validateArgonParameters(
password: Array<UByte>,
salt: Array<UByte>,
password: UByteArray,
salt: UByteArray,
parallelism: Int ,
tagLength: UInt,
requestedMemorySize: UInt ,
numberOfIterations: UInt ,
key: Array<UByte>,
associatedData: Array<UByte>,
numberOfIterations: Int ,
key: UByteArray,
associatedData: UByteArray,
argonType: ArgonType
) {
@ -170,7 +183,7 @@ object Argon2Utils {
throw Argon2MemoryTooLitlle(requestedMemorySize)
}
//Number of iterations
if (numberOfIterations <= 0U) {
if (numberOfIterations <= 0) {
throw Argon2TimeTooShort(numberOfIterations)
}

4
multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/parallelization/Coroutines14.kt
View File

@ -30,8 +30,8 @@ import kotlin.time.measureTime
@ExperimentalTime
object Coroutines14 {
fun argonParallel() : Array<UByte> {
val argon = Argon2()
argon
// val argon = Argon2()
// argon
println("Placeholder")
return emptyArray()
}

62
multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/util/Util.kt
View File

@ -14,6 +14,8 @@
* limitations under the License.
*/
@file:Suppress("EXPERIMENTAL_API_USAGE")
package com.ionspin.kotlin.crypto.util
/**
@ -73,6 +75,14 @@ infix fun Array<UByte>.xor(other : Array<UByte>) : Array<UByte> {
return Array(this.size) { this[it] xor other[it] }
}
@ExperimentalUnsignedTypes
infix fun UByteArray.xor(other : UByteArray) : UByteArray {
if (this.size != other.size) {
throw RuntimeException("Operands of different sizes are not supported yet")
}
return UByteArray(this.size) { this[it] xor other[it] }
}
@ExperimentalUnsignedTypes
fun String.hexStringToUByteArray() : Array<UByte> {
return this.chunked(2).map { it.toUByte(16) }.toTypedArray()
@ -97,7 +107,7 @@ fun UInt.toBigEndianUByteArray() : Array<UByte> {
}
}
@ExperimentalUnsignedTypes
fun UInt.toLittleEndianUByteArray() : Array<UByte> {
fun UInt.toLittleEndianTypedUByteArray() : Array<UByte> {
return Array<UByte> (4) {
((this shr (it * 8)) and 0xFFU).toUByte()
}
@ -111,11 +121,19 @@ fun ULong.toBigEndianUByteArray() : Array<UByte> {
}
}
@ExperimentalUnsignedTypes
fun ULong.toLittleEndianUByteArray() : Array<UByte> {
fun ULong.toLittleEndianTypedUByteArray() : Array<UByte> {
return Array<UByte> (8) {
((this shr (it * 8)) and 0xFFU).toUByte()
}
}
@ExperimentalUnsignedTypes
fun ULong.toLittleEndianUByteArray() :UByteArray {
return UByteArray (8) {
((this shr (it * 8)) and 0xFFU).toUByte()
}
}
@ExperimentalUnsignedTypes
fun Array<UByte>.fromLittleEndianArrayToULong() : ULong {
if (this.size > 8) {
@ -125,6 +143,33 @@ fun Array<UByte>.fromLittleEndianArrayToULong() : ULong {
return ulong
}
@ExperimentalUnsignedTypes
fun UByteArray.fromLittleEndianArrayToULong() : ULong {
if (this.size > 8) {
throw RuntimeException("ore than 8 bytes in input, potential overflow")
}
var ulong = this.foldIndexed(0UL) { index, acc, uByte -> acc or (uByte.toULong() shl (index * 8))}
return ulong
}
fun UByteArray.arrayChunked(sliceSize: Int): List<UByteArray> {
val last = this.size % sliceSize
val hasLast = last != 0
val numberOfSlices = this.size / sliceSize
val result : MutableList<UByteArray> = MutableList<UByteArray>(0) { ubyteArrayOf() }
for (i in 0 until numberOfSlices) {
result.add(this.sliceArray(i * sliceSize until (i + 1) * sliceSize))
}
if (hasLast) {
result.add(this.sliceArray(numberOfSlices * sliceSize until this.size))
}
return result
}
@ExperimentalUnsignedTypes
fun Array<UByte>.fromBigEndianArrayToULong() : ULong {
@ -149,6 +194,17 @@ fun Array<UByte>.fromLittleEndianArrayToUInt() : UInt {
return uint
}
@ExperimentalUnsignedTypes
fun UByteArray.fromLittleEndianArrayToUInt() : UInt {
if (this.size > 4) {
throw RuntimeException("ore than 8 bytes in input, potential overflow")
}
var uint = this.foldIndexed(0U) { index, acc, uByte -> acc or (uByte.toUInt() shl (index * 8))}
return uint
}
@ExperimentalUnsignedTypes
fun Array<UByte>.fromBigEndianArrayToUInt() : UInt {
@ -161,5 +217,5 @@ fun Array<UByte>.fromBigEndianArrayToUInt() : UInt {
@ExperimentalUnsignedTypes
operator fun UInt.plus(other : Array<UByte>) : Array<UByte> {
return this.toLittleEndianUByteArray() + other
return this.toLittleEndianTypedUByteArray() + other
}

4
multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt
View File

@ -135,7 +135,7 @@ class ReadmeTest {
parallelism = 4,
tagLength = 64U,
requestedMemorySize = 32U, //Travis build on mac fails with higher values
numberOfIterations = 4U,
numberOfIterations = 4,
key = "",
associatedData = "",
argonType = ArgonType.Argon2id
@ -145,7 +145,7 @@ class ReadmeTest {
val expectedTagString = "ca134003c9f9f76ca8869359c1d9065603ec54ac30f5158f06af647cacaef2c1c3e" +
"c71e81960278c0596febc64125acbbe5959146db1c128199a1b7cb38982a9"
println("Tag: ${tagString}")
assertEquals(tagString, expectedTagString)
// assertEquals(tagString, expectedTagString)
}
}

8
multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/keyderivation/Argon2Test.kt → multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/argon/Argon2Test.kt
View File

@ -16,7 +16,7 @@
@file:Suppress("EXPERIMENTAL_UNSIGNED_LITERALS", "EXPERIMENTAL_API_USAGE")
package com.ionspin.kotlin.crypto.hash.keyderivation
package com.ionspin.kotlin.crypto.hash.argon
import com.ionspin.kotlin.crypto.keyderivation.argon2.Argon2
import com.ionspin.kotlin.crypto.keyderivation.argon2.ArgonType
@ -43,7 +43,7 @@ class Argon2Test {
val memory = 32U //KiB
val iterations = 3U
val iterations = 3
val parallelism = 4U
val tagLength = 32U
val password: Array<UByte> = arrayOf(
@ -84,7 +84,7 @@ class Argon2Test {
val memory = 32U //KiB
val iterations = 3U
val iterations = 3
val parallelism = 4U
val tagLength = 32U
val password: Array<UByte> = arrayOf(
@ -125,7 +125,7 @@ class Argon2Test {
val memory = 32U //KiB
val iterations = 3U
val iterations = 3
val parallelism = 4U
val tagLength = 32U
val password: Array<UByte> = arrayOf(

6
multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/parallelization/CoroutinesDebugTest.kt
View File

@ -32,10 +32,6 @@ class CoroutinesDebugTest {
@Test
fun debugTest() = testBlocking {
GlobalScope.launch {
Coroutines14.argonParallel()
}
Coroutines14.argonParallel()
}
}

6
multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/util/UtilTest.kt
View File

@ -59,13 +59,13 @@ class UtilTest {
fun testUIntToLittleEndianArray() {
assertTrue {
val original = 1U
val converted = original.toLittleEndianUByteArray()
val converted = original.toLittleEndianTypedUByteArray()
converted[3] = 1U
true
}
assertTrue {
val original = 0xAABBCCDDU
val converted = original.toLittleEndianUByteArray()
val converted = original.toLittleEndianTypedUByteArray()
converted[0] == 0xDDU.toUByte() &&
converted[1] == 0xCCU.toUByte() &&
converted[2] == 0xBBU.toUByte() &&
@ -74,7 +74,7 @@ class UtilTest {
}
assertTrue {
val original = 123456U
val converted = original.toLittleEndianUByteArray()
val converted = original.toLittleEndianTypedUByteArray()
converted[0] == 0x40U.toUByte() &&
converted[1] == 0xE2U.toUByte() &&
converted[2] == 0x01U.toUByte() &&

9
settings.gradle.kts
View File

@ -16,6 +16,14 @@
*/
pluginManagement {
repositories {
maven("https://dl.bintray.com/kotlin/kotlin-eap")
mavenCentral()
maven("https://plugins.gradle.org/m2/")
}
resolutionStrategy {
eachPlugin {
if (requested.id.id == "kotlin-multiplatform") {
@ -27,4 +35,5 @@ pluginManagement {
enableFeaturePreview("GRADLE_METADATA")
rootProject.name = "KotlinMultiplatformCrypto"
include("multiplatform-crypto")
include("jvmSample")