.gitea/workflows/main.yaml

@@ -1,36 +0,0 @@
-on:
-  push:
-    branches:
-      - main
-
-env:
-  INFENDRO__TOKEN: ${{ secrets.TOKEN }}
-
-jobs:
-  publish:
-    runs-on: linux
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/cache/restore@v4
-        with:
-          key: gradle
-          path: |
-            ~/.gradle/caches/
-            ~/.gradle/wrapper/
-            ~/.konan/
-
-      - uses: actions/setup-java@v4
-        with:
-          java-version: '24'
-          distribution: 'temurin'
-
-      - run: ./gradlew publish
-
-      - uses: actions/cache/save@v4
-        with:
-          key: gradle
-          path: |
-            ~/.gradle/caches/
-            ~/.gradle/wrapper/
-            ~/.konan/

.gitea/workflows/publish.yaml

@@ -0,0 +1,47 @@
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  publish:
+    runs-on: linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          java-version: '24'
+          distribution: 'temurin'
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          key: gradle-${{ hashFiles('**/libs.versions.toml') }}
+          restore-keys: gradle
+          path: |
+            ~/.gradle/caches/
+            ~/.gradle/wrapper/
+
+      - name: Cache Konan
+        uses: actions/cache@v4
+        with:
+          key: konan-${{ hashFiles('**/libs.versions.toml') }}
+          restore-keys: konan
+          path: |
+            ~/.konan/
+
+      - name: Cache Node
+        uses: actions/cache@v4
+        with:
+          key: node-${{ hashFiles('**/libs.versions.toml') }}
+          restore-keys: node
+          path: |
+            ~/.gradle/nodejs
+            ~/.gradle/yarn
+
+      - name: Publish
+        run: ./gradlew publish
+        env:
+          INFENDRO__TOKEN: ${{ secrets.TOKEN }}

.gitea/workflows/test.yaml

@@ -0,0 +1,28 @@
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          java-version: '24'
+          distribution: 'temurin'
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          key: gradle-${{ hashFiles('**/libs.versions.toml') }}
+          restore-keys: gradle
+          path: |
+            ~/.gradle/caches/
+            ~/.gradle/wrapper/
+
+      - name: Test
+        run: ./gradlew jvmTest

README.md

@@ -1,21 +1,14 @@
 # prng-kt
 
-`prng-kt` is a Kotlin Multiplatform library that provides common pseudorandom number generators.
+`prng-kt` is a Kotlin Multiplatform library that provides common [Pseudorandom Number Generators](https://en.wikipedia.org/wiki/Pseudorandom_number_generator).
 
-Supported PRNGs:
+Supported [PRNG](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) algorithms:
 - LCG
+- Xoshiro256++
+- Xoshiro256**
 
-Supported CSPRNGs:
-- HMAC DRBG
-
-## Targets
-
-| Target           | Status        |
-|------------------|---------------|
-| JVM              | Supported     |
-| JavaScript       | Supported     |
-| Native (Linux)   | Supported     |
-| Native (Windows) | Not Supported |
+Supported [CSPRNG](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator) algorithms:
+- HMAC-DRBG
 
 ## Installation
 
@@ -27,34 +20,30 @@ repositories {
 }
 
 dependencies {
-    implementation("com.infendro:prng:1.2.0")
+    implementation("com.infendro:prng:1.3.0")
 }
 ```
 
 ## Usage
 
 ```kotlin
-import com.infendro.hash.sha2.`SHA-256`
-import com.infendro.random.csprng.CSPRNG
-
 fun main() {
-    // create a PRNG instance
+    // create PRNG instance
     val rng = CSPRNG.HMAC(`SHA-256`)
 
-    // seed the PRNG to receive predictable results
-    rng.seed(/* some seed */)
+    // seed PRNG to receive deterministic numbers
+    rng.seed(/* seed */)
     val a = rng.nextInt()
     val b = rng.nextInt()
     val c = rng.nextInt()
 
-    // reseed the PRNG to add entropy to the following results
-    rng.reseed(/* some random entropy */)
+    // reseed PRNG to add additional entropy
+    rng.reseed(/* entropy */)
     val d = rng.nextInt()
     val e = rng.nextInt()
     val f = rng.nextInt()
 
-    // each run:
-    // a, b, and c will be predictable
-    // d, e, and f will be random (assuming the entropy is also random)
+    // a, b, and c will be deterministic
+    // d, e, and f will be random (assuming entropy is random)
 }
 ```

build.gradle.kts

@@ -1,8 +1,11 @@
+@file:OptIn(ExperimentalWasmDsl::class)
+
 import com.infendro.plugin.infendro
 import com.infendro.plugin.token
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 
 group = "com.infendro"
-version = "1.2.0"
+version = "1.3.0"
 
 plugins {
     alias(libs.plugins.infendro)
@@ -12,10 +15,14 @@ plugins {
 
 kotlin {
     jvm()
-    js {
-        nodejs()
-    }
     linuxX64()
+    linuxArm64()
+    mingwX64()
+    macosX64()
+    macosArm64()
+    js { nodejs() }
+    wasmJs { nodejs() }
+    wasmWasi { nodejs() }
 
     repositories {
         infendro()
@@ -24,15 +31,11 @@ kotlin {
 
     sourceSets {
         commonMain.dependencies {
+            implementation(libs.bytes)
             implementation(libs.hash)
             implementation(libs.mac)
-            implementation(libs.bytearray)
         }
     }
-
-    compilerOptions {
-        freeCompilerArgs.add("-opt-in=kotlin.ExperimentalUnsignedTypes")
-    }
 }
 
 publishing.repositories {

gradle/libs.versions.toml

@@ -1,15 +1,15 @@
 [versions]
-infendro = "1.0.0"
-kotlin = "2.2.21"
-hash = "1.3.2"
-mac = "1.2.0"
-bytearray = "1.2.4"
+infendro = "1.1.0"
+kotlin = "2.3.0"
+bytes = "1.4.0"
+hash = "1.6.0"
+mac = "1.4.0"
 
 [plugins]
 infendro = { id = "com.infendro.plugin", version.ref = "infendro" }
 multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 
 [libraries]
+bytes = { module = "com.infendro:bytes", version.ref = "bytes" }
 hash = { module = "com.infendro:hash", version.ref = "hash" }
 mac = { module = "com.infendro:mac", version.ref = "mac" }
-bytearray = { module = "com.infendro:bytearray", version.ref = "bytearray" }

src/commonMain/kotlin/com/infendro/random/CSPRNG.kt

@@ -0,0 +1,5 @@
+package com.infendro.random
+
+abstract class CSPRNG : PRNG() {
+    abstract fun reseed(entropy: ByteArray)
+}

src/commonMain/kotlin/com/infendro/random/PRNG.kt

@@ -0,0 +1,16 @@
+package com.infendro.random
+
+import kotlin.random.Random
+
+abstract class PRNG : Random() {
+    abstract fun seed(seed: ByteArray)
+
+    protected abstract fun generate(): Int
+
+    override fun nextBits(bitCount: Int): Int {
+        require(bitCount in 0..32)
+
+        if (bitCount == 0) return 0
+        return generate() ushr (32 - bitCount)
+    }
+}

src/commonMain/kotlin/com/infendro/random/csprng/CSPRNG.kt

@@ -1,16 +0,0 @@
-package com.infendro.random.csprng
-
-import com.infendro.hash.HashFunction
-import com.infendro.random.prng.PRNG
-
-abstract class CSPRNG : PRNG() {
-    abstract fun reseed(
-        entropy: UByteArray,
-    )
-
-    companion object {
-        fun HMAC(
-            function: HashFunction,
-        ) = com.infendro.random.csprng.HMAC(function)
-    }
-}

src/commonMain/kotlin/com/infendro/random/csprng/HMAC-DRBG.kt

@@ -0,0 +1,50 @@
+package com.infendro.random.csprng
+
+import com.infendro.bytes.bytearray.toInt
+import com.infendro.hash.HashFunction
+import com.infendro.mac.HMAC
+import com.infendro.random.CSPRNG
+import kotlin.properties.Delegates.notNull
+
+class `HMAC-DRBG`(
+    private val function: HashFunction,
+) : CSPRNG() {
+    private val hmac = HMAC(function)
+
+    private var k: ByteArray by notNull()
+    private var v: ByteArray by notNull()
+
+    private val buffer = ByteArray(function.bytes + 1)
+
+    override fun seed(seed: ByteArray) {
+        k = ByteArray(function.bytes) { 0x00 }
+        v = ByteArray(function.bytes) { 0x01 }
+        reseed(seed)
+    }
+
+    override fun reseed(entropy: ByteArray) {
+        val value = ByteArray(v.size + 1 + entropy.size)
+
+        v.copyInto(value)
+        value[v.size] = 0x00
+        entropy.copyInto(value, v.size + 1)
+        hmac.hashInto(k, value, k)
+        hmac.hashInto(k, v, v)
+
+        value[v.size] = 0x01
+        hmac.hashInto(k, value, k)
+        hmac.hashInto(k, v, v)
+    }
+
+    override fun generate(): Int {
+        hmac.hashInto(k, v, v)
+        val result = v.toInt()
+
+        v.copyInto(buffer)
+        buffer[v.size] = 0x00
+        hmac.hashInto(k, buffer, k)
+        hmac.hashInto(k, v, v)
+
+        return result
+    }
+}

src/commonMain/kotlin/com/infendro/random/csprng/HMAC.kt

@@ -1,47 +0,0 @@
-package com.infendro.random.csprng
-
-import com.infendro.hash.HashFunction
-import kotlin.math.min
-import kotlin.properties.Delegates.notNull
-
-class HMAC internal constructor(
-    private val function: HashFunction,
-) : CSPRNG() {
-    private val hmac = com.infendro.mac.HMAC(function)
-
-    private var k: UByteArray by notNull()
-    private var v: UByteArray by notNull()
-
-    override fun seed(
-        seed: UByteArray,
-    ) {
-        k = UByteArray(function.bytes) { 0x00U }
-        v = UByteArray(function.bytes) { 0x01U }
-        reseed(seed)
-    }
-
-    override fun reseed(
-        entropy: UByteArray,
-    ) {
-        k = hmac.hash(k, v + ubyteArrayOf(0x00U) + entropy)
-        v = hmac.hash(k, v)
-        k = hmac.hash(k, v + ubyteArrayOf(0x01U) + entropy)
-        v = hmac.hash(k, v)
-    }
-
-    override fun generate(
-        count: Int,
-    ): UByteArray {
-        val bytes = buildList {
-            while (size < count) {
-                v = hmac.hash(k, v)
-                addAll(v.take(min(count - size, function.bytes)))
-            }
-        }.toUByteArray()
-
-        k = hmac.hash(k, v + ubyteArrayOf(0x00U))
-        v = hmac.hash(k, v)
-
-        return bytes
-    }
-}

src/commonMain/kotlin/com/infendro/random/prng/LCG.kt

@@ -1,33 +1,23 @@
 package com.infendro.random.prng
 
-import com.infendro.bytearray.padStart
-import com.infendro.bytearray.toUByteArray
-import com.infendro.bytearray.toULong
-import kotlin.math.min
-import kotlin.properties.Delegates
+import com.infendro.bytes.bytearray.toLong
+import com.infendro.hash.sha2.`SHA-256`
+import com.infendro.random.PRNG
+import kotlin.properties.Delegates.notNull
 
-class LCG internal constructor() : PRNG() {
-    private val a: ULong = 25214903917UL
-    private val c: ULong = 11UL
-    private val m: ULong = 1UL shl 48
+class LCG : PRNG() {
+    private val a: Long = 25214903917L
+    private val c: Long = 11L
+    private val mask: Long = (1L shl 48) - 1
 
-    private var x: ULong by Delegates.notNull()
+    private var x: Long by notNull()
 
-    override fun seed(
-        seed: UByteArray,
-    ) {
-        val s = seed.padStart(8, 0x00U).takeLast(8).toUByteArray()
-        x = s.toULong() % m
+    override fun seed(seed: ByteArray) {
+        x = `SHA-256`.hash(seed).toLong() and mask
     }
 
-    override fun generate(
-        count: Int,
-    ): UByteArray {
-        return buildList {
-            while (size < count) {
-                x = (a * x + c) % m
-                addAll(x.toUByteArray().takeLast(min(count - size, 6)))
-            }
-        }.toUByteArray()
+    override fun generate(): Int {
+        x = (a * x + c) and mask
+        return (x ushr 16).toInt()
     }
 }

src/commonMain/kotlin/com/infendro/random/prng/PRNG.kt

@@ -1,44 +0,0 @@
-package com.infendro.random.prng
-
-import com.infendro.bytearray.toInt
-import kotlin.random.Random
-
-abstract class PRNG : Random() {
-    abstract fun seed(
-        seed: UByteArray,
-    )
-
-    abstract fun generate(
-        count: Int,
-    ): UByteArray
-
-    override fun nextBits(
-        bitCount: Int,
-    ): Int {
-        require(bitCount in 0..32)
-
-        if (bitCount == 0) return 0
-        return generate(4).toInt() ushr (32 - bitCount)
-    }
-
-    override fun nextBytes(
-        array: ByteArray,
-        fromIndex: Int,
-        toIndex: Int,
-    ): ByteArray {
-        require(fromIndex in 0..array.size && toIndex in 0..array.size)
-        require(fromIndex <= toIndex)
-
-        val size = toIndex - fromIndex
-        val bytes = generate(size).asByteArray()
-        for (i in 0..<size) {
-            array[i + fromIndex] = bytes[i]
-        }
-
-        return array
-    }
-
-    companion object {
-        fun LCG() = com.infendro.random.prng.LCG()
-    }
-}

src/commonMain/kotlin/com/infendro/random/prng/Xoshiro256pp.kt

@@ -0,0 +1,28 @@
+package com.infendro.random.prng
+
+import com.infendro.bytes.bytearray.toLongArray
+import com.infendro.hash.sha2.`SHA-256`
+import com.infendro.random.PRNG
+import kotlin.properties.Delegates.notNull
+
+class Xoshiro256pp : PRNG() {
+    private var s: LongArray by notNull()
+
+    override fun seed(seed: ByteArray) {
+        s = `SHA-256`.hash(seed).toLongArray()
+    }
+
+    override fun generate(): Int {
+        val result = (s[0] + s[3]).rotateLeft(23) + s[0]
+
+        val t = s[1] shl 17
+        s[2] = s[2] xor s[0]
+        s[3] = s[3] xor s[1]
+        s[1] = s[1] xor s[2]
+        s[0] = s[0] xor s[3]
+        s[2] = s[2] xor t
+        s[3] = s[3].rotateLeft(45)
+
+        return (result ushr 32).toInt()
+    }
+}

src/commonMain/kotlin/com/infendro/random/prng/Xoshiro256ss.kt

@@ -0,0 +1,28 @@
+package com.infendro.random.prng
+
+import com.infendro.bytes.bytearray.toLongArray
+import com.infendro.hash.sha2.`SHA-256`
+import com.infendro.random.PRNG
+import kotlin.properties.Delegates.notNull
+
+class Xoshiro256ss : PRNG() {
+    private var s: LongArray by notNull()
+
+    override fun seed(seed: ByteArray) {
+        s = `SHA-256`.hash(seed).toLongArray()
+    }
+
+    override fun generate(): Int {
+        val result = (s[1] * 5).rotateLeft(7) * 9
+
+        val t = s[1] shl 17
+        s[2] = s[2] xor s[0]
+        s[3] = s[3] xor s[1]
+        s[1] = s[1] xor s[2]
+        s[0] = s[0] xor s[3]
+        s[2] = s[2] xor t
+        s[3] = s[3].rotateLeft(45)
+
+        return (result ushr 32).toInt()
+    }
+}