From 86dcd2316eff0ee130ab7771dcabc9630605e1e4 Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sat, 20 Jul 2019 20:02:37 +0200 Subject: [PATCH 1/6] Add build and maven shields --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 64ef26a..f232204 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,6 @@ +[![Build Status](https://travis-ci.com/ionspin/kotlin-multiplatform-crypto.svg?branch=master)](https://travis-ci.com/ionspin/kotlin-multiplatform-crypto) +![Maven Central](https://img.shields.io/maven-central/v/com.ionspin.kotlin/multiplatform-crypto.svg) + # Kotlin Multiplatform Crypto Library Kotlin Multiplatform Crypto is a library for various cryptographic applications. From 187282232ee6956afe793d1114c7730d1b5122ea Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sat, 20 Jul 2019 23:46:17 +0200 Subject: [PATCH 2/6] Added sha256 updateable mode --- .../com/ionspin/kotlin/crypto/sha/Sha256.kt | 278 ++++++++++++------ .../com/ionspin/kotlin/crypto/sha/Sha512.kt | 4 +- .../kotlin/crypto/sha/Sha256UpdateableTest.kt | 57 ++++ 3 files changed, 241 insertions(+), 98 deletions(-) create mode 100644 multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt index 2f506db..d8e49f6 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt @@ -29,11 +29,11 @@ import com.ionspin.kotlin.crypto.rotateRight @ExperimentalUnsignedTypes -class Sha256() : Hash { +class Sha256 : Hash { companion object { const val BLOCK_SIZE = 512 - const val W_SIZE = 64 + const val BLOCK_SIZE_IN_BYTES = 64 const val UINT_MASK = 0xFFFFFFFFU const val BYTE_MASK_FROM_ULONG = 0xFFUL const val BYTE_MASK_FROM_UINT = 0xFFU @@ -61,103 +61,37 @@ class Sha256() : Hash { ) @ExperimentalStdlibApi - fun digest(message : String) : Array { + fun digest(message: String): Array { return digest(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) } - fun digest(message: Array) : Array { + fun digest(message: Array): Array { - var h0 = 0x6a09e667U - var h1 = 0xbb67ae85U - var h2 = 0x3c6ef372U - var h3 = 0xa54ff53aU - var h4 = 0x510e527fU - var h5 = 0x9b05688cU - var h6 = 0x1f83d9abU - var h7 = 0x5be0cd19U + var h = iv.copyOf() - val originalMessageSizeInBits = message.size * 8 + val expansionArray = createExpansionArray(message.size) - - //K such that L + 1 + K + 64 is a multiple of 512 - val expandedRemainderOf512 = (originalMessageSizeInBits + 65) % BLOCK_SIZE - val zeroAddAmount = when (expandedRemainderOf512) { - 0 -> 0 - else -> (BLOCK_SIZE - expandedRemainderOf512) / 8 - } - val expansionArray = Array(zeroAddAmount + 1) { - when (it) { - 0 -> 0b10000000U //TODO This wont work if there the byte needs to be shared with the L (length) ULong - else -> 0U - } - } - - val chunks = (message + expansionArray + originalMessageSizeInBits.toULong().toPaddedByteArray()).chunked(64) + val chunks = ( + message + + expansionArray + + (message.size * 8).toULong().toPaddedByteArray() + ) + .chunked(BLOCK_SIZE_IN_BYTES) chunks.forEach { chunk -> - val w = Array(W_SIZE) { - when (it) { - in 0 until 16 -> { - var collected = (chunk[(it * 4)].toUInt() shl 24) + - (chunk[(it * 4) + 1].toUInt() shl 16 ) + - (chunk[(it * 4) + 2].toUInt() shl 8 ) + - (chunk[(it * 4) + 3].toUInt()) - collected - } - else -> 0U - } - } - for (i in 16 until W_SIZE) { - val s0 = scheduleSigma0(w[i - 15]) - val s1 = scheduleSigma1(w[i - 2]) - w[i] = w[i-16] + s0 + w[i - 7] + s1 - } - - var a = h0 - var b = h1 - var c = h2 - var d = h3 - var e = h4 - var f = h5 - var g = h6 - var h = h7 - - for (i in 0 until W_SIZE) { - val s1 = compressionSigma1(e) - val ch = ch(e, f, g) - val temp1 = h + s1 + ch + k[i] + w[i] - val s0 = compressionSigma0(a) - val maj = maj(a,b,c) - val temp2 = s0 + maj - h = g - g = f - f = e - e = d + temp1 - d = c - c = b - b = a - a = temp1 + temp2 - } - - h0 += a - h1 += b - h2 += c - h3 += d - h4 += e - h5 += f - h6 += g - h7 += h + val w = expandChunk(chunk) + mix(h, w).copyInto(h) } - val digest = h0.toPaddedByteArray() + - h1.toPaddedByteArray() + - h2.toPaddedByteArray() + - h3.toPaddedByteArray() + - h4.toPaddedByteArray() + - h5.toPaddedByteArray() + - h6.toPaddedByteArray() + - h7.toPaddedByteArray() + val digest = h[0].toPaddedByteArray() + + h[1].toPaddedByteArray() + + h[2].toPaddedByteArray() + + h[3].toPaddedByteArray() + + h[4].toPaddedByteArray() + + h[5].toPaddedByteArray() + + h[6].toPaddedByteArray() + + h[7].toPaddedByteArray() return digest } @@ -165,27 +99,104 @@ class Sha256() : Hash { return value.rotateRight(7) xor value.rotateRight(18) xor (value shr 3) } - private fun scheduleSigma1(value : UInt) : UInt { + private fun scheduleSigma1(value: UInt): UInt { return value.rotateRight(17) xor value.rotateRight(19) xor (value shr 10) } - private fun compressionSigma0(a : UInt) : UInt { - return (a rotateRight 2) xor (a rotateRight 13) xor (a rotateRight 22) + private fun compressionSigma0(a: UInt): UInt { + return (a rotateRight 2) xor (a rotateRight 13) xor (a rotateRight 22) } - private fun compressionSigma1(e : UInt) : UInt { - return (e rotateRight 6) xor (e rotateRight 11) xor (e rotateRight 25) + private fun compressionSigma1(e: UInt): UInt { + return (e rotateRight 6) xor (e rotateRight 11) xor (e rotateRight 25) } - private fun ch(x : UInt, y : UInt, z : UInt) : UInt { + private fun ch(x: UInt, y: UInt, z: UInt): UInt { return ((x and y) xor ((x xor UINT_MASK) and z)) } - private fun maj(x : UInt, y : UInt, z : UInt) : UInt { + private fun maj(x: UInt, y: UInt, z: UInt): UInt { return (((x and y) xor (x and z) xor (y and z))) } + private fun expandChunk(chunk: Array): Array { + val w = Array(BLOCK_SIZE_IN_BYTES) { + when (it) { + in 0 until 16 -> { + var collected = (chunk[(it * 4)].toUInt() shl 24) + + (chunk[(it * 4) + 1].toUInt() shl 16) + + (chunk[(it * 4) + 2].toUInt() shl 8) + + (chunk[(it * 4) + 3].toUInt()) + collected + } + else -> 0U + } + } + for (i in 16 until BLOCK_SIZE_IN_BYTES) { + val s0 = scheduleSigma0(w[i - 15]) + val s1 = scheduleSigma1(w[i - 2]) + w[i] = w[i - 16] + s0 + w[i - 7] + s1 + } + return w + } + private fun mix(h: Array, w: Array): Array { + var paramA = h[0] + var paramB = h[1] + var paramC = h[2] + var paramD = h[3] + var paramE = h[4] + var paramF = h[5] + var paramG = h[6] + var paramH = h[7] + + for (i in 0 until BLOCK_SIZE_IN_BYTES) { + val s1 = compressionSigma1(paramE) + val ch = ch(paramE, paramF, paramG) + val temp1 = paramH + s1 + ch + k[i] + w[i] + val s0 = compressionSigma0(paramA) + val maj = maj(paramA, paramB, paramC) + val temp2 = s0 + maj + paramH = paramG + paramG = paramF + paramF = paramE + paramE = paramD + temp1 + paramD = paramC + paramC = paramB + paramB = paramA + paramA = temp1 + temp2 + } + + h[0] += paramA + h[1] += paramB + h[2] += paramC + h[3] += paramD + h[4] += paramE + h[5] += paramF + h[6] += paramG + h[7] += paramH + return h + } + + + fun createExpansionArray(originalSizeInBytes : Int) : Array { + val originalMessageSizeInBits = originalSizeInBytes * 8 + + + //K such that L + 1 + K + 64 is a multiple of 512 + val expandedRemainderOf512 = (originalMessageSizeInBits + BLOCK_SIZE_IN_BYTES + 1) % BLOCK_SIZE + val zeroAddAmount = when (expandedRemainderOf512) { + 0 -> 0 + else -> (BLOCK_SIZE - expandedRemainderOf512) / 8 + } + val expansionArray = Array(zeroAddAmount + 1) { + when (it) { + 0 -> 0b10000000U + else -> 0U + } + } + return expansionArray + } private fun ULong.toPaddedByteArray(): Array { val byteMask = BYTE_MASK_FROM_ULONG @@ -219,10 +230,85 @@ class Sha256() : Hash { } + var h = iv.copyOf() + var counter = 0 + var bufferCounter = 0 + var buffer = Array(BLOCK_SIZE_IN_BYTES) { 0U } + + @ExperimentalStdlibApi + fun update(message: String) { + return update(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + } + + fun update(array: Array) { + if (array.isEmpty()) { + throw RuntimeException("Updating with empty array is not allowed. If you need empty hash, just call digest without updating") + } + + when { + bufferCounter + array.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(array, bufferCounter) + bufferCounter + array.size >= BLOCK_SIZE_IN_BYTES -> { + val chunked = array.chunked(BLOCK_SIZE_IN_BYTES) + chunked.forEach { chunk -> + if (bufferCounter + chunk.size < BLOCK_SIZE_IN_BYTES) { + appendToBuffer(chunk, bufferCounter) + } else { + chunk.copyInto( + destination = buffer, + destinationOffset = bufferCounter, + startIndex = 0, + endIndex = BLOCK_SIZE_IN_BYTES - bufferCounter + ) + counter += BLOCK_SIZE_IN_BYTES + consumeBlock(buffer) + buffer = Array(BLOCK_SIZE_IN_BYTES) { + when (it) { + in (0 until (chunk.size - (BLOCK_SIZE_IN_BYTES - bufferCounter))) -> { + chunk[it + (BLOCK_SIZE_IN_BYTES - bufferCounter)] + } + else -> { + 0U + } + } + + } + bufferCounter = chunk.size - (BLOCK_SIZE_IN_BYTES - bufferCounter) + } + } + + } + } + } + + private fun consumeBlock(block: Array) { + val w = expandChunk(block) + mix(h, w).copyInto(h) + } + + fun digest() : Array { + val length = counter + bufferCounter + val expansionArray = createExpansionArray(length) + val finalBlock = buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPaddedByteArray() + finalBlock.chunked(BLOCK_SIZE_IN_BYTES).forEach { + consumeBlock(it) + } + val digest = h[0].toPaddedByteArray() + + h[1].toPaddedByteArray() + + h[2].toPaddedByteArray() + + h[3].toPaddedByteArray() + + h[4].toPaddedByteArray() + + h[5].toPaddedByteArray() + + h[6].toPaddedByteArray() + + h[7].toPaddedByteArray() + return digest + } - + private fun appendToBuffer(array: Array, start: Int) { + array.copyInto(destination = buffer, destinationOffset = start, startIndex = 0, endIndex = array.size) + bufferCounter += array.size + } diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt index ba6a9f5..80dfcb7 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt @@ -146,14 +146,14 @@ class Sha512 : Hash { //K such that L + 1 + K + 64 is a multiple of 512 - val expandedRemainderOf1024 = (originalMessageSizeInBits + 129) % BLOCK_SIZE + val expandedRemainderOf1024 = (originalMessageSizeInBits + 130) % BLOCK_SIZE val zeroAddAmount = when (expandedRemainderOf1024) { 0 -> 0 else -> (BLOCK_SIZE - expandedRemainderOf1024) / 8 } val expansionArray = Array(zeroAddAmount + 1) { when (it) { - 0 -> 0b10000000U //TODO This wont work if there the byte needs to be shared with the L (length) ULong + 0 -> 0b10000000U else -> 0U } } diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt new file mode 100644 index 0000000..01a0dae --- /dev/null +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt @@ -0,0 +1,57 @@ +/* + * 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.sha + +import com.ionspin.kotlin.crypto.chunked +import kotlin.test.Test +import kotlin.test.assertTrue + +/** + * Created by Ugljesa Jovanovic + * ugljesa.jovanovic@ionspin.com + * on 17-Jul-2019 + */ +@ExperimentalUnsignedTypes +class Sha256UpdateableTest { + + @ExperimentalStdlibApi + @Test + fun testWellKnownValue() { + val sha256 = Sha256() + sha256.update("abc") + val result = sha256.digest() + val expectedResult = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" + assertTrue { + result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + + + } + + @ExperimentalStdlibApi + @Test + fun testWellKnownDoubleBlock() { + val sha256 = Sha256() + sha256.update(message = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") + val resultDoubleBlock = sha256.digest() + println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) + val expectedResultForDoubleBlock = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } +} \ No newline at end of file From 995cb23176a748a0308464b9ef89c32c303fcbe9 Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sun, 21 Jul 2019 00:55:11 +0200 Subject: [PATCH 3/6] Tests cleanup --- .../com/ionspin/kotlin/crypto/sha/Sha512.kt | 265 ++++++++++++------ .../ionspin/kotlin/crypto/sha/Sha256Test.kt | 27 ++ .../kotlin/crypto/sha/Sha256UpdateableTest.kt | 47 ++++ .../ionspin/kotlin/crypto/sha/Sha512Test.kt | 10 +- .../kotlin/crypto/sha/Sha512UpdateableTest.kt | 89 ++++++ 5 files changed, 345 insertions(+), 93 deletions(-) create mode 100644 multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt index 80dfcb7..9b5fffc 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt @@ -30,6 +30,8 @@ import com.ionspin.kotlin.crypto.rotateRight class Sha512 : Hash { companion object { const val BLOCK_SIZE = 1024 + const val BLOCK_SIZE_IN_BYTES = 128 + const val CHUNK_SIZE = 80 const val ULONG_MASK = 0xFFFFFFFFFFFFFFFFUL val k = arrayOf( @@ -133,102 +135,29 @@ class Sha512 : Hash { fun digest(message: Array): Array { - var h0 = 0x6a09e667f3bcc908UL - var h1 = 0xbb67ae8584caa73bUL - var h2 = 0x3c6ef372fe94f82bUL - var h3 = 0xa54ff53a5f1d36f1UL - var h4 = 0x510e527fade682d1UL - var h5 = 0x9b05688c2b3e6c1fUL - var h6 = 0x1f83d9abfb41bd6bUL - var h7 = 0x5be0cd19137e2179UL + var h = iv.copyOf() - val originalMessageSizeInBits = message.size * 8 - - - //K such that L + 1 + K + 64 is a multiple of 512 - val expandedRemainderOf1024 = (originalMessageSizeInBits + 130) % BLOCK_SIZE - val zeroAddAmount = when (expandedRemainderOf1024) { - 0 -> 0 - else -> (BLOCK_SIZE - expandedRemainderOf1024) / 8 - } - val expansionArray = Array(zeroAddAmount + 1) { - when (it) { - 0 -> 0b10000000U - else -> 0U - } - } + val expansionArray = createExpansionArray(message.size) val chunks = - (message + expansionArray + originalMessageSizeInBits.toULong().toPadded128BitByteArray()).chunked(128) + (message + expansionArray + (message.size * 8).toULong().toPadded128BitByteArray()).chunked( + BLOCK_SIZE_IN_BYTES) chunks.forEach { chunk -> - val w = Array(80) { - when (it) { - in 0 until 16 -> { - var collected = (chunk[(it * 8)].toULong() shl 56) + - (chunk[(it * 8) + 1].toULong() shl 48) + - (chunk[(it * 8) + 2].toULong() shl 40) + - (chunk[(it * 8) + 3].toULong() shl 32) + - (chunk[(it * 8) + 4].toULong() shl 24) + - (chunk[(it * 8) + 5].toULong() shl 16) + - (chunk[(it * 8) + 6].toULong() shl 8) + - (chunk[(it * 8) + 7].toULong()) - collected - } - else -> 0UL - } - } - for (i in 16 until 80) { - val s0 = scheduleSigma0(w[i - 15]) - val s1 = scheduleSigma1(w[i - 2]) - w[i] = w[i - 16] + s0 + w[i - 7] + s1 - } - - var a = h0 - var b = h1 - var c = h2 - var d = h3 - var e = h4 - var f = h5 - var g = h6 - var h = h7 - - for (i in 0 until 80) { - val s1 = compressionSigma1(e) - val ch = ch(e, f, g) - val temp1 = h + s1 + ch + k[i] + w[i] - val s0 = compressionSigma0(a) - val maj = maj(a, b, c) - val temp2 = s0 + maj - h = g - g = f - f = e - e = d + temp1 - d = c - c = b - b = a - a = temp1 + temp2 - } - - h0 += a - h1 += b - h2 += c - h3 += d - h4 += e - h5 += f - h6 += g - h7 += h + val w = expandChunk(chunk) + mix(h, w) } - val digest = h0.toPaddedByteArray() + - h1.toPaddedByteArray() + - h2.toPaddedByteArray() + - h3.toPaddedByteArray() + - h4.toPaddedByteArray() + - h5.toPaddedByteArray() + - h6.toPaddedByteArray() + - h7.toPaddedByteArray() + val digest = + h[0].toPaddedByteArray() + + h[1].toPaddedByteArray() + + h[2].toPaddedByteArray() + + h[3].toPaddedByteArray() + + h[4].toPaddedByteArray() + + h[5].toPaddedByteArray() + + h[6].toPaddedByteArray() + + h[7].toPaddedByteArray() return digest } @@ -256,6 +185,86 @@ class Sha512 : Hash { return ((x and y) xor (x and z) xor (y and z)) } + private fun expandChunk(chunk: Array): Array { + val w = Array(CHUNK_SIZE) { + when (it) { + in 0 until 16 -> { + var collected = (chunk[(it * 8)].toULong() shl 56) + + (chunk[(it * 8) + 1].toULong() shl 48) + + (chunk[(it * 8) + 2].toULong() shl 40) + + (chunk[(it * 8) + 3].toULong() shl 32) + + (chunk[(it * 8) + 4].toULong() shl 24) + + (chunk[(it * 8) + 5].toULong() shl 16) + + (chunk[(it * 8) + 6].toULong() shl 8) + + (chunk[(it * 8) + 7].toULong()) + collected + } + else -> 0UL + } + } + for (i in 16 until CHUNK_SIZE) { + val s0 = scheduleSigma0(w[i - 15]) + val s1 = scheduleSigma1(w[i - 2]) + w[i] = w[i - 16] + s0 + w[i - 7] + s1 + } + return w + } + + private fun mix(h: Array, w: Array): Array { + var paramA = h[0] + var paramB = h[1] + var paramC = h[2] + var paramD = h[3] + var paramE = h[4] + var paramF = h[5] + var paramG = h[6] + var paramH = h[7] + + for (i in 0 until CHUNK_SIZE) { + val s1 = compressionSigma1(paramE) + val ch = ch(paramE, paramF, paramG) + val temp1 = paramH + s1 + ch + k[i] + w[i] + val s0 = compressionSigma0(paramA) + val maj = maj(paramA, paramB, paramC) + val temp2 = s0 + maj + paramH = paramG + paramG = paramF + paramF = paramE + paramE = paramD + temp1 + paramD = paramC + paramC = paramB + paramB = paramA + paramA = temp1 + temp2 + } + + h[0] += paramA + h[1] += paramB + h[2] += paramC + h[3] += paramD + h[4] += paramE + h[5] += paramF + h[6] += paramG + h[7] += paramH + return h + } + + fun createExpansionArray(originalSizeInBytes : Int) : Array { + val originalMessageSizeInBits = originalSizeInBytes * 8 + + val expandedRemainderOf1024 = (originalMessageSizeInBits + 129) % BLOCK_SIZE + val zeroAddAmount = when (expandedRemainderOf1024) { + 0 -> 0 + else -> (BLOCK_SIZE - expandedRemainderOf1024) / 8 + } + val expansionArray = Array(zeroAddAmount + 1) { + when (it) { + 0 -> 0b10000000U + else -> 0U + } + } + return expansionArray + } + private fun ULong.toPaddedByteArray(): Array { val byteMask = 0xFFUL @@ -294,5 +303,85 @@ class Sha512 : Hash { } } + var h = iv.copyOf() + var counter = 0 + var bufferCounter = 0 + var buffer = Array(BLOCK_SIZE_IN_BYTES) { 0U } + + @ExperimentalStdlibApi + fun update(message: String) { + return update(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + } + + fun update(array: Array) { + if (array.isEmpty()) { + throw RuntimeException("Updating with empty array is not allowed. If you need empty hash, just call digest without updating") + } + + when { + bufferCounter + array.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(array, bufferCounter) + bufferCounter + array.size >= BLOCK_SIZE_IN_BYTES -> { + val chunked = array.chunked(BLOCK_SIZE_IN_BYTES) + chunked.forEach { chunk -> + if (bufferCounter + chunk.size < BLOCK_SIZE_IN_BYTES) { + appendToBuffer(chunk, bufferCounter) + } else { + chunk.copyInto( + destination = buffer, + destinationOffset = bufferCounter, + startIndex = 0, + endIndex = BLOCK_SIZE_IN_BYTES - bufferCounter + ) + counter += BLOCK_SIZE_IN_BYTES + consumeBlock(buffer) + buffer = Array(BLOCK_SIZE_IN_BYTES) { + when (it) { + in (0 until (chunk.size - (BLOCK_SIZE_IN_BYTES - bufferCounter))) -> { + chunk[it + (BLOCK_SIZE_IN_BYTES - bufferCounter)] + } + else -> { + 0U + } + } + + } + bufferCounter = chunk.size - (BLOCK_SIZE_IN_BYTES - bufferCounter) + } + } + + } + } + } + + private fun consumeBlock(block: Array) { + val w = expandChunk(block) + mix(h, w).copyInto(h) + } + + fun digest() : Array { + val length = counter + bufferCounter + val expansionArray = createExpansionArray(length) + val finalBlock = buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPadded128BitByteArray() + finalBlock.chunked(BLOCK_SIZE_IN_BYTES).forEach { + consumeBlock(it) + } + + + val digest = h[0].toPaddedByteArray() + + h[1].toPaddedByteArray() + + h[2].toPaddedByteArray() + + h[3].toPaddedByteArray() + + h[4].toPaddedByteArray() + + h[5].toPaddedByteArray() + + h[6].toPaddedByteArray() + + h[7].toPaddedByteArray() + return digest + } + + private fun appendToBuffer(array: Array, start: Int) { + array.copyInto(destination = buffer, destinationOffset = start, startIndex = 0, endIndex = array.size) + bufferCounter += array.size + } + } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt index 57507bd..505d05f 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt @@ -50,4 +50,31 @@ class Sha256Test { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) } } + + @ExperimentalStdlibApi + @Test + fun testWellKnown3() { //It's good that I'm consistent with names. + + + val resultDoubleBlock = Sha256.digest(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) + val expectedResultForDoubleBlock = "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @ExperimentalStdlibApi + @Test + fun testWellKnownLong() { + val inputBuilder = StringBuilder() + for (i in 0 until 1000000) { + inputBuilder.append("a") + } + val resultDoubleBlock = Sha256.digest(message = (inputBuilder.toString()).encodeToByteArray().map { it.toUByte() }.toTypedArray()) + val expectedResultForDoubleBlock = "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt index 01a0dae..9ba98cb 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt @@ -17,6 +17,7 @@ package com.ionspin.kotlin.crypto.sha import com.ionspin.kotlin.crypto.chunked +import kotlin.test.Ignore import kotlin.test.Test import kotlin.test.assertTrue @@ -54,4 +55,50 @@ class Sha256UpdateableTest { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) } } + + @ExperimentalStdlibApi + @Test + fun testWellKnown3() { //It's good that I'm consistent with names. + val sha256 = Sha256() + sha256.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + val resultDoubleBlock = sha256.digest() + println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) + val expectedResultForDoubleBlock = "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @ExperimentalStdlibApi + @Test + fun testWellKnownLong() { + val sha256 = Sha256() + for (i in 0 until 10000) { + sha256.update("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") + } + val resultDoubleBlock = sha256.digest() + val expectedResultForDoubleBlock = "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @Ignore() + @ExperimentalStdlibApi + @Test + fun testWellKnownLonger() { + val sha256 = Sha256() + for (i in 0 until 16_777_216) { + if (i % 10000 == 0) { + println("$i/16777216") + } + sha256.update("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno") + } + val resultDoubleBlock = sha256.digest() + val expectedResultForDoubleBlock = "50e72a0e26442fe2552dc3938ac58658228c0cbfb1d2ca872ae435266fcd055e" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + //50e72a0e 26442fe2 552dc393 8ac58658 228c0cbf b1d2ca87 2ae43526 6fcd055e } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt index 5a375e3..37d5c07 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt @@ -44,12 +44,12 @@ class Sha512Test { @ExperimentalUnsignedTypes @ExperimentalStdlibApi @Test - fun testWellKnownDoubleBlock() { - - val resultDoubleBlock = Sha512.digest(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn" + - "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + fun testWellKnown3() { + val sha512 = Sha512() + sha512.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + val resultDoubleBlock = sha512.digest() val expectedResultForDoubleBlock = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018" + - "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" + "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" assertTrue { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) } diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt new file mode 100644 index 0000000..bdcf195 --- /dev/null +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt @@ -0,0 +1,89 @@ +/* + * 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.sha + +import kotlin.test.Ignore +import kotlin.test.Test +import kotlin.test.assertTrue + +/** + * Created by Ugljesa Jovanovic + * ugljesa.jovanovic@ionspin.com + * on 21-Jul-2019 + */ +class Sha512UpdateableTest { + @ExperimentalStdlibApi + @Test + fun testWellKnownValue() { + val sha512 = Sha512() + sha512.update("abc") + val result = sha512.digest() + val expectedResult = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" + + "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" + assertTrue { + result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + + + } + + @ExperimentalStdlibApi + @Test + fun testWellKnownDoubleBlock() { + val sha512 = Sha512() + sha512.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + val resultDoubleBlock = sha512.digest() + println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) + val expectedResultForDoubleBlock = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018" + + "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @ExperimentalStdlibApi + @Test + fun testWellKnownLong() { + val sha512 = Sha512() + for (i in 0 until 10000) { + sha512.update("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") + } + val resultDoubleBlock = sha512.digest() + val expectedResultForDoubleBlock = "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @Ignore() //Interestingly enough I'm not the only one having trouble with this test. + @ExperimentalStdlibApi + @Test + fun testWellKnownLonger() { + val sha512 = Sha512() + for (i in 0 until 16_777_216) { + if (i % 10000 == 0) { + println("$i/16777216") + } + sha512.update("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno") + } + val resultDoubleBlock = sha512.digest() + val expectedResultForDoubleBlock = "b47c933421ea2db149ad6e10fce6c7f93d0752380180ffd7f4629a712134831d77be6091b819ed352c2967a2e2d4fa5050723c9630691f1a05a7281dbe6c1086" + assertTrue { + resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } +} \ No newline at end of file From 6d8024cf7f6c29f8785c66c46b33bbefb915cb93 Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sun, 21 Jul 2019 12:26:41 +0200 Subject: [PATCH 4/6] Extracted interfaces for hashes --- .../ionspin/kotlin/crypto/{ => hash}/Hash.kt | 29 +++++++- .../crypto/{ => hash}/blake2b/Blake2b.kt | 59 +++++++-------- .../kotlin/crypto/{ => hash}/sha/Sha256.kt | 61 +++++++++------- .../kotlin/crypto/{ => hash}/sha/Sha512.kt | 72 +++++++++++-------- .../com/ionspin/kotlin/crypto/ReadmeTest.kt | 10 +-- .../crypto/{ => hash}/blake2b/Blake2BTest.kt | 2 +- .../{ => hash}/blake2b/Blake2bInstanceTest.kt | 5 +- .../blake2b/Blake2bKnowAnswerTests.kt | 7 +- .../crypto/{ => hash}/sha/Sha256Test.kt | 10 +-- .../{ => hash}/sha/Sha256UpdateableTest.kt | 7 +- .../crypto/{ => hash}/sha/Sha512Test.kt | 8 +-- .../{ => hash}/sha/Sha512UpdateableTest.kt | 4 +- 12 files changed, 162 insertions(+), 112 deletions(-) rename multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/{ => hash}/Hash.kt (53%) rename multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/{ => hash}/blake2b/Blake2b.kt (87%) rename multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha256.kt (84%) rename multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha512.kt (84%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/blake2b/Blake2BTest.kt (99%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/blake2b/Blake2bInstanceTest.kt (94%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/blake2b/Blake2bKnowAnswerTests.kt (99%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha256Test.kt (81%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha256UpdateableTest.kt (91%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha512Test.kt (83%) rename multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/{ => hash}/sha/Sha512UpdateableTest.kt (94%) diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/Hash.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt similarity index 53% rename from multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/Hash.kt rename to multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt index 0a89f27..21add43 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/Hash.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt @@ -14,14 +14,37 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto +package com.ionspin.kotlin.crypto.hash + /** * Created by Ugljesa Jovanovic * ugljesa.jovanovic@ionspin.com * on 20-Jul-2019 */ -interface Hash +interface Hash { + val MAX_HASH_BYTES : Int +} -interface UpdateableHash : Hash +@ExperimentalUnsignedTypes +interface UpdateableHash : Hash { + fun update(data : Array) + + fun update(data : String) + + fun digest() : Array + + fun digestString() : String +} + +@ExperimentalUnsignedTypes +interface StatelessHash : Hash { + fun digest(inputString: String, key: String? = null, hashLength: Int = MAX_HASH_BYTES): Array + + fun digest( + inputMessage: Array = emptyArray(), + key: Array = emptyArray(), + hashLength: Int = MAX_HASH_BYTES + ): Array +} diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2b.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt similarity index 87% rename from multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2b.kt rename to multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt index 937ea57..5c435f7 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2b.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt @@ -14,14 +14,13 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.blake2b +package com.ionspin.kotlin.crypto.hash.blake2b import com.ionspin.kotlin.bignum.integer.BigInteger import com.ionspin.kotlin.bignum.integer.toBigInteger import com.ionspin.kotlin.crypto.* -import kotlinx.coroutines.CoroutineScope -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.Job +import com.ionspin.kotlin.crypto.hash.StatelessHash +import com.ionspin.kotlin.crypto.hash.UpdateableHash /** * Created by Ugljesa Jovanovic @@ -31,12 +30,13 @@ import kotlinx.coroutines.Job @ExperimentalUnsignedTypes class Blake2b(val key: Array? = null, val hashLength: Int = 64) : UpdateableHash { - companion object : Hash { + + companion object : StatelessHash { const val BITS_IN_WORD = 64 const val ROUNDS_IN_COMPRESS = 12 const val BLOCK_BYTES = 128 - const val MAX_HASH_BYTES = 64 + override val MAX_HASH_BYTES = 64 const val MIN_HASH_BYTES = 1 const val MAX_KEY_BYTES = 64 const val MIN_KEY_BYTES = 0 @@ -143,38 +143,39 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea } @ExperimentalStdlibApi - fun digest(inputString: String, key: String? = null): Array { - val chunked = inputString.encodeToByteArray().map { it.toUByte() }.toList().chunked(BLOCK_BYTES) - .map { it.toTypedArray() }.toTypedArray() + override fun digest(inputString: String, key: String?, hashLength: Int): Array { + val array = inputString.encodeToByteArray().map { it.toUByte() }.toList().toTypedArray() val keyBytes = key?.run { encodeToByteArray().map { it.toUByte() }.toTypedArray() } ?: emptyArray() - return digest(inputMessage = chunked, secretKey = keyBytes) + return digest(inputMessage = array, key = keyBytes) } - fun digest( - inputMessage: Array> = emptyArray(), - secretKey: Array = emptyArray(), - hashLength: Int = MAX_HASH_BYTES + override fun digest( + inputMessage: Array, + key: Array, + hashLength: Int ): Array { + val chunkedMessage = inputMessage.chunked(BLOCK_BYTES) + val h = iv.copyOf() - h[0] = h[0] xor 0x01010000UL xor (secretKey.size.toULong() shl 8) xor hashLength.toULong() + h[0] = h[0] xor 0x01010000UL xor (key.size.toULong() shl 8) xor hashLength.toULong() - val message = if (secretKey.isEmpty()) { - if (inputMessage.isEmpty()) { + val message = if (key.isEmpty()) { + if (chunkedMessage.isEmpty()) { Array(1) { Array(128) { 0U } } } else { - inputMessage + chunkedMessage } } else { - arrayOf(padToBlock(secretKey), *inputMessage) + arrayOf(padToBlock(key), *chunkedMessage) } if (message.size > 1) { @@ -246,6 +247,8 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea requestedHashLenght ) + override val MAX_HASH_BYTES: Int = Blake2b.MAX_HASH_BYTES + var h = iv.copyOf() var counter = BigInteger.ZERO var bufferCounter = 0 @@ -260,15 +263,15 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea } } - fun update(array: Array) { - if (array.isEmpty()) { + override fun update(data: Array) { + if (data.isEmpty()) { throw RuntimeException("Updating with empty array is not allowed. If you need empty hash, just call digest without updating") } when { - bufferCounter + array.size < BLOCK_BYTES -> appendToBuffer(array, bufferCounter) - bufferCounter + array.size >= BLOCK_BYTES -> { - val chunked = array.chunked(BLOCK_BYTES) + bufferCounter + data.size < BLOCK_BYTES -> appendToBuffer(data, bufferCounter) + bufferCounter + data.size >= BLOCK_BYTES -> { + val chunked = data.chunked(BLOCK_BYTES) chunked.forEach { chunk -> if (bufferCounter + chunk.size < BLOCK_BYTES) { appendToBuffer(chunk, bufferCounter) @@ -301,8 +304,8 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea } @ExperimentalStdlibApi - fun update(input: String) { - update(input.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + override fun update(data: String) { + update(data.encodeToByteArray().map { it.toUByte() }.toTypedArray()) } private fun appendToBuffer(array: Array, start: Int) { @@ -314,7 +317,7 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea h = compress(h, block, counter, false) } - fun digest(): Array { + override fun digest(): Array { val lastBlockPadded = padToBlock(buffer) counter += bufferCounter compress(h, lastBlockPadded, counter, true) @@ -325,7 +328,7 @@ class Blake2b(val key: Array? = null, val hashLength: Int = 64) : Updatea } - fun digestString(): String { + override fun digestString(): String { return digest().map { it.toString(16) }.joinToString(separator = "") } diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt similarity index 84% rename from multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt rename to multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt index d8e49f6..58e47c2 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha256.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt @@ -14,10 +14,11 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha -import com.ionspin.kotlin.crypto.Hash import com.ionspin.kotlin.crypto.chunked +import com.ionspin.kotlin.crypto.hash.StatelessHash +import com.ionspin.kotlin.crypto.hash.UpdateableHash import com.ionspin.kotlin.crypto.rotateRight @@ -29,15 +30,20 @@ import com.ionspin.kotlin.crypto.rotateRight @ExperimentalUnsignedTypes -class Sha256 : Hash { +class Sha256 : UpdateableHash { - companion object { + override val MAX_HASH_BYTES: Int = 32 + + + companion object : StatelessHash { const val BLOCK_SIZE = 512 const val BLOCK_SIZE_IN_BYTES = 64 const val UINT_MASK = 0xFFFFFFFFU const val BYTE_MASK_FROM_ULONG = 0xFFUL const val BYTE_MASK_FROM_UINT = 0xFFU + override val MAX_HASH_BYTES: Int = 32 + val iv = arrayOf( 0x6a09e667U, 0xbb67ae85U, @@ -61,22 +67,25 @@ class Sha256 : Hash { ) @ExperimentalStdlibApi - fun digest(message: String): Array { - return digest(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + override fun digest(inputString: String, key: String?, hashLength: Int): Array { + return digest( + inputString.encodeToByteArray().map { it.toUByte() }.toTypedArray(), + key?.run { encodeToByteArray().map { it.toUByte() }.toTypedArray() } ?: emptyArray(), + hashLength) } - fun digest(message: Array): Array { + override fun digest(inputMessage: Array, key: Array, hashLength: Int): Array { var h = iv.copyOf() - val expansionArray = createExpansionArray(message.size) + val expansionArray = createExpansionArray(inputMessage.size) val chunks = ( - message + - expansionArray + - (message.size * 8).toULong().toPaddedByteArray() - ) - .chunked(BLOCK_SIZE_IN_BYTES) + inputMessage + + expansionArray + + (inputMessage.size * 8).toULong().toPaddedByteArray() + ) + .chunked(BLOCK_SIZE_IN_BYTES) chunks.forEach { chunk -> val w = expandChunk(chunk) @@ -179,7 +188,7 @@ class Sha256 : Hash { } - fun createExpansionArray(originalSizeInBytes : Int) : Array { + fun createExpansionArray(originalSizeInBytes: Int): Array { val originalMessageSizeInBits = originalSizeInBytes * 8 @@ -236,19 +245,19 @@ class Sha256 : Hash { var buffer = Array(BLOCK_SIZE_IN_BYTES) { 0U } @ExperimentalStdlibApi - fun update(message: String) { - return update(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + override fun update(data: String) { + return update(data.encodeToByteArray().map { it.toUByte() }.toTypedArray()) } - fun update(array: Array) { - if (array.isEmpty()) { + override fun update(data: Array) { + if (data.isEmpty()) { throw RuntimeException("Updating with empty array is not allowed. If you need empty hash, just call digest without updating") } when { - bufferCounter + array.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(array, bufferCounter) - bufferCounter + array.size >= BLOCK_SIZE_IN_BYTES -> { - val chunked = array.chunked(BLOCK_SIZE_IN_BYTES) + bufferCounter + data.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(data, bufferCounter) + bufferCounter + data.size >= BLOCK_SIZE_IN_BYTES -> { + val chunked = data.chunked(BLOCK_SIZE_IN_BYTES) chunked.forEach { chunk -> if (bufferCounter + chunk.size < BLOCK_SIZE_IN_BYTES) { appendToBuffer(chunk, bufferCounter) @@ -285,10 +294,11 @@ class Sha256 : Hash { mix(h, w).copyInto(h) } - fun digest() : Array { + override fun digest(): Array { val length = counter + bufferCounter val expansionArray = createExpansionArray(length) - val finalBlock = buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPaddedByteArray() + val finalBlock = + buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPaddedByteArray() finalBlock.chunked(BLOCK_SIZE_IN_BYTES).forEach { consumeBlock(it) } @@ -305,11 +315,14 @@ class Sha256 : Hash { return digest } + override fun digestString(): String { + return digest().map { it.toString(16) }.joinToString(separator = "") + } + private fun appendToBuffer(array: Array, start: Int) { array.copyInto(destination = buffer, destinationOffset = start, startIndex = 0, endIndex = array.size) bufferCounter += array.size } - } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt similarity index 84% rename from multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt rename to multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt index 9b5fffc..95a934c 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/sha/Sha512.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt @@ -14,10 +14,11 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha -import com.ionspin.kotlin.crypto.Hash import com.ionspin.kotlin.crypto.chunked +import com.ionspin.kotlin.crypto.hash.StatelessHash +import com.ionspin.kotlin.crypto.hash.UpdateableHash import com.ionspin.kotlin.crypto.rotateRight /** @@ -27,13 +28,18 @@ import com.ionspin.kotlin.crypto.rotateRight */ @ExperimentalUnsignedTypes -class Sha512 : Hash { - companion object { +class Sha512 : UpdateableHash { + + override val MAX_HASH_BYTES: Int = 32 + + companion object : StatelessHash { const val BLOCK_SIZE = 1024 const val BLOCK_SIZE_IN_BYTES = 128 const val CHUNK_SIZE = 80 const val ULONG_MASK = 0xFFFFFFFFFFFFFFFFUL + override val MAX_HASH_BYTES: Int = 32 + val k = arrayOf( 0x428a2f98d728ae22UL, 0x7137449123ef65cdUL, @@ -129,19 +135,24 @@ class Sha512 : Hash { ) @ExperimentalStdlibApi - fun digest(message: String): Array { - return digest(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + override fun digest(inputString: String, key: String?, hashLength: Int): Array { + return digest( + inputString.encodeToByteArray().map { it.toUByte() }.toTypedArray(), + key?.run { encodeToByteArray().map { it.toUByte() }.toTypedArray() } ?: emptyArray(), + hashLength = hashLength + ) } - fun digest(message: Array): Array { + override fun digest(inputMessage: Array, key: Array, hashLength: Int): Array { var h = iv.copyOf() - val expansionArray = createExpansionArray(message.size) + val expansionArray = createExpansionArray(inputMessage.size) val chunks = - (message + expansionArray + (message.size * 8).toULong().toPadded128BitByteArray()).chunked( - BLOCK_SIZE_IN_BYTES) + (inputMessage + expansionArray + (inputMessage.size * 8).toULong().toPadded128BitByteArray()).chunked( + BLOCK_SIZE_IN_BYTES + ) chunks.forEach { chunk -> val w = expandChunk(chunk) @@ -150,14 +161,14 @@ class Sha512 : Hash { } val digest = - h[0].toPaddedByteArray() + - h[1].toPaddedByteArray() + - h[2].toPaddedByteArray() + - h[3].toPaddedByteArray() + - h[4].toPaddedByteArray() + - h[5].toPaddedByteArray() + - h[6].toPaddedByteArray() + - h[7].toPaddedByteArray() + h[0].toPaddedByteArray() + + h[1].toPaddedByteArray() + + h[2].toPaddedByteArray() + + h[3].toPaddedByteArray() + + h[4].toPaddedByteArray() + + h[5].toPaddedByteArray() + + h[6].toPaddedByteArray() + + h[7].toPaddedByteArray() return digest } @@ -248,7 +259,7 @@ class Sha512 : Hash { return h } - fun createExpansionArray(originalSizeInBytes : Int) : Array { + fun createExpansionArray(originalSizeInBytes: Int): Array { val originalMessageSizeInBits = originalSizeInBytes * 8 val expandedRemainderOf1024 = (originalMessageSizeInBits + 129) % BLOCK_SIZE @@ -309,19 +320,19 @@ class Sha512 : Hash { var buffer = Array(BLOCK_SIZE_IN_BYTES) { 0U } @ExperimentalStdlibApi - fun update(message: String) { - return update(message.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + override fun update(data: String) { + return update(data.encodeToByteArray().map { it.toUByte() }.toTypedArray()) } - fun update(array: Array) { - if (array.isEmpty()) { + override fun update(data: Array) { + if (data.isEmpty()) { throw RuntimeException("Updating with empty array is not allowed. If you need empty hash, just call digest without updating") } when { - bufferCounter + array.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(array, bufferCounter) - bufferCounter + array.size >= BLOCK_SIZE_IN_BYTES -> { - val chunked = array.chunked(BLOCK_SIZE_IN_BYTES) + bufferCounter + data.size < BLOCK_SIZE_IN_BYTES -> appendToBuffer(data, bufferCounter) + bufferCounter + data.size >= BLOCK_SIZE_IN_BYTES -> { + val chunked = data.chunked(BLOCK_SIZE_IN_BYTES) chunked.forEach { chunk -> if (bufferCounter + chunk.size < BLOCK_SIZE_IN_BYTES) { appendToBuffer(chunk, bufferCounter) @@ -358,10 +369,11 @@ class Sha512 : Hash { mix(h, w).copyInto(h) } - fun digest() : Array { + override fun digest(): Array { val length = counter + bufferCounter val expansionArray = createExpansionArray(length) - val finalBlock = buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPadded128BitByteArray() + val finalBlock = + buffer.copyOfRange(0, bufferCounter) + expansionArray + (length * 8).toULong().toPadded128BitByteArray() finalBlock.chunked(BLOCK_SIZE_IN_BYTES).forEach { consumeBlock(it) } @@ -378,6 +390,10 @@ class Sha512 : Hash { return digest } + override fun digestString(): String { + return digest().map { it.toString(16) }.joinToString(separator = "") + } + private fun appendToBuffer(array: Array, start: Int) { array.copyInto(destination = buffer, destinationOffset = start, startIndex = 0, endIndex = array.size) bufferCounter += array.size diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt index 4f39cf1..2a1d703 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt @@ -16,9 +16,9 @@ package com.ionspin.kotlin.crypto -import com.ionspin.kotlin.crypto.blake2b.Blake2b -import com.ionspin.kotlin.crypto.sha.Sha256 -import com.ionspin.kotlin.crypto.sha.Sha512 +import com.ionspin.kotlin.crypto.hash.blake2b.Blake2b +import com.ionspin.kotlin.crypto.hash.sha.Sha256 +import com.ionspin.kotlin.crypto.hash.sha.Sha512 import kotlin.test.Test import kotlin.test.assertTrue @@ -74,7 +74,7 @@ class ReadmeTest { @Test fun sha256Example() { val input ="abc" - val result = Sha256.digest(message = input) + val result = Sha256.digest(inputString = input) val expectedResult = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" assertTrue { result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) @@ -87,7 +87,7 @@ class ReadmeTest { @Test fun sha512Example() { val input ="abc" - val result = Sha512.digest(message = input.encodeToByteArray().map { it.toUByte() }.toTypedArray()) + val result = Sha512.digest(inputMessage = input.encodeToByteArray().map { it.toUByte() }.toTypedArray()) println(result.map {it.toString(16)}) val expectedResult = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" + "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2BTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2BTest.kt similarity index 99% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2BTest.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2BTest.kt index 5916900..d4bdd51 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2BTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2BTest.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.blake2b +package com.ionspin.kotlin.crypto.hash.blake2b import kotlin.test.Test import kotlin.test.assertTrue diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bInstanceTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt similarity index 94% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bInstanceTest.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt index 020232e..24f1181 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bInstanceTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt @@ -14,11 +14,8 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.blake2b +package com.ionspin.kotlin.crypto.hash.blake2b -import com.ionspin.kotlin.crypto.util.testBlocking -import kotlinx.coroutines.GlobalScope -import kotlinx.coroutines.launch import kotlin.test.Test import kotlin.test.assertTrue diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bKnowAnswerTests.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bKnowAnswerTests.kt similarity index 99% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bKnowAnswerTests.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bKnowAnswerTests.kt index ddfb35c..c1c4bab 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/blake2b/Blake2bKnowAnswerTests.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bKnowAnswerTests.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.blake2b +package com.ionspin.kotlin.crypto.hash.blake2b import kotlin.test.Test import kotlin.test.assertTrue @@ -37,10 +37,9 @@ class Blake2bKnowAnswerTests { fun knownAnswerTest() { kat.forEach { val parsedInput = it.input.chunked(2).map { it.toUByte(16) }.toTypedArray() - val chunkedInput = parsedInput.toList().chunked(128).map { it.toTypedArray() }.toTypedArray() val result = Blake2b.digest( - inputMessage = chunkedInput, - secretKey = it.key.chunked(2).map { it.toUByte(16) }.toTypedArray() + inputMessage = parsedInput, + key = it.key.chunked(2).map { it.toUByte(16) }.toTypedArray() ) assertTrue { result.contentEquals(it.hash.chunked(2).map { it.toUByte(16) }.toTypedArray()) diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256Test.kt similarity index 81% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256Test.kt index 505d05f..7aec043 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256Test.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256Test.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha import kotlin.test.Test import kotlin.test.assertTrue @@ -31,7 +31,7 @@ class Sha256Test { @Test fun testWellKnownValue() { - val result = Sha256.digest(message = "abc") + val result = Sha256.digest(inputString = "abc") val expectedResult = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" assertTrue { result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) @@ -44,7 +44,7 @@ class Sha256Test { @Test fun testWellKnownDoubleBlock() { - val resultDoubleBlock = Sha256.digest(message = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") + val resultDoubleBlock = Sha256.digest(inputString = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") val expectedResultForDoubleBlock = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" assertTrue { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) @@ -56,7 +56,7 @@ class Sha256Test { fun testWellKnown3() { //It's good that I'm consistent with names. - val resultDoubleBlock = Sha256.digest(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + val resultDoubleBlock = Sha256.digest(inputString = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) val expectedResultForDoubleBlock = "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1" assertTrue { @@ -71,7 +71,7 @@ class Sha256Test { for (i in 0 until 1000000) { inputBuilder.append("a") } - val resultDoubleBlock = Sha256.digest(message = (inputBuilder.toString()).encodeToByteArray().map { it.toUByte() }.toTypedArray()) + val resultDoubleBlock = Sha256.digest(inputMessage = (inputBuilder.toString()).encodeToByteArray().map { it.toUByte() }.toTypedArray()) val expectedResultForDoubleBlock = "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" assertTrue { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt similarity index 91% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt index 9ba98cb..8790573 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha256UpdateableTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt @@ -14,9 +14,8 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha -import com.ionspin.kotlin.crypto.chunked import kotlin.test.Ignore import kotlin.test.Test import kotlin.test.assertTrue @@ -47,7 +46,7 @@ class Sha256UpdateableTest { @Test fun testWellKnownDoubleBlock() { val sha256 = Sha256() - sha256.update(message = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") + sha256.update(data = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") val resultDoubleBlock = sha256.digest() println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) val expectedResultForDoubleBlock = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" @@ -60,7 +59,7 @@ class Sha256UpdateableTest { @Test fun testWellKnown3() { //It's good that I'm consistent with names. val sha256 = Sha256() - sha256.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + sha256.update(data = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") val resultDoubleBlock = sha256.digest() println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) val expectedResultForDoubleBlock = "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1" diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512Test.kt similarity index 83% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512Test.kt index 37d5c07..353c79d 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512Test.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512Test.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha import kotlin.test.Test import kotlin.test.assertTrue @@ -30,7 +30,7 @@ class Sha512Test { @Test fun testWellKnownValue() { - val result = Sha512.digest(message = "abc".encodeToByteArray().map { it.toUByte() }.toTypedArray()) + val result = Sha512.digest(inputMessage = "abc".encodeToByteArray().map { it.toUByte() }.toTypedArray()) println(result.map {it.toString(16)}) val expectedResult = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" + "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" @@ -46,7 +46,7 @@ class Sha512Test { @Test fun testWellKnown3() { val sha512 = Sha512() - sha512.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + sha512.update(data = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") val resultDoubleBlock = sha512.digest() val expectedResultForDoubleBlock = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018" + "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909" @@ -62,7 +62,7 @@ class Sha512Test { for (i in 0 until 1000000) { inputBuilder.append("a") } - val resultDoubleBlock = Sha512.digest(message = (inputBuilder.toString()).encodeToByteArray().map { it.toUByte() }.toTypedArray()) + val resultDoubleBlock = Sha512.digest(inputMessage = (inputBuilder.toString()).encodeToByteArray().map { it.toUByte() }.toTypedArray()) val expectedResultForDoubleBlock = "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b" assertTrue { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt similarity index 94% rename from multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt rename to multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt index bdcf195..19ecd40 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/sha/Sha512UpdateableTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.ionspin.kotlin.crypto.sha +package com.ionspin.kotlin.crypto.hash.sha import kotlin.test.Ignore import kotlin.test.Test @@ -45,7 +45,7 @@ class Sha512UpdateableTest { @Test fun testWellKnownDoubleBlock() { val sha512 = Sha512() - sha512.update(message = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") + sha512.update(data = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu") val resultDoubleBlock = sha512.digest() println(resultDoubleBlock.map{ it.toString(16)}.joinToString(separator = "")) val expectedResultForDoubleBlock = "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018" + From 91616fe0e058572cf7adea6d6dc2cb49221a4488 Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sun, 21 Jul 2019 12:36:10 +0200 Subject: [PATCH 5/6] Name and README update --- README.md | 36 +++++++++++++++---- .../com/ionspin/kotlin/crypto/hash/Hash.kt | 2 +- .../kotlin/crypto/hash/blake2b/Blake2b.kt | 4 +-- .../ionspin/kotlin/crypto/hash/sha/Sha256.kt | 4 +-- .../ionspin/kotlin/crypto/hash/sha/Sha512.kt | 4 +-- .../com/ionspin/kotlin/crypto/ReadmeTest.kt | 27 ++++++++++++++ .../hash/blake2b/Blake2bInstanceTest.kt | 2 +- .../crypto/hash/sha/Sha256UpdateableTest.kt | 5 +-- .../crypto/hash/sha/Sha512UpdateableTest.kt | 2 +- 9 files changed, 67 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index f232204..0aeaf5b 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ This is an extremely early release, currently only consisting of Blake2b and SHA **The API will move fast and break often until v1.0** -Make SHA hashes "updateable" like Blake2b +Make SHA hashes "updatable" like Blake2b After that tenative plan is to add 25519 curve based signing and key exchange next. @@ -48,11 +48,17 @@ implementation("com.ionspin.kotlin:crypto:0.0.1-SNAPSHOT") ## Usage -### Blake2b +### Hashes + +Hashes are provided in two versions, "stateless", usually the companion object of the hash, +which takes the data to be hashed in one go, and "updatable" which can be fed data in chunks. + + +#### Blake2b You can use Blake 2b in two modes -#### Using a `Blake2b` object +##### Stateless version You need to deliver the complete data that is to be hashed in one go ```kotlin @@ -62,9 +68,9 @@ val result = Blake2b.digest(input) Result is returned as a `Array` -#### Using a `Blake2b` instance +##### Updatable instance version You can create an instance and feed the data by using `update(input : Array)` call. Once all data is supplied, -you should call `digest()` or `digestString()` convinence method that converts the `Array` into hexadecimal string. +you should call `digest()` or `digestString()` convenience method that converts the `Array` into hexadecimal string. If you want to use Blake2b with a key, you should supply it when creating the `Blake2b` instance. @@ -77,7 +83,9 @@ val result = blake2b.digest() ``` After digest is called, the instance is reset and can be reused (Keep in mind key stays the same for the particular instance). -### SHA2 (SHA256 and SHA512) +#### SHA2 (SHA256 and SHA512) + +##### Stateless version You need to deliver the complete data that is to be hashed in one go. You can either provide the `Array` as input or `String`. Result is always returned as `Array` (At least in verision 0.0.1) @@ -94,6 +102,22 @@ val result = Sha512.digest(message = input.encodeToByteArray().map { it.toUByte( Result is returned as a `Array` +##### Updateable version + +Or you can use the updatable instance version + +```kotlin +val sha256 = Sha256() +sha256.update("abc") +val result = sha256.digest() +``` + +```kotlin +val sha512 = Sha512() +sha512.update("abc") +val result = sha512.digest() +``` + diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt index 21add43..23f9cfd 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/Hash.kt @@ -27,7 +27,7 @@ interface Hash { } @ExperimentalUnsignedTypes -interface UpdateableHash : Hash { +interface UpdatableHash : Hash { fun update(data : Array) fun update(data : String) diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt index 5c435f7..b462faa 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2b.kt @@ -20,7 +20,7 @@ import com.ionspin.kotlin.bignum.integer.BigInteger import com.ionspin.kotlin.bignum.integer.toBigInteger import com.ionspin.kotlin.crypto.* import com.ionspin.kotlin.crypto.hash.StatelessHash -import com.ionspin.kotlin.crypto.hash.UpdateableHash +import com.ionspin.kotlin.crypto.hash.UpdatableHash /** * Created by Ugljesa Jovanovic @@ -29,7 +29,7 @@ import com.ionspin.kotlin.crypto.hash.UpdateableHash */ @ExperimentalUnsignedTypes -class Blake2b(val key: Array? = null, val hashLength: Int = 64) : UpdateableHash { +class Blake2b(val key: Array? = null, val hashLength: Int = 64) : UpdatableHash { companion object : StatelessHash { diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt index 58e47c2..34995a7 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256.kt @@ -18,7 +18,7 @@ package com.ionspin.kotlin.crypto.hash.sha import com.ionspin.kotlin.crypto.chunked import com.ionspin.kotlin.crypto.hash.StatelessHash -import com.ionspin.kotlin.crypto.hash.UpdateableHash +import com.ionspin.kotlin.crypto.hash.UpdatableHash import com.ionspin.kotlin.crypto.rotateRight @@ -30,7 +30,7 @@ import com.ionspin.kotlin.crypto.rotateRight @ExperimentalUnsignedTypes -class Sha256 : UpdateableHash { +class Sha256 : UpdatableHash { override val MAX_HASH_BYTES: Int = 32 diff --git a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt index 95a934c..217175e 100644 --- a/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt +++ b/multiplatform-crypto/src/commonMain/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512.kt @@ -18,7 +18,7 @@ package com.ionspin.kotlin.crypto.hash.sha import com.ionspin.kotlin.crypto.chunked import com.ionspin.kotlin.crypto.hash.StatelessHash -import com.ionspin.kotlin.crypto.hash.UpdateableHash +import com.ionspin.kotlin.crypto.hash.UpdatableHash import com.ionspin.kotlin.crypto.rotateRight /** @@ -28,7 +28,7 @@ import com.ionspin.kotlin.crypto.rotateRight */ @ExperimentalUnsignedTypes -class Sha512 : UpdateableHash { +class Sha512 : UpdatableHash { override val MAX_HASH_BYTES: Int = 32 diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt index 2a1d703..ee449cb 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ReadmeTest.kt @@ -96,5 +96,32 @@ class ReadmeTest { } + } + + @ExperimentalStdlibApi + @Test + fun sha256UpdatableExample() { + val sha256 = Sha256() + sha256.update("abc") + val result = sha256.digest() + val expectedResult = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" + assertTrue { + result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + } + + @ExperimentalStdlibApi + @Test + fun sha512UpdatableExample() { + val sha512 = Sha512() + sha512.update("abc") + val result = sha512.digest() + val expectedResult = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" + + "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f" + assertTrue { + result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) + } + + } } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt index 24f1181..44eaaa0 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/blake2b/Blake2bInstanceTest.kt @@ -29,7 +29,7 @@ import kotlin.test.assertTrue class Blake2bInstanceTest { @Test - fun testUpdateableBlake2b() { + fun testUpdatableBlake2b() { val updates = 14 val input = "1234567890" val expectedResult = arrayOf( diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt index 8790573..620d2fd 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha256UpdateableTest.kt @@ -26,7 +26,7 @@ import kotlin.test.assertTrue * on 17-Jul-2019 */ @ExperimentalUnsignedTypes -class Sha256UpdateableTest { +class Sha256UpdatableTest { @ExperimentalStdlibApi @Test @@ -38,8 +38,6 @@ class Sha256UpdateableTest { assertTrue { result.contentEquals(expectedResult.chunked(2).map { it.toUByte(16) }.toTypedArray()) } - - } @ExperimentalStdlibApi @@ -99,5 +97,4 @@ class Sha256UpdateableTest { resultDoubleBlock.contentEquals(expectedResultForDoubleBlock.chunked(2).map { it.toUByte(16) }.toTypedArray()) } } - //50e72a0e 26442fe2 552dc393 8ac58658 228c0cbf b1d2ca87 2ae43526 6fcd055e } \ No newline at end of file diff --git a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt index 19ecd40..9facd3b 100644 --- a/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt +++ b/multiplatform-crypto/src/commonTest/kotlin/com/ionspin/kotlin/crypto/hash/sha/Sha512UpdateableTest.kt @@ -25,7 +25,7 @@ import kotlin.test.assertTrue * ugljesa.jovanovic@ionspin.com * on 21-Jul-2019 */ -class Sha512UpdateableTest { +class Sha512UpdatableTest { @ExperimentalStdlibApi @Test fun testWellKnownValue() { From 7489399501ddabb67e2abdc9b6b0f3abd4213548 Mon Sep 17 00:00:00 2001 From: Ugljesa Jovanovic Date: Sun, 21 Jul 2019 12:37:14 +0200 Subject: [PATCH 6/6] Changelog update --- CHANGELOG.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0d5abb8..e72430e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,10 @@ ## Descriptive changelog (All dates are DD.MM.YYYY) - +#### Updatable SHA hash implementation - 0.0.2 - 21.7.2019 +- Added "updatable" version for SHA +- Moved sha and blake to hash package +- Updated tests #### Initial release - 0.0.1 - 20.7.2019 - Implemented Blake2b and SHA256/512