add option for insecure random with kulid

Author: daphil19

benchmark/src/commonMain/kotlin/dev/phillipslabs/kulid/benchmark/ULIDBenchmark.kt

@@ -2,13 +2,29 @@ package dev.phillipslabs.kulid.benchmark
 
 import dev.phillipslabs.kulid.ULID
 import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
 
 @State(Scope.Benchmark)
 class ULIDBenchmark {
     @Benchmark
-    fun generateULID() {
-        ULID.generate()
+    fun generateULID(bh: Blackhole) {
+        bh.consume(ULID.generate())
+    }
+
+    @Benchmark
+    fun generateULIDString(bh: Blackhole) {
+        bh.consume(ULID.generate().toString())
+    }
+
+    @Benchmark
+    fun generateInsecureRandomULID(bh: Blackhole) {
+        bh.consume(ULID.generate(secureRandom = false))
+    }
+
+    @Benchmark
+    fun generateInsecureRandomULIDString(bh: Blackhole) {
+        bh.consume(ULID.generate(secureRandom = false).toString())
     }
 }

benchmark/src/commonMain/kotlin/dev/phillipslabs/kulid/benchmark/UUIDBenchmark.kt

@@ -1,6 +1,7 @@
 package dev.phillipslabs.kulid.benchmark
 
 import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
 import kotlin.uuid.ExperimentalUuidApi
@@ -10,8 +11,13 @@ import kotlin.uuid.Uuid
 class UUIDBenchmark {
     @OptIn(ExperimentalUuidApi::class)
     @Benchmark
-    fun generateUUID() {
-        // right now,  ULID encodes to string on creation
-        Uuid.random().toString()
+    fun generateUUID(bh: Blackhole) {
+        bh.consume(Uuid.random())
+    }
+
+    @OptIn(ExperimentalUuidApi::class)
+    @Benchmark
+    fun generateUUIDString(bh: Blackhole) {
+        bh.consume(Uuid.random().toString())
     }
 }

kulid/src/commonMain/kotlin/dev/phillipslabs/kulid/ULID.kt

@@ -8,6 +8,7 @@ import kotlinx.serialization.Serializable
 import org.kotlincrypto.random.CryptoRand
 import kotlin.jvm.JvmInline
 import kotlin.math.absoluteValue
+import kotlin.random.Random
 
 // some of these are marked as internal so that tests can be conducted easier
 // ideally, they would all be private unless there's a compelling reason to expose these
@@ -46,7 +47,10 @@ public value class ULID private constructor(
         public val MAX: ULID = fromString("7ZZZZZZZZZZZZZZZZZZZZZZZZZ")
         public val MIN: ULID = fromString("00000000000000000000000000")
 
-        public fun generate(timestamp: Long = Clock.System.now().toEpochMilliseconds()): ULID {
+        public fun generate(
+            timestamp: Long = Clock.System.now().toEpochMilliseconds(),
+            secureRandom: Boolean = true,
+        ): ULID {
             check(timestamp >= 0L) { "Time must be non-negative" }
             check(timestamp <= MAX_TIME) { "Time must be less than $MAX_TIME" }
 
@@ -56,7 +60,14 @@ public value class ULID private constructor(
             buf.writeShort((timestamp shr 32).toShort())
             buf.writeInt(timestamp.toInt())
 
-            val randomness = CryptoRand.Default.nextBytes(ByteArray(RANDOM_BYTE_SIZE))
+            val randomness =
+                if (secureRandom) {
+                    CryptoRand.Default.nextBytes(
+                        ByteArray(RANDOM_BYTE_SIZE),
+                    )
+                } else {
+                    Random.nextBytes(ByteArray(RANDOM_BYTE_SIZE))
+                }
             buf.write(randomness)
 
             return ULID(buf.readByteString())