Merge pull request #52 from Traderjoe95/feature/ristretto255
Add Ristretto255 Support
This commit is contained in:
Ugljesa Jovanovic
GitHub
commit
cf9094ebb2
9
.editorconfig
Normal file
9
.editorconfig
Normal file
@ -0,0 +1,9 @@
|
|||||||
|
# EditorConfig is awesome: https://editorconfig.org
|
||||||
|
|
||||||
|
# top-most EditorConfig file
|
||||||
|
root = true
|
||||||
|
|
||||||
|
[*.{kt,kts}]
|
||||||
|
indent_size = 4
|
||||||
|
indent_style = space
|
||||||
|
max_line_length = 120
|
||||||
@ -21,7 +21,6 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
|
|||||||
import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
|
import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
|
||||||
import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeTest
|
import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeTest
|
||||||
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
|
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
|
||||||
import org.jetbrains.dokka.Platform
|
|
||||||
|
|
||||||
plugins {
|
plugins {
|
||||||
kotlin(PluginsDeps.multiplatform)
|
kotlin(PluginsDeps.multiplatform)
|
||||||
@ -672,15 +671,16 @@ tasks {
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (getHostOsName() == "linux" && getHostArchitecture() == "x86-64") {
|
val jvmTest by getting(Test::class) {
|
||||||
val jvmTest by getting(Test::class) {
|
testLogging {
|
||||||
testLogging {
|
events("PASSED", "FAILED", "SKIPPED")
|
||||||
events("PASSED", "FAILED", "SKIPPED")
|
exceptionFormat = TestExceptionFormat.FULL
|
||||||
exceptionFormat = TestExceptionFormat.FULL
|
showStandardStreams = true
|
||||||
showStandardStreams = true
|
showStackTraces = true
|
||||||
showStackTraces = true
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (getHostOsName() == "linux" && getHostArchitecture() == "x86-64") {
|
||||||
|
|
||||||
val linuxX64Test by getting(KotlinNativeTest::class) {
|
val linuxX64Test by getting(KotlinNativeTest::class) {
|
||||||
|
|
||||||
|
|||||||
@ -0,0 +1,150 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ed25519
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.util.LibsodiumUtil
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Created by Johannes Leupold
|
||||||
|
* johannes.leupold@kobil.com
|
||||||
|
* on 12-Aug-2024
|
||||||
|
*/
|
||||||
|
|
||||||
|
const val crypto_core_ed25519_BYTES = 32
|
||||||
|
const val crypto_core_ed25519_UNIFORMBYTES = 32
|
||||||
|
const val crypto_core_ed25519_HASHBYTES = 64
|
||||||
|
const val crypto_core_ed25519_SCALARBYTES = 32
|
||||||
|
const val crypto_core_ed25519_NONREDUCEDSCALARBYTES = 64
|
||||||
|
|
||||||
|
const val crypto_scalarmult_ed25519_BYTES = 32U
|
||||||
|
const val crypto_scalarmult_ed25519_SCALARBYTES = 32U
|
||||||
|
|
||||||
|
expect object Ed25519LowLevel {
|
||||||
|
fun isValidPoint(encoded: UByteArray): Boolean
|
||||||
|
fun addPoints(p: UByteArray, q: UByteArray): UByteArray
|
||||||
|
fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray
|
||||||
|
fun pointFromUniform(uniform: UByteArray): UByteArray
|
||||||
|
fun randomPoint(): UByteArray
|
||||||
|
fun randomScalar(): UByteArray
|
||||||
|
fun invertScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun negateScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun complementScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun addScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun reduceScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplicationBase(n: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray
|
||||||
|
}
|
||||||
|
|
||||||
|
object Ed25519 {
|
||||||
|
data class Point(val encoded: UByteArray) {
|
||||||
|
companion object {
|
||||||
|
val IDENTITY: Point = Point(UByteArray(crypto_core_ed25519_BYTES))
|
||||||
|
val BASE: Point = multiplyBaseNoClamp(Scalar.ONE)
|
||||||
|
|
||||||
|
fun fromUniform(uniform: UByteArray): Point = Point(Ed25519LowLevel.pointFromUniform(uniform))
|
||||||
|
|
||||||
|
fun random(): Point = Point(Ed25519LowLevel.randomPoint())
|
||||||
|
|
||||||
|
fun multiplyBase(n: Scalar): Point = Point(Ed25519LowLevel.scalarMultiplicationBase(n.encoded))
|
||||||
|
|
||||||
|
fun multiplyBaseNoClamp(n: Scalar): Point =
|
||||||
|
Point(Ed25519LowLevel.scalarMultiplicationBaseNoClamp(n.encoded))
|
||||||
|
|
||||||
|
fun fromHex(hex: String): Point = Point(LibsodiumUtil.fromHex(hex))
|
||||||
|
}
|
||||||
|
|
||||||
|
val isValid: Boolean
|
||||||
|
get() = Ed25519LowLevel.isValidPoint(encoded)
|
||||||
|
|
||||||
|
operator fun plus(q: Point): Point = Point(Ed25519LowLevel.addPoints(this.encoded, q.encoded))
|
||||||
|
operator fun minus(q: Point): Point = Point(Ed25519LowLevel.subtractPoints(this.encoded, q.encoded))
|
||||||
|
|
||||||
|
operator fun times(n: Scalar): Point = Point(Ed25519LowLevel.scalarMultiplication(n.encoded, this.encoded))
|
||||||
|
fun times(n: Scalar, clamp: Boolean): Point =
|
||||||
|
if (clamp) times(n) else Point(Ed25519LowLevel.scalarMultiplicationNoClamp(n.encoded, this.encoded))
|
||||||
|
|
||||||
|
fun toHex(): String = LibsodiumUtil.toHex(encoded)
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean = (other as? Point)?.encoded?.contentEquals(encoded) == true
|
||||||
|
override fun hashCode(): Int = encoded.contentHashCode()
|
||||||
|
}
|
||||||
|
|
||||||
|
data class Scalar(val encoded: UByteArray) {
|
||||||
|
companion object {
|
||||||
|
val ZERO = fromUInt(0U)
|
||||||
|
val ONE = fromUInt(1U)
|
||||||
|
val TWO = fromUInt(2U)
|
||||||
|
|
||||||
|
fun random(): Scalar = Scalar(Ed25519LowLevel.randomScalar())
|
||||||
|
|
||||||
|
fun fromUInt(i: UInt): Scalar = fromULong(i.toULong())
|
||||||
|
|
||||||
|
fun fromULong(l: ULong): Scalar {
|
||||||
|
val encoded = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
var rem = l
|
||||||
|
|
||||||
|
for (i in 0..7) {
|
||||||
|
encoded[i] = (rem and 0xffU).toUByte()
|
||||||
|
rem = rem shr 8
|
||||||
|
}
|
||||||
|
|
||||||
|
return Scalar(encoded)
|
||||||
|
}
|
||||||
|
|
||||||
|
fun fromHex(hex: String): Scalar {
|
||||||
|
require(hex.length <= 2 * crypto_core_ed25519_NONREDUCEDSCALARBYTES) {
|
||||||
|
"Scalars must be at most $crypto_core_ed25519_NONREDUCEDSCALARBYTES bytes long"
|
||||||
|
}
|
||||||
|
|
||||||
|
if (hex.length > 2 * crypto_core_ed25519_SCALARBYTES) {
|
||||||
|
val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ed25519_NONREDUCEDSCALARBYTES, '0'))
|
||||||
|
// Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
|
||||||
|
// non-reduced scalar. After decoding, it is reduced, to obtain a scalar in the canonical range
|
||||||
|
return Scalar(Ed25519LowLevel.reduceScalar(encoded))
|
||||||
|
} else {
|
||||||
|
val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ed25519_SCALARBYTES, '0'))
|
||||||
|
// Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
|
||||||
|
// scalar.
|
||||||
|
return Scalar(encoded)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
operator fun plus(y: Scalar): Scalar = Scalar(Ed25519LowLevel.addScalars(this.encoded, y.encoded))
|
||||||
|
operator fun plus(y: UInt): Scalar = this + fromUInt(y)
|
||||||
|
operator fun plus(y: ULong): Scalar = this + fromULong(y)
|
||||||
|
|
||||||
|
operator fun minus(y: Scalar): Scalar = Scalar(Ed25519LowLevel.subtractScalars(this.encoded, y.encoded))
|
||||||
|
operator fun minus(y: UInt): Scalar = this - fromUInt(y)
|
||||||
|
operator fun minus(y: ULong): Scalar = this - fromULong(y)
|
||||||
|
|
||||||
|
operator fun times(y: Scalar): Scalar = Scalar(Ed25519LowLevel.multiplyScalars(this.encoded, y.encoded))
|
||||||
|
operator fun times(y: UInt): Scalar = this * fromUInt(y)
|
||||||
|
operator fun times(y: ULong): Scalar = this * fromULong(y)
|
||||||
|
|
||||||
|
operator fun div(y: Scalar): Scalar = times(y.invert())
|
||||||
|
operator fun div(y: UInt): Scalar = this / fromUInt(y)
|
||||||
|
operator fun div(y: ULong): Scalar = this / fromULong(y)
|
||||||
|
|
||||||
|
operator fun unaryMinus(): Scalar = Scalar(Ed25519LowLevel.negateScalar(this.encoded))
|
||||||
|
|
||||||
|
operator fun times(p: Point): Point = p.times(this)
|
||||||
|
fun times(p: Point, clamp: Boolean): Point =
|
||||||
|
if (clamp) p.times(this) else p.times(this, clamp)
|
||||||
|
|
||||||
|
fun reduce(): Scalar = Scalar(Ed25519LowLevel.reduceScalar(this.encoded))
|
||||||
|
fun invert(): Scalar = Scalar(Ed25519LowLevel.invertScalar(this.encoded))
|
||||||
|
fun complement(): Scalar = Scalar(Ed25519LowLevel.complementScalar(this.encoded))
|
||||||
|
|
||||||
|
fun multiplyWithBase(): Point = Point.multiplyBase(this)
|
||||||
|
|
||||||
|
fun multiplyWithBaseNoClamp(): Point = Point.multiplyBaseNoClamp(this)
|
||||||
|
|
||||||
|
fun toHex(): String = LibsodiumUtil.toHex(encoded)
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean = (other as? Scalar)?.encoded?.contentEquals(encoded) == true
|
||||||
|
override fun hashCode(): Int = encoded.contentHashCode()
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,141 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ristretto255
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.util.LibsodiumUtil
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Created by Johannes Leupold
|
||||||
|
* johannes.leupold@kobil.com
|
||||||
|
* on 12-Aug-2024
|
||||||
|
*/
|
||||||
|
|
||||||
|
const val crypto_core_ristretto255_BYTES = 32
|
||||||
|
const val crypto_core_ristretto255_HASHBYTES = 64
|
||||||
|
const val crypto_core_ristretto255_SCALARBYTES = 32
|
||||||
|
const val crypto_core_ristretto255_NONREDUCEDSCALARBYTES = 64
|
||||||
|
|
||||||
|
const val crypto_scalarmult_ristretto255_BYTES = 32U
|
||||||
|
const val crypto_scalarmult_ristretto255_SCALARBYTES = 32U
|
||||||
|
|
||||||
|
expect object Ristretto255LowLevel {
|
||||||
|
fun isValidPoint(encoded: UByteArray): Boolean
|
||||||
|
fun addPoints(p: UByteArray, q: UByteArray): UByteArray
|
||||||
|
fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray
|
||||||
|
fun pointFromHash(hash: UByteArray): UByteArray
|
||||||
|
fun randomPoint(): UByteArray
|
||||||
|
fun randomScalar(): UByteArray
|
||||||
|
fun invertScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun negateScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun complementScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun addScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray
|
||||||
|
fun reduceScalar(scalar: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray
|
||||||
|
fun scalarMultiplicationBase(n: UByteArray): UByteArray
|
||||||
|
}
|
||||||
|
|
||||||
|
object Ristretto255 {
|
||||||
|
data class Point(val encoded: UByteArray) {
|
||||||
|
companion object {
|
||||||
|
val IDENTITY: Point = Point(UByteArray(crypto_core_ristretto255_BYTES))
|
||||||
|
val BASE: Point = multiplyBase(Scalar.ONE)
|
||||||
|
|
||||||
|
fun fromHash(hash: UByteArray): Point = Point(Ristretto255LowLevel.pointFromHash(hash))
|
||||||
|
|
||||||
|
fun random(): Point = Point(Ristretto255LowLevel.randomPoint())
|
||||||
|
|
||||||
|
fun multiplyBase(n: Scalar): Point = Point(Ristretto255LowLevel.scalarMultiplicationBase(n.encoded))
|
||||||
|
|
||||||
|
fun fromHex(hex: String): Point = Point(LibsodiumUtil.fromHex(hex))
|
||||||
|
}
|
||||||
|
|
||||||
|
val isValid: Boolean
|
||||||
|
get() = Ristretto255LowLevel.isValidPoint(this.encoded)
|
||||||
|
|
||||||
|
operator fun plus(q: Point): Point = Point(Ristretto255LowLevel.addPoints(this.encoded, q.encoded))
|
||||||
|
operator fun minus(q: Point): Point = Point(Ristretto255LowLevel.subtractPoints(this.encoded, q.encoded))
|
||||||
|
|
||||||
|
operator fun times(n: Scalar): Point = Point(Ristretto255LowLevel.scalarMultiplication(n.encoded, this.encoded))
|
||||||
|
|
||||||
|
fun toHex(): String = LibsodiumUtil.toHex(encoded)
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean = (other as? Point)?.encoded?.contentEquals(encoded) == true
|
||||||
|
override fun hashCode(): Int = encoded.contentHashCode()
|
||||||
|
}
|
||||||
|
|
||||||
|
data class Scalar(val encoded: UByteArray) {
|
||||||
|
companion object {
|
||||||
|
val ZERO = fromUInt(0U)
|
||||||
|
val ONE = fromUInt(1U)
|
||||||
|
val TWO = fromUInt(2U)
|
||||||
|
|
||||||
|
fun random(): Scalar = Scalar(Ristretto255LowLevel.randomScalar())
|
||||||
|
|
||||||
|
fun fromUInt(i: UInt): Scalar = fromULong(i.toULong())
|
||||||
|
|
||||||
|
fun fromULong(l: ULong): Scalar {
|
||||||
|
val encoded = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
var rem = l
|
||||||
|
|
||||||
|
for (i in 0..7) {
|
||||||
|
encoded[i] = (rem and 0xffU).toUByte()
|
||||||
|
rem = rem shr 8
|
||||||
|
}
|
||||||
|
|
||||||
|
return Scalar(encoded)
|
||||||
|
}
|
||||||
|
|
||||||
|
fun fromHex(hex: String): Scalar {
|
||||||
|
require(hex.length <= 2 * crypto_core_ristretto255_NONREDUCEDSCALARBYTES) {
|
||||||
|
"Scalars must be at most $crypto_core_ristretto255_NONREDUCEDSCALARBYTES bytes long"
|
||||||
|
}
|
||||||
|
|
||||||
|
if (hex.length > 2 * crypto_core_ristretto255_SCALARBYTES) {
|
||||||
|
val encoded =
|
||||||
|
LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ristretto255_NONREDUCEDSCALARBYTES, '0'))
|
||||||
|
// Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
|
||||||
|
// non-reduced scalar. After decoding, it is reduced, to obtain a scalar in the canonical range
|
||||||
|
return Scalar(Ristretto255LowLevel.reduceScalar(encoded))
|
||||||
|
} else {
|
||||||
|
val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ristretto255_SCALARBYTES, '0'))
|
||||||
|
// Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
|
||||||
|
// scalar.
|
||||||
|
return Scalar(encoded)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
operator fun plus(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.addScalars(this.encoded, y.encoded))
|
||||||
|
operator fun plus(y: UInt): Scalar = this + fromUInt(y)
|
||||||
|
operator fun plus(y: ULong): Scalar = this + fromULong(y)
|
||||||
|
|
||||||
|
operator fun minus(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.subtractScalars(this.encoded, y.encoded))
|
||||||
|
operator fun minus(y: UInt): Scalar = this - fromUInt(y)
|
||||||
|
operator fun minus(y: ULong): Scalar = this - fromULong(y)
|
||||||
|
|
||||||
|
operator fun times(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.multiplyScalars(this.encoded, y.encoded))
|
||||||
|
operator fun times(y: UInt): Scalar = this * fromUInt(y)
|
||||||
|
operator fun times(y: ULong): Scalar = this * fromULong(y)
|
||||||
|
|
||||||
|
operator fun div(y: Scalar): Scalar =
|
||||||
|
Scalar(Ristretto255LowLevel.multiplyScalars(this.encoded, y.invert().encoded))
|
||||||
|
|
||||||
|
operator fun div(y: UInt): Scalar = this / fromUInt(y)
|
||||||
|
operator fun div(y: ULong): Scalar = this / fromULong(y)
|
||||||
|
|
||||||
|
operator fun unaryMinus(): Scalar = Scalar(Ristretto255LowLevel.negateScalar(this.encoded))
|
||||||
|
|
||||||
|
operator fun times(p: Point): Point = p.times(this)
|
||||||
|
|
||||||
|
fun reduce(): Scalar = Scalar(Ristretto255LowLevel.reduceScalar(this.encoded))
|
||||||
|
fun invert(): Scalar = Scalar(Ristretto255LowLevel.invertScalar(this.encoded))
|
||||||
|
fun complement(): Scalar = Scalar(Ristretto255LowLevel.complementScalar(this.encoded))
|
||||||
|
|
||||||
|
fun multiplyWithBase(): Point = Point.multiplyBase(this)
|
||||||
|
|
||||||
|
fun toHex(): String = LibsodiumUtil.toHex(encoded)
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean = (other as? Scalar)?.encoded?.contentEquals(encoded) == true
|
||||||
|
override fun hashCode(): Int = encoded.contentHashCode()
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,243 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ed25519
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.LibsodiumInitializer
|
||||||
|
import com.ionspin.kotlin.crypto.util.LibsodiumUtil
|
||||||
|
import com.ionspin.kotlin.crypto.util.runTest
|
||||||
|
import kotlin.test.Test
|
||||||
|
import kotlin.test.assertEquals
|
||||||
|
import kotlin.test.assertFalse
|
||||||
|
import kotlin.test.assertNotEquals
|
||||||
|
import kotlin.test.assertTrue
|
||||||
|
|
||||||
|
class Ed25519Test {
|
||||||
|
// Test vectors from https://github.com/jedisct1/libsodium/blob/master/test/default/core_ed25519.c
|
||||||
|
val badEncodings = arrayOf(
|
||||||
|
"0000000000000000000000000000000000000000000000000000000000000000",
|
||||||
|
"0100000000000000000000000000000000000000000000000000000000000000",
|
||||||
|
"0200000000000000000000000000000000000000000000000000000000000000",
|
||||||
|
// Non canonical encodings
|
||||||
|
"f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
"f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
)
|
||||||
|
|
||||||
|
// Test vectors generated with sodium.js
|
||||||
|
private val fromUniformTestVectors = arrayOf(
|
||||||
|
"d5d31a04bf9cd6b4f3f014ab57f95d439a0bd741e71f1ecb580143235545255e" to "cb9fff40134270e80e0dcfcdc66aa4ebf02cd27c9d9d26adfdf78d0012ad1b62",
|
||||||
|
"9d2e8fc82097672be7b3eb9b9ac74d0cd22087ce04a202a51e88702dceab88a1" to "6b1f76c95d2a201a25b77e73de875637e250acb8e22c44230b2c21bb5a45bb15",
|
||||||
|
"7863e96b9a73ffb45df22e2692f395d24b5d7acf745c5fa536818fd00e3ba6f6" to "43be765b38f32d815203e1657c261545366f15b24af2a97694b9320b4a36c407",
|
||||||
|
"1dfd309d25f6a2c6e0358cddf8dcf8c0fd018ccc7eb799d71fa829640cb5adb3" to "4c6b7015631f4063d85f3b195c7dfcb699a242b3449dc9b4abce8948df88a28e",
|
||||||
|
"40bc69ec71804975dfcbd90b18ca5d9d0117b2e15cacf61e21960b33742a9d55" to "722b608070036ad2e82927338c5edca18f2d0e6f8ed393321ed3704269af1f29",
|
||||||
|
"06c705d68c6224de01437208d7af2b3d933c1822abbe8f551b584cba073dc645" to "bb713b72bf705cc5a3daf299b787d28d47fdb39dc98a13082657b4137081624f",
|
||||||
|
"e4307d89b2e904063a6a16c9cf09b4225e0b5f4dd2367f08b11bf7787fa626d3" to "f10dea3347ab6792fac62ee6825dad3e4915f15287506db8067ecdbf00f0f30a",
|
||||||
|
"6f61fe548ff2cd7bc64d1d3cf4a707a8efba8247e906042d76e98b730f5d1d4d" to "5c43c14cb548b09ac8180c627bcf76bd7720aca21ef72cc13c5584e34ec23ff6",
|
||||||
|
)
|
||||||
|
|
||||||
|
// Test vectors generated with sodium.js
|
||||||
|
private val basePointSmallMultiplesNoClamp = arrayOf(
|
||||||
|
// This is the basepoint
|
||||||
|
"5866666666666666666666666666666666666666666666666666666666666666",
|
||||||
|
// These are small multiples of the basepoint
|
||||||
|
"c9a3f86aae465f0e56513864510f3997561fa2c9e85ea21dc2292309f3cd6022",
|
||||||
|
"d4b4f5784868c3020403246717ec169ff79e26608ea126a1ab69ee77d1b16712",
|
||||||
|
"2f1132ca61ab38dff00f2fea3228f24c6c71d58085b80e47e19515cb27e8d047",
|
||||||
|
"edc876d6831fd2105d0b4389ca2e283166469289146e2ce06faefe98b22548df",
|
||||||
|
"f47e49f9d07ad2c1606b4d94067c41f9777d4ffda709b71da1d88628fce34d85",
|
||||||
|
"b862409fb5c4c4123df2abf7462b88f041ad36dd6864ce872fd5472be363c5b1",
|
||||||
|
"b4b937fca95b2f1e93e41e62fc3c78818ff38a66096fad6e7973e5c90006d321",
|
||||||
|
"c0f1225584444ec730446e231390781ffdd2f256e9fcbeb2f40dddc2c2233d7f",
|
||||||
|
"2c7be86ab07488ba43e8e03d85a67625cfbf98c8544de4c877241b7aaafc7fe3",
|
||||||
|
"1337036ac32d8f30d4589c3c1c595812ce0fff40e37c6f5a97ab213f318290ad",
|
||||||
|
"f9e42d2edc81d23367967352b47e4856b82578634e6c1de72280ce8b60ce70c0",
|
||||||
|
"801f40eaaee1ef8723279a28b2cf4037b889dad222604678748b53ed0db0db92",
|
||||||
|
"39289c8998fd69835c26b619e89848a7bf02b7cb7ad1ba1581cbc4506f2550ce",
|
||||||
|
"df5c2eadc44c6d94a19a9aa118afe5ac3193d26401f76251f522ff042dfbcb92",
|
||||||
|
"eb2767c137ab7ad8279c078eff116ab0786ead3a2e0f989f72c37f82f2969670",
|
||||||
|
)
|
||||||
|
|
||||||
|
// Test vectors generated with sodium.js
|
||||||
|
// Because of clamping, the lowest three bits of the scalar are cleared to make it a multiple of the cofactor (8)
|
||||||
|
// This makes two scalars yield the same result if they only differ in the lowest three bits. Because of this, for
|
||||||
|
// these test vectors, the scalars used to obtain them are set to s = i * 4 + 1 where i is the index
|
||||||
|
val basePointSmallMultiplesClamped = arrayOf(
|
||||||
|
"693e47972caf527c7883ad1b39822f026f47db2ab0e1919955b8993aa04411d1",
|
||||||
|
"693e47972caf527c7883ad1b39822f026f47db2ab0e1919955b8993aa04411d1",
|
||||||
|
"c9877dfd1ccda6393a15aed8aba06798456798355f2a9da4e182fecd40290157",
|
||||||
|
"c9877dfd1ccda6393a15aed8aba06798456798355f2a9da4e182fecd40290157",
|
||||||
|
"33598cc739b5da481888220cc8d584ba6c385a4c489cb6305446fd78d591bd96",
|
||||||
|
"33598cc739b5da481888220cc8d584ba6c385a4c489cb6305446fd78d591bd96",
|
||||||
|
"b46a44945eaff85c6de56812f8b035f01f6680a6f37f74bc6aa992bd0ef2d32a",
|
||||||
|
"b46a44945eaff85c6de56812f8b035f01f6680a6f37f74bc6aa992bd0ef2d32a",
|
||||||
|
"31b532ff5943a5c73690714ceb6414b99d50b0daee2b2d994ea78adf7ac28f4f",
|
||||||
|
"31b532ff5943a5c73690714ceb6414b99d50b0daee2b2d994ea78adf7ac28f4f",
|
||||||
|
"140fcdae065d38753b1b563c61ab588da04e7b822a5575483d123fb96f30868d",
|
||||||
|
"140fcdae065d38753b1b563c61ab588da04e7b822a5575483d123fb96f30868d",
|
||||||
|
"cb920ec5b5ebcce941d7e84c9ade21d4628c2b020b3c32f7e1b07fbb825c145d",
|
||||||
|
"cb920ec5b5ebcce941d7e84c9ade21d4628c2b020b3c32f7e1b07fbb825c145d",
|
||||||
|
"d479546534fa8a146475623ca938efe42c6d561732088f8c3fd687ffff15210b",
|
||||||
|
"d479546534fa8a146475623ca938efe42c6d561732088f8c3fd687ffff15210b",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomPoint() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
val p = Ed25519.Point.random()
|
||||||
|
val q = Ed25519.Point.random()
|
||||||
|
val r = Ed25519.Point.random()
|
||||||
|
|
||||||
|
assertNotEquals(p, q)
|
||||||
|
assertNotEquals(q, r)
|
||||||
|
assertNotEquals(r, p)
|
||||||
|
|
||||||
|
assertTrue { p.isValid }
|
||||||
|
assertTrue { q.isValid }
|
||||||
|
assertTrue { r.isValid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointHexConversion() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val p = Ed25519.Point.random()
|
||||||
|
|
||||||
|
assertEquals(p, Ed25519.Point.fromHex(p.toHex()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testIsValidPoint() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for (hexEncoded in badEncodings) {
|
||||||
|
assertFalse { Ed25519.Point.fromHex(hexEncoded).isValid }
|
||||||
|
}
|
||||||
|
|
||||||
|
for (hexEncoded in basePointSmallMultiplesNoClamp) {
|
||||||
|
assertTrue { Ed25519.Point.fromHex(hexEncoded).isValid }
|
||||||
|
}
|
||||||
|
|
||||||
|
for (hexEncoded in basePointSmallMultiplesClamped) {
|
||||||
|
assertTrue { Ed25519.Point.fromHex(hexEncoded).isValid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointArithmeticNoClamp() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for (i in basePointSmallMultiplesNoClamp.indices) {
|
||||||
|
val p = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[i])
|
||||||
|
val b = Ed25519.Point.BASE
|
||||||
|
val n = Ed25519.Scalar.fromUInt(i.toUInt() + 1U)
|
||||||
|
|
||||||
|
assertEquals(p, Ed25519.Point.multiplyBaseNoClamp(n))
|
||||||
|
assertEquals(p, b.times(n, false))
|
||||||
|
assertEquals(p, n.multiplyWithBaseNoClamp())
|
||||||
|
|
||||||
|
for (j in 0..<i) {
|
||||||
|
val q = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[j])
|
||||||
|
val m = Ed25519.Scalar.fromUInt(i.toUInt() - j.toUInt())
|
||||||
|
|
||||||
|
assertEquals(p, q + b.times(m, clamp = false))
|
||||||
|
assertEquals(p, b.times(m, clamp = false) + q)
|
||||||
|
assertEquals(q, p - b.times(m, clamp = false))
|
||||||
|
}
|
||||||
|
|
||||||
|
for (j in i + 1..<basePointSmallMultiplesNoClamp.size) {
|
||||||
|
val q = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[j])
|
||||||
|
val m = Ed25519.Scalar.fromUInt(j.toUInt() - i.toUInt())
|
||||||
|
|
||||||
|
assertEquals(q, p + b.times(m, clamp = false))
|
||||||
|
assertEquals(q, b.times(m, clamp = false) + p)
|
||||||
|
assertEquals(p, q - b.times(m, clamp = false))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointArithmeticClamped() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for (i in basePointSmallMultiplesNoClamp.indices) {
|
||||||
|
println("i: $i")
|
||||||
|
val p = Ed25519.Point.fromHex(basePointSmallMultiplesClamped[i])
|
||||||
|
val b = Ed25519.Point.BASE
|
||||||
|
val n = Ed25519.Scalar.fromUInt(i.toUInt() * 4U + 1U)
|
||||||
|
|
||||||
|
assertEquals(p, Ed25519.Point.multiplyBase(n))
|
||||||
|
assertEquals(p, b.times(n))
|
||||||
|
assertEquals(p, n.multiplyWithBase())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointFromUniform() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for ((input, output) in fromUniformTestVectors) {
|
||||||
|
val outPoint = Ed25519.Point.fromHex(output)
|
||||||
|
val uniform = LibsodiumUtil.fromHex(input)
|
||||||
|
|
||||||
|
assertEquals(outPoint, Ed25519.Point.fromUniform(uniform))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomScalar() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
val x = Ed25519.Scalar.random()
|
||||||
|
val y = Ed25519.Scalar.random()
|
||||||
|
val z = Ed25519.Scalar.random()
|
||||||
|
|
||||||
|
assertNotEquals(x, y)
|
||||||
|
assertNotEquals(y, z)
|
||||||
|
assertNotEquals(z, x)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testScalarHexConversion() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val p = Ed25519.Scalar.random()
|
||||||
|
|
||||||
|
assertEquals(p, Ed25519.Scalar.fromHex(p.toHex()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testScalarArithmetic() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val x = Ed25519.Scalar.random()
|
||||||
|
val y = Ed25519.Scalar.random()
|
||||||
|
|
||||||
|
val xInv = x.invert()
|
||||||
|
val xComp = x.complement()
|
||||||
|
val xNeg = -x
|
||||||
|
|
||||||
|
assertEquals(Ed25519.Scalar.ZERO, x + xNeg)
|
||||||
|
assertEquals(Ed25519.Scalar.ZERO, xNeg + x)
|
||||||
|
assertEquals(Ed25519.Scalar.ZERO, x - x)
|
||||||
|
|
||||||
|
assertEquals(x, x + Ed25519.Scalar.ZERO)
|
||||||
|
assertEquals(x, Ed25519.Scalar.ZERO + x)
|
||||||
|
|
||||||
|
assertEquals(Ed25519.Scalar.ONE, x + xComp)
|
||||||
|
assertEquals(Ed25519.Scalar.ONE, xComp + x)
|
||||||
|
|
||||||
|
assertEquals(Ed25519.Scalar.ONE, x * xInv)
|
||||||
|
assertEquals(Ed25519.Scalar.ONE, xInv * x)
|
||||||
|
assertEquals(Ed25519.Scalar.ONE, x / x)
|
||||||
|
|
||||||
|
assertEquals(x, x * Ed25519.Scalar.ONE)
|
||||||
|
assertEquals(x, Ed25519.Scalar.ONE * x)
|
||||||
|
|
||||||
|
assertEquals(y - x, y + xNeg)
|
||||||
|
assertEquals(y / x, y * xInv)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,228 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ristretto255
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.LibsodiumInitializer
|
||||||
|
import com.ionspin.kotlin.crypto.hash.Hash
|
||||||
|
import com.ionspin.kotlin.crypto.util.encodeToUByteArray
|
||||||
|
import com.ionspin.kotlin.crypto.util.runTest
|
||||||
|
import kotlin.test.Test
|
||||||
|
import kotlin.test.assertEquals
|
||||||
|
import kotlin.test.assertFalse
|
||||||
|
import kotlin.test.assertNotEquals
|
||||||
|
import kotlin.test.assertTrue
|
||||||
|
|
||||||
|
class Ristretto255Test {
|
||||||
|
// Test vectors from https://ristretto.group/test_vectors/ristretto255.html
|
||||||
|
val badEncodings = arrayOf(
|
||||||
|
// These are all bad because they're non-canonical field encodings.
|
||||||
|
"00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||||
|
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
"f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
"edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
// These are all bad because they're negative field elements.
|
||||||
|
"0100000000000000000000000000000000000000000000000000000000000000",
|
||||||
|
"01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
|
||||||
|
"ed57ffd8c914fb201471d1c3d245ce3c746fcbe63a3679d51b6a516ebebe0e20",
|
||||||
|
"c34c4e1826e5d403b78e246e88aa051c36ccf0aafebffe137d148a2bf9104562",
|
||||||
|
"c940e5a4404157cfb1628b108db051a8d439e1a421394ec4ebccb9ec92a8ac78",
|
||||||
|
"47cfc5497c53dc8e61c91d17fd626ffb1c49e2bca94eed052281b510b1117a24",
|
||||||
|
"f1c6165d33367351b0da8f6e4511010c68174a03b6581212c71c0e1d026c3c72",
|
||||||
|
"87260f7a2f12495118360f02c26a470f450dadf34a413d21042b43b9d93e1309",
|
||||||
|
// These are all bad because they give a non-square x^2.
|
||||||
|
"26948d35ca62e643e26a83177332e6b6afeb9d08e4268b650f1f5bbd8d81d371",
|
||||||
|
"4eac077a713c57b4f4397629a4145982c661f48044dd3f96427d40b147d9742f",
|
||||||
|
"de6a7b00deadc788eb6b6c8d20c0ae96c2f2019078fa604fee5b87d6e989ad7b",
|
||||||
|
"bcab477be20861e01e4a0e295284146a510150d9817763caf1a6f4b422d67042",
|
||||||
|
"2a292df7e32cababbd9de088d1d1abec9fc0440f637ed2fba145094dc14bea08",
|
||||||
|
"f4a9e534fc0d216c44b218fa0c42d99635a0127ee2e53c712f70609649fdff22",
|
||||||
|
"8268436f8c4126196cf64b3c7ddbda90746a378625f9813dd9b8457077256731",
|
||||||
|
"2810e5cbc2cc4d4eece54f61c6f69758e289aa7ab440b3cbeaa21995c2f4232b",
|
||||||
|
// These are all bad because they give a negative xy value.
|
||||||
|
"3eb858e78f5a7254d8c9731174a94f76755fd3941c0ac93735c07ba14579630e",
|
||||||
|
"a45fdc55c76448c049a1ab33f17023edfb2be3581e9c7aade8a6125215e04220",
|
||||||
|
"d483fe813c6ba647ebbfd3ec41adca1c6130c2beeee9d9bf065c8d151c5f396e",
|
||||||
|
"8a2e1d30050198c65a54483123960ccc38aef6848e1ec8f5f780e8523769ba32",
|
||||||
|
"32888462f8b486c68ad7dd9610be5192bbeaf3b443951ac1a8118419d9fa097b",
|
||||||
|
"227142501b9d4355ccba290404bde41575b037693cef1f438c47f8fbf35d1165",
|
||||||
|
"5c37cc491da847cfeb9281d407efc41e15144c876e0170b499a96a22ed31e01e",
|
||||||
|
"445425117cb8c90edcbc7c1cc0e74f747f2c1efa5630a967c64f287792a48a4b",
|
||||||
|
// This is s = -1, which causes y = 0.
|
||||||
|
"ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Test vectors from https://ristretto.group/test_vectors/ristretto255.html
|
||||||
|
val fromHashTestVectors = arrayOf(
|
||||||
|
"Ristretto is traditionally a short shot of espresso coffee" to "3066f82a1a747d45120d1740f14358531a8f04bbffe6a819f86dfe50f44a0a46",
|
||||||
|
"made with the normal amount of ground coffee but extracted with" to "f26e5b6f7d362d2d2a94c5d0e7602cb4773c95a2e5c31a64f133189fa76ed61b",
|
||||||
|
"about half the amount of water in the same amount of time" to "006ccd2a9e6867e6a2c5cea83d3302cc9de128dd2a9a57dd8ee7b9d7ffe02826",
|
||||||
|
"by using a finer grind." to "f8f0c87cf237953c5890aec3998169005dae3eca1fbb04548c635953c817f92a",
|
||||||
|
"This produces a concentrated shot of coffee per volume." to "ae81e7dedf20a497e10c304a765c1767a42d6e06029758d2d7e8ef7cc4c41179",
|
||||||
|
"Just pulling a normal shot short will produce a weaker shot" to "e2705652ff9f5e44d3e841bf1c251cf7dddb77d140870d1ab2ed64f1a9ce8628",
|
||||||
|
"and is not a Ristretto as some believe." to "80bd07262511cdde4863f8a7434cef696750681cb9510eea557088f76d9e5065",
|
||||||
|
)
|
||||||
|
|
||||||
|
// Test vectors from https://ristretto.group/test_vectors/ristretto255.html
|
||||||
|
val basePointSmallMultiples = arrayOf(
|
||||||
|
// This is the basepoint
|
||||||
|
"e2f2ae0a6abc4e71a884a961c500515f58e30b6aa582dd8db6a65945e08d2d76",
|
||||||
|
// These are small multiples of the basepoint
|
||||||
|
"6a493210f7499cd17fecb510ae0cea23a110e8d5b901f8acadd3095c73a3b919",
|
||||||
|
"94741f5d5d52755ece4f23f044ee27d5d1ea1e2bd196b462166b16152a9d0259",
|
||||||
|
"da80862773358b466ffadfe0b3293ab3d9fd53c5ea6c955358f568322daf6a57",
|
||||||
|
"e882b131016b52c1d3337080187cf768423efccbb517bb495ab812c4160ff44e",
|
||||||
|
"f64746d3c92b13050ed8d80236a7f0007c3b3f962f5ba793d19a601ebb1df403",
|
||||||
|
"44f53520926ec81fbd5a387845beb7df85a96a24ece18738bdcfa6a7822a176d",
|
||||||
|
"903293d8f2287ebe10e2374dc1a53e0bc887e592699f02d077d5263cdd55601c",
|
||||||
|
"02622ace8f7303a31cafc63f8fc48fdc16e1c8c8d234b2f0d6685282a9076031",
|
||||||
|
"20706fd788b2720a1ed2a5dad4952b01f413bcf0e7564de8cdc816689e2db95f",
|
||||||
|
"bce83f8ba5dd2fa572864c24ba1810f9522bc6004afe95877ac73241cafdab42",
|
||||||
|
"e4549ee16b9aa03099ca208c67adafcafa4c3f3e4e5303de6026e3ca8ff84460",
|
||||||
|
"aa52e000df2e16f55fb1032fc33bc42742dad6bd5a8fc0be0167436c5948501f",
|
||||||
|
"46376b80f409b29dc2b5f6f0c52591990896e5716f41477cd30085ab7f10301e",
|
||||||
|
"e0c418f7c8d9c4cdd7395b93ea124f3ad99021bb681dfc3302a9d99a2e53e64e",
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomPoint() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
val p = Ristretto255.Point.random()
|
||||||
|
val q = Ristretto255.Point.random()
|
||||||
|
val r = Ristretto255.Point.random()
|
||||||
|
|
||||||
|
assertNotEquals(p, q)
|
||||||
|
assertNotEquals(q, r)
|
||||||
|
assertNotEquals(r, p)
|
||||||
|
|
||||||
|
|
||||||
|
assertTrue { p.isValid }
|
||||||
|
assertTrue { q.isValid }
|
||||||
|
assertTrue { r.isValid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointHexConversion() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val p = Ristretto255.Point.random()
|
||||||
|
|
||||||
|
assertEquals(p, Ristretto255.Point.fromHex(p.toHex()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testIsValidPoint() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for (hexEncoded in badEncodings) {
|
||||||
|
assertFalse { Ristretto255.Point.fromHex(hexEncoded).isValid }
|
||||||
|
}
|
||||||
|
|
||||||
|
for (hexEncoded in basePointSmallMultiples) {
|
||||||
|
assertTrue { Ristretto255.Point.fromHex(hexEncoded).isValid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointArithmetic() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for (i in basePointSmallMultiples.indices) {
|
||||||
|
val p = Ristretto255.Point.fromHex(basePointSmallMultiples[i])
|
||||||
|
val b = Ristretto255.Point.BASE
|
||||||
|
val n = Ristretto255.Scalar.fromUInt(i.toUInt() + 1U)
|
||||||
|
|
||||||
|
assertEquals(p, Ristretto255.Point.multiplyBase(n))
|
||||||
|
assertEquals(p, b.times(n))
|
||||||
|
assertEquals(p, n.multiplyWithBase())
|
||||||
|
|
||||||
|
for (j in 0..<i) {
|
||||||
|
val q = Ristretto255.Point.fromHex(basePointSmallMultiples[j])
|
||||||
|
val m = Ristretto255.Scalar.fromUInt(i.toUInt() - j.toUInt())
|
||||||
|
|
||||||
|
assertEquals(p, q + b * m)
|
||||||
|
assertEquals(p, b * m + q)
|
||||||
|
assertEquals(q, p - b * m)
|
||||||
|
}
|
||||||
|
|
||||||
|
for (j in i + 1..<basePointSmallMultiples.size) {
|
||||||
|
val q = Ristretto255.Point.fromHex(basePointSmallMultiples[j])
|
||||||
|
val m = Ristretto255.Scalar.fromUInt(j.toUInt() - i.toUInt())
|
||||||
|
|
||||||
|
assertEquals(q, p + b * m)
|
||||||
|
assertEquals(q, b * m + p)
|
||||||
|
assertEquals(p, q - b * m)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testPointFromHash() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
for ((input, output) in fromHashTestVectors) {
|
||||||
|
val outPoint = Ristretto255.Point.fromHex(output)
|
||||||
|
val hash = Hash.sha512(input.encodeToUByteArray())
|
||||||
|
|
||||||
|
assertEquals(outPoint, Ristretto255.Point.fromHash(hash))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomScalar() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
val x = Ristretto255.Scalar.random()
|
||||||
|
val y = Ristretto255.Scalar.random()
|
||||||
|
val z = Ristretto255.Scalar.random()
|
||||||
|
|
||||||
|
assertNotEquals(x, y)
|
||||||
|
assertNotEquals(y, z)
|
||||||
|
assertNotEquals(z, x)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testScalarHexConversion() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val p = Ristretto255.Scalar.random()
|
||||||
|
|
||||||
|
assertEquals(p, Ristretto255.Scalar.fromHex(p.toHex()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testScalarArithmetic() = runTest {
|
||||||
|
LibsodiumInitializer.initializeWithCallback {
|
||||||
|
repeat(10) {
|
||||||
|
val x = Ristretto255.Scalar.random()
|
||||||
|
val y = Ristretto255.Scalar.random()
|
||||||
|
|
||||||
|
val xInv = x.invert()
|
||||||
|
val xComp = x.complement()
|
||||||
|
val xNeg = -x
|
||||||
|
|
||||||
|
assertEquals(Ristretto255.Scalar.ZERO, x + xNeg)
|
||||||
|
assertEquals(Ristretto255.Scalar.ZERO, xNeg + x)
|
||||||
|
assertEquals(Ristretto255.Scalar.ZERO, x - x)
|
||||||
|
|
||||||
|
assertEquals(x, x + Ristretto255.Scalar.ZERO)
|
||||||
|
assertEquals(x, Ristretto255.Scalar.ZERO + x)
|
||||||
|
|
||||||
|
assertEquals(Ristretto255.Scalar.ONE, x + xComp)
|
||||||
|
assertEquals(Ristretto255.Scalar.ONE, xComp + x)
|
||||||
|
|
||||||
|
assertEquals(Ristretto255.Scalar.ONE, x * xInv)
|
||||||
|
assertEquals(Ristretto255.Scalar.ONE, xInv * x)
|
||||||
|
assertEquals(Ristretto255.Scalar.ONE, x / x)
|
||||||
|
|
||||||
|
assertEquals(x, x * Ristretto255.Scalar.ONE)
|
||||||
|
assertEquals(x, Ristretto255.Scalar.ONE * x)
|
||||||
|
|
||||||
|
assertEquals(y - x, y + xNeg)
|
||||||
|
assertEquals(y / x, y * xInv)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -363,5 +363,112 @@ external object JsSodiumInterface {
|
|||||||
// ---- Scalar multiplication end ----
|
// ---- Scalar multiplication end ----
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// ---- Ristretto255 ----
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_is_valid_point")
|
||||||
|
fun crypto_core_ristretto255_is_valid_point(p: Uint8Array): Boolean
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_random")
|
||||||
|
fun crypto_core_ristretto255_random(): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_from_hash")
|
||||||
|
fun crypto_core_ristretto255_from_hash(r: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_add")
|
||||||
|
fun crypto_core_ristretto255_add(p: Uint8Array, q: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_sub")
|
||||||
|
fun crypto_core_ristretto255_sub(p: Uint8Array, q: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_random")
|
||||||
|
fun crypto_core_ristretto255_scalar_random(): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_reduce")
|
||||||
|
fun crypto_core_ristretto255_scalar_reduce(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_invert")
|
||||||
|
fun crypto_core_ristretto255_scalar_invert(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_negate")
|
||||||
|
fun crypto_core_ristretto255_scalar_negate(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_complement")
|
||||||
|
fun crypto_core_ristretto255_scalar_complement(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_add")
|
||||||
|
fun crypto_core_ristretto255_scalar_add(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_sub")
|
||||||
|
fun crypto_core_ristretto255_scalar_sub(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ristretto255_scalar_mul")
|
||||||
|
fun crypto_core_ristretto255_scalar_mul(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ristretto255")
|
||||||
|
fun crypto_scalarmult_ristretto255(n: Uint8Array, p: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ristretto255_base")
|
||||||
|
fun crypto_scalarmult_ristretto255_base(n: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
//
|
||||||
|
// ---- Ristretto255 end ----
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// ---- Ed25519 ----
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_is_valid_point")
|
||||||
|
fun crypto_core_ed25519_is_valid_point(p: Uint8Array): Boolean
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_random")
|
||||||
|
fun crypto_core_ed25519_random(): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_from_uniform")
|
||||||
|
fun crypto_core_ed25519_from_uniform(r: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_add")
|
||||||
|
fun crypto_core_ed25519_add(p: Uint8Array, q: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_sub")
|
||||||
|
fun crypto_core_ed25519_sub(p: Uint8Array, q: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_random")
|
||||||
|
fun crypto_core_ed25519_scalar_random(): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_reduce")
|
||||||
|
fun crypto_core_ed25519_scalar_reduce(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_invert")
|
||||||
|
fun crypto_core_ed25519_scalar_invert(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_negate")
|
||||||
|
fun crypto_core_ed25519_scalar_negate(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_complement")
|
||||||
|
fun crypto_core_ed25519_scalar_complement(s: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_add")
|
||||||
|
fun crypto_core_ed25519_scalar_add(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_sub")
|
||||||
|
fun crypto_core_ed25519_scalar_sub(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_core_ed25519_scalar_mul")
|
||||||
|
fun crypto_core_ed25519_scalar_mul(x: Uint8Array, y: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ed25519")
|
||||||
|
fun crypto_scalarmult_ed25519(n: Uint8Array, p: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ed25519_noclamp")
|
||||||
|
fun crypto_scalarmult_ed25519_noclamp(n: Uint8Array, p: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ed25519_base")
|
||||||
|
fun crypto_scalarmult_ed25519_base(n: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
@JsName("crypto_scalarmult_ed25519_base_noclamp")
|
||||||
|
fun crypto_scalarmult_ed25519_base_noclamp(n: Uint8Array): Uint8Array
|
||||||
|
|
||||||
|
//
|
||||||
|
// ---- Ed25519 end ----
|
||||||
}
|
}
|
||||||
|
|||||||
@ -0,0 +1,106 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ed25519
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.getSodium
|
||||||
|
import ext.libsodium.com.ionspin.kotlin.crypto.toUByteArray
|
||||||
|
import ext.libsodium.com.ionspin.kotlin.crypto.toUInt8Array
|
||||||
|
|
||||||
|
actual object Ed25519LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean =
|
||||||
|
getSodium().crypto_core_ed25519_is_valid_point(encoded.toUInt8Array())
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_add(p.toUInt8Array(), q.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_sub(p.toUInt8Array(), q.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromUniform(uniform: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_from_uniform(uniform.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_random()
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_random()
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_invert(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_negate(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_complement(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_add(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_sub(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_mul(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ed25519_scalar_reduce(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ed25519(n.toUInt8Array(), p.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ed25519_noclamp(n.toUInt8Array(), p.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ed25519_base(n.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ed25519_base_noclamp(n.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,94 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ristretto255
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.getSodium
|
||||||
|
import ext.libsodium.com.ionspin.kotlin.crypto.toUByteArray
|
||||||
|
import ext.libsodium.com.ionspin.kotlin.crypto.toUInt8Array
|
||||||
|
|
||||||
|
actual object Ristretto255LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean =
|
||||||
|
getSodium().crypto_core_ristretto255_is_valid_point(encoded.toUInt8Array())
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_add(p.toUInt8Array(), q.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_sub(p.toUInt8Array(), q.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromHash(hash: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_from_hash(hash.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_random()
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_random()
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_invert(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_negate(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_complement(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_add(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_sub(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_mul(x.toUInt8Array(), y.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_core_ristretto255_scalar_reduce(scalar.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ristretto255(n.toUInt8Array(), p.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = getSodium().crypto_scalarmult_ristretto255_base(n.toUInt8Array())
|
||||||
|
|
||||||
|
return result.toUByteArray()
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1293,4 +1293,80 @@ interface JnaLibsodiumInterface : Library {
|
|||||||
fun crypto_scalarmult_base(q: ByteArray, b: ByteArray): Int
|
fun crypto_scalarmult_base(q: ByteArray, b: ByteArray): Int
|
||||||
//
|
//
|
||||||
// // ---- Scalar multiplication end ----
|
// // ---- Scalar multiplication end ----
|
||||||
|
|
||||||
|
//
|
||||||
|
// // ---- Ristretto255 ----
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_is_valid_point(p: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_random(p: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_from_hash(p: ByteArray, r: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_add(r: ByteArray, p: ByteArray, q: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_sub(r: ByteArray, p: ByteArray, q: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_random(r: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_reduce(r: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_invert(recip: ByteArray, s: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_negate(neg: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_complement(comp: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_add(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_sub(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ristretto255_scalar_mul(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ristretto255(q: ByteArray, n: ByteArray, p: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ristretto255_base(q: ByteArray, n: ByteArray): Int
|
||||||
|
|
||||||
|
//
|
||||||
|
// // ---- Ristretto255 end ----
|
||||||
|
|
||||||
|
//
|
||||||
|
// // ---- Ed25519 ----
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_is_valid_point(p: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_random(p: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_from_uniform(p: ByteArray, r: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_add(r: ByteArray, p: ByteArray, q: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_sub(r: ByteArray, p: ByteArray, q: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_random(r: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_reduce(r: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_invert(recip: ByteArray, s: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_negate(neg: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_complement(comp: ByteArray, s: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_add(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_sub(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_core_ed25519_scalar_mul(z: ByteArray, x: ByteArray, y: ByteArray)
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ed25519(q: ByteArray, n: ByteArray, p: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ed25519_noclamp(q: ByteArray, n: ByteArray, p: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ed25519_base(q: ByteArray, n: ByteArray): Int
|
||||||
|
|
||||||
|
fun crypto_scalarmult_ed25519_base_noclamp(q: ByteArray, n: ByteArray): Int
|
||||||
|
|
||||||
|
//
|
||||||
|
// // ---- Ed25519 end ----
|
||||||
}
|
}
|
||||||
|
|||||||
@ -0,0 +1,136 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ed25519
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
|
||||||
|
import com.ionspin.kotlin.crypto.LibsodiumInitializer.sodiumJna
|
||||||
|
|
||||||
|
actual object Ed25519LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean =
|
||||||
|
sodiumJna.crypto_core_ed25519_is_valid_point(encoded.asByteArray()) == 1
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_add(result.asByteArray(), p.asByteArray(), q.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_sub(result.asByteArray(), p.asByteArray(), q.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromUniform(uniform: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_from_uniform(result.asByteArray(), uniform.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ed25519_BYTES).also {
|
||||||
|
sodiumJna.crypto_core_ed25519_random(it.asByteArray())
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ed25519_SCALARBYTES).also {
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_random(it.asByteArray())
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_invert(result.asByteArray(), scalar.asByteArray()).ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_negate(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_complement(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_add(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_sub(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_mul(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ed25519_scalar_reduce(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ed25519(result.asByteArray(), n.asByteArray(), p.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ed25519_noclamp(result.asByteArray(), n.asByteArray(), p.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ed25519_base(result.asByteArray(), n.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ed25519_base_noclamp(result.asByteArray(), n.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,118 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ristretto255
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
|
||||||
|
import com.ionspin.kotlin.crypto.LibsodiumInitializer.sodiumJna
|
||||||
|
|
||||||
|
actual object Ristretto255LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean =
|
||||||
|
sodiumJna.crypto_core_ristretto255_is_valid_point(encoded.asByteArray()) == 1
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_add(result.asByteArray(), p.asByteArray(), q.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_sub(result.asByteArray(), p.asByteArray(), q.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromHash(hash: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_from_hash(result.asByteArray(), hash.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ristretto255_BYTES).also {
|
||||||
|
sodiumJna.crypto_core_ristretto255_random(it.asByteArray())
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ristretto255_SCALARBYTES).also {
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_random(it.asByteArray())
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_invert(result.asByteArray(), scalar.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_negate(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_complement(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_add(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_sub(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_mul(result.asByteArray(), x.asByteArray(), y.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_core_ristretto255_scalar_reduce(result.asByteArray(), scalar.asByteArray())
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ristretto255(result.asByteArray(), n.asByteArray(), p.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
sodiumJna.crypto_scalarmult_ristretto255_base(result.asByteArray(), n.asByteArray())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
Binary file not shown.
@ -0,0 +1,230 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ed25519
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
|
||||||
|
import com.ionspin.kotlin.crypto.util.toPtr
|
||||||
|
import kotlinx.cinterop.usePinned
|
||||||
|
import libsodium.crypto_core_ed25519_add
|
||||||
|
import libsodium.crypto_core_ed25519_from_uniform
|
||||||
|
import libsodium.crypto_core_ed25519_is_valid_point
|
||||||
|
import libsodium.crypto_core_ed25519_random
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_add
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_complement
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_invert
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_mul
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_negate
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_random
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_reduce
|
||||||
|
import libsodium.crypto_core_ed25519_scalar_sub
|
||||||
|
import libsodium.crypto_core_ed25519_sub
|
||||||
|
import libsodium.crypto_scalarmult_ed25519
|
||||||
|
import libsodium.crypto_scalarmult_ed25519_base
|
||||||
|
import libsodium.crypto_scalarmult_ed25519_base_noclamp
|
||||||
|
import libsodium.crypto_scalarmult_ed25519_noclamp
|
||||||
|
|
||||||
|
|
||||||
|
actual object Ed25519LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean {
|
||||||
|
return encoded.usePinned { crypto_core_ed25519_is_valid_point(it.toPtr()) == 1 }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
q.usePinned { qPinned ->
|
||||||
|
crypto_core_ed25519_add(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
q.usePinned { qPinned ->
|
||||||
|
crypto_core_ed25519_sub(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromUniform(uniform: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
uniform.usePinned { uniformPinned ->
|
||||||
|
crypto_core_ed25519_from_uniform(resultPinned.toPtr(), uniformPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ed25519_BYTES).apply {
|
||||||
|
usePinned { crypto_core_ed25519_random(it.toPtr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ed25519_SCALARBYTES).apply {
|
||||||
|
usePinned { crypto_core_ed25519_scalar_random(it.toPtr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ed25519_scalar_invert(resultPinned.toPtr(), scalarPinned.toPtr()).ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ed25519_scalar_negate(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ed25519_scalar_complement(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ed25519_scalar_add(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ed25519_scalar_sub(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ed25519_scalar_mul(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ed25519_scalar_reduce(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
crypto_scalarmult_ed25519(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
crypto_scalarmult_ed25519_noclamp(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
crypto_scalarmult_ed25519_base(resultPinned.toPtr(), nPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ed25519_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
crypto_scalarmult_ed25519_base_noclamp(resultPinned.toPtr(), nPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,201 @@
|
|||||||
|
package com.ionspin.kotlin.crypto.ristretto255
|
||||||
|
|
||||||
|
import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
|
||||||
|
import com.ionspin.kotlin.crypto.util.toPtr
|
||||||
|
import kotlinx.cinterop.usePinned
|
||||||
|
import libsodium.crypto_core_ristretto255_add
|
||||||
|
import libsodium.crypto_core_ristretto255_from_hash
|
||||||
|
import libsodium.crypto_core_ristretto255_is_valid_point
|
||||||
|
import libsodium.crypto_core_ristretto255_random
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_add
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_complement
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_invert
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_mul
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_negate
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_random
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_reduce
|
||||||
|
import libsodium.crypto_core_ristretto255_scalar_sub
|
||||||
|
import libsodium.crypto_core_ristretto255_sub
|
||||||
|
import libsodium.crypto_scalarmult_ristretto255
|
||||||
|
import libsodium.crypto_scalarmult_ristretto255_base
|
||||||
|
|
||||||
|
|
||||||
|
actual object Ristretto255LowLevel {
|
||||||
|
actual fun isValidPoint(encoded: UByteArray): Boolean {
|
||||||
|
return encoded.usePinned { crypto_core_ristretto255_is_valid_point(it.toPtr()) == 1 }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
q.usePinned { qPinned ->
|
||||||
|
crypto_core_ristretto255_add(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
q.usePinned { qPinned ->
|
||||||
|
crypto_core_ristretto255_sub(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun pointFromHash(hash: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
hash.usePinned { hashPinned ->
|
||||||
|
crypto_core_ristretto255_from_hash(resultPinned.toPtr(), hashPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ristretto255_BYTES).apply {
|
||||||
|
usePinned { crypto_core_ristretto255_random(it.toPtr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ristretto255_SCALARBYTES).apply {
|
||||||
|
usePinned { crypto_core_ristretto255_scalar_random(it.toPtr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun invertScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_invert(
|
||||||
|
resultPinned.toPtr(),
|
||||||
|
scalarPinned.toPtr()
|
||||||
|
).ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun negateScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_negate(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun complementScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_complement(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_add(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_sub(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
x.usePinned { xPinned ->
|
||||||
|
y.usePinned { yPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_mul(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun reduceScalar(scalar: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
scalar.usePinned { scalarPinned ->
|
||||||
|
crypto_core_ristretto255_scalar_reduce(resultPinned.toPtr(), scalarPinned.toPtr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
p.usePinned { pPinned ->
|
||||||
|
crypto_scalarmult_ristretto255(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
|
||||||
|
val result = UByteArray(crypto_core_ristretto255_BYTES)
|
||||||
|
|
||||||
|
result.usePinned { resultPinned ->
|
||||||
|
n.usePinned { nPinned ->
|
||||||
|
crypto_scalarmult_ristretto255_base(resultPinned.toPtr(), nPinned.toPtr())
|
||||||
|
.ensureLibsodiumSuccess()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -4,7 +4,6 @@ import kotlinx.cinterop.CPointer
|
|||||||
import kotlinx.cinterop.Pinned
|
import kotlinx.cinterop.Pinned
|
||||||
import kotlinx.cinterop.UByteVar
|
import kotlinx.cinterop.UByteVar
|
||||||
import kotlinx.cinterop.addressOf
|
import kotlinx.cinterop.addressOf
|
||||||
import kotlinx.cinterop.toCPointer
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Created by Ugljesa Jovanovic
|
* Created by Ugljesa Jovanovic
|
||||||
|
|||||||
@ -1,6 +1,6 @@
|
|||||||
./configureMacos64.sh
|
./configureMacos64.sh
|
||||||
cd libsodium
|
cd libsodium
|
||||||
./dist-build/apple-xcframework.sh
|
LIBSODIUM_FULL_BUILD=1 ./dist-build/apple-xcframework.sh
|
||||||
|
|
||||||
mkdir ../static-ios
|
mkdir ../static-ios
|
||||||
mkdir ../static-ios-simulators
|
mkdir ../static-ios-simulators
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user