react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/RecentPickerStore.kt

@@ -0,0 +1,74 @@
+package com.customcamera
+
+import android.content.Context
+
+/**
+ * Persists the recently used emojis and stickers for the preview editor's pickers
+ * (most-recent-first, deduplicated, capped) in SharedPreferences, so the "Recent"
+ * category survives process restarts. Writes are async (apply()) and the lists are
+ * tiny strings, so there is no measurable I/O or memory cost on low-end devices.
+ *
+ * Stickers are encoded one per line as "res:<drawable-name>" (bundled vectors — the
+ * NAME is stored because resource ids are not stable across builds) or
+ * "emoji:<glyph>". Emojis are stored one glyph per line. '\n' is a safe separator:
+ * it can appear in neither a resource name nor an emoji sequence.
+ */
+internal object RecentPickerStore {
+
+  private const val PREFS = "camera_picker_recents"
+  private const val KEY_EMOJIS = "recent_emojis"
+  private const val KEY_STICKERS = "recent_stickers"
+  private const val MAX_EMOJIS = 32
+  private const val MAX_STICKERS = 18
+
+  private fun prefs(context: Context) =
+    context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+  private fun load(context: Context, key: String): List<String> =
+    prefs(context).getString(key, null)
+      ?.split('\n')
+      ?.filter { it.isNotBlank() }
+      ?: emptyList()
+
+  private fun save(context: Context, key: String, entry: String, max: Int) {
+    val updated = (listOf(entry) + load(context, key).filter { it != entry }).take(max)
+    prefs(context).edit().putString(key, updated.joinToString("\n")).apply()
+  }
+
+  // ----- Emojis -----
+
+  fun recentEmojis(context: Context): List<String> = load(context, KEY_EMOJIS)
+
+  fun addEmoji(context: Context, glyph: String) =
+    save(context, KEY_EMOJIS, glyph, MAX_EMOJIS)
+
+  // ----- Stickers -----
+
+  fun recentStickers(context: Context): List<StickerPickerData.Sticker> =
+    load(context, KEY_STICKERS).mapNotNull { entry ->
+      when {
+        entry.startsWith("res:") -> {
+          // Resolve the stored drawable name back to this build's id; drop entries
+          // whose drawable no longer exists (e.g. a sticker removed in an update).
+          val id = context.resources.getIdentifier(
+            entry.removePrefix("res:"), "drawable", context.packageName
+          )
+          if (id != 0) StickerPickerData.Sticker.Res(id) else null
+        }
+        entry.startsWith("emoji:") -> StickerPickerData.Sticker.Emoji(entry.removePrefix("emoji:"))
+        else -> null
+      }
+    }
+
+  fun addSticker(context: Context, sticker: StickerPickerData.Sticker) {
+    val entry = when (sticker) {
+      is StickerPickerData.Sticker.Res -> {
+        val name = runCatching { context.resources.getResourceEntryName(sticker.resId) }.getOrNull()
+          ?: return
+        "res:$name"
+      }
+      is StickerPickerData.Sticker.Emoji -> "emoji:${sticker.glyph}"
+    }
+    save(context, KEY_STICKERS, entry, MAX_STICKERS)
+  }
+}

package/android/src/main/java/com/customcamera/SecureFileEraser.kt

@@ -0,0 +1,411 @@
+package com.customcamera
+
+import android.os.ParcelFileDescriptor
+import android.util.Log
+import java.io.File
+import java.io.FileDescriptor
+import java.io.FileOutputStream
+import java.io.RandomAccessFile
+import java.security.SecureRandom
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+/**
+ * Destroys the CONTENT of a media file before its directory entry is unlinked.
+ *
+ * `File.delete()` only detaches a name from an inode: every byte of the photo or video stays on
+ * the flash until the filesystem happens to reuse those blocks, which on a half-empty device can
+ * be never. Anything that can read the raw partition — a forensic tool, a recovery image, a
+ * backup of the app's sandbox — recovers the deleted media in full. This class removes that
+ * window by writing over the file's own extent first, so the delete that follows unlinks blocks
+ * that no longer contain the media.
+ *
+ * Three properties matter and each one is a deliberate choice here:
+ *
+ *  - **The bytes that land are indistinguishable from noise.** [SecureRandom] supplies
+ *    cryptographically secure random data, and that data is then run through AES-CTR under a
+ *    single-use key that is generated in memory and never stored, logged, or derived from
+ *    anything reproducible. The keystream is discarded with the object, so what remains on the
+ *    platter cannot be distinguished from — or reduced to — anything meaningful, and carries no
+ *    residual structure that would hint at the file's former size class or format.
+ *  - **The overwrite is longer than the file.** The pass runs to `original size + `
+ *    [PAD_BYTES], so the padding spills past the original end-of-file into freshly allocated
+ *    blocks. That covers the tail slack of the last original block and denies a recovery tool the
+ *    single most useful fact it has left after an overwrite: the exact original length.
+ *  - **Nothing is ever held in RAM at file scale.** Both the random source and the cipher output
+ *    are fixed-size chunk buffers ([chunkBytes], one buffer each, sized down on small-heap
+ *    devices). Erasing a 2 GB recording costs the same handful of kilobytes as erasing a
+ *    thumbnail — there is no path here that allocates against the file's length.
+ *
+ * The overwrite is issued in place through [RandomAccessFile] rather than by truncating and
+ * rewriting. Truncating first would release the original blocks back to the allocator, and the
+ * filesystem would then be free to satisfy the rewrite from somewhere else entirely — leaving the
+ * media exactly where it was, with a wall of random data written harmlessly beside it.
+ *
+ * Every entry point reports whether the overwrite actually completed. A caller must never
+ * translate a failure here into "securely deleted": see [Result.securelyOverwritten].
+ */
+internal object SecureFileEraser {
+  private const val TAG = "SecureFileEraser"
+
+  /**
+   * Bytes written PAST the original end of file — 2 MiB.
+   *
+   * The point is not volume, it is length obfuscation. Overwriting exactly `length` bytes leaves
+   * the file's original size recoverable from its metadata and block allocation, which for media
+   * is itself disclosure (it identifies the clip, and pins which of several deleted files a
+   * recovered fragment belonged to). Running past the end also guarantees the partially used
+   * final block of the original file is covered in full rather than up to the old EOF offset.
+   */
+  const val PAD_BYTES: Long = 2L * 1024L * 1024L
+
+  /** Head-room left unclaimed so the padding pass cannot be the write that fills the volume. */
+  private const val SPACE_MARGIN_BYTES: Long = 8L * 1024L * 1024L
+
+  /** Transient buffer size on a normal-heap device. Matches the copy path's 1 MiB unit. */
+  private const val CHUNK_BYTES: Int = MediaFileIo.COPY_BUFFER_BYTES
+
+  /**
+   * Buffer size on a small-heap device. A deletion can be triggered while the media grid holds a
+   * screenful of decoded thumbnails, so the erase path must not be the allocation that pushes a
+   * low-RAM device into an OOM. 256 KiB still reduces a 1 GB clip to ~4,000 write calls.
+   */
+  private const val SMALL_HEAP_CHUNK_BYTES: Int = 256 * 1024
+
+  /** Outcome of one overwrite, and the only honest basis for reporting a secure deletion. */
+  data class Result(
+    /**
+     * True ONLY when every byte of the original extent was overwritten and the write was flushed
+     * to storage. False means some of the original media may still be readable on the device, and
+     * the caller MUST NOT describe the deletion as secure.
+     */
+    val securelyOverwritten: Boolean,
+    /** The file's exact length before the pass, measured immediately before writing. */
+    val originalBytes: Long,
+    /** Bytes actually written and flushed. `originalBytes + `[PAD_BYTES] on a complete pass. */
+    val overwrittenBytes: Long,
+    /** True when the full padding also landed — see [PAD_BYTES]. */
+    val padded: Boolean,
+    val error: String? = null
+  ) {
+    companion object {
+      fun failed(originalBytes: Long, error: String) =
+        Result(
+          securelyOverwritten = false,
+          originalBytes = originalBytes,
+          overwrittenBytes = 0L,
+          padded = false,
+          error = error
+        )
+    }
+  }
+
+  /**
+   * Overwrite [file]'s content, then unlink it.
+   *
+   * The unlink is preceded by a rename to a random name in the same directory. A directory entry
+   * outlives the file it names in most filesystems' journals, so the original name — which for
+   * this app's media encodes the capture timestamp and container — would otherwise survive an
+   * otherwise perfect content wipe.
+   *
+   * A file that no longer exists is reported as securely erased with a zero length: the caller
+   * asked for it to be gone and it is, with nothing left to overwrite. Returning a failure there
+   * would make every retry and every already-cleaned duplicate look like a security incident.
+   */
+  fun erase(file: File, padBytes: Long = PAD_BYTES): Result {
+    if (!file.exists()) {
+      return Result(
+        securelyOverwritten = true,
+        originalBytes = 0L,
+        overwrittenBytes = 0L,
+        padded = false
+      )
+    }
+    if (!file.isFile) return Result.failed(0L, "Not a regular file: ${file.absolutePath}")
+
+    val result = overwrite(file, padBytes)
+
+    // Unlink whatever the overwrite achieved. This runs even on a failed overwrite: the caller's
+    // instruction was to delete the media, and leaving a half-scrubbed file in place would be
+    // both a leak and a phantom entry in the library. The Result still reports the truth about
+    // the overwrite, which is what the caller surfaces.
+    val scrubbed = renameToRandom(file)
+    val deleted = runCatching { scrubbed.delete() }.getOrDefault(false) || !scrubbed.exists()
+    if (!deleted) {
+      Log.e(TAG, "Overwrote but could not unlink ${scrubbed.absolutePath}")
+      return result.copy(
+        securelyOverwritten = false,
+        error = result.error ?: "File could not be unlinked after overwrite"
+      )
+    }
+
+    return result
+  }
+
+  /**
+   * Overwrite [file]'s content in place, without deleting it.
+   *
+   * Separated from [erase] because a content URI cannot be renamed or unlinked as a path — see
+   * the [ParcelFileDescriptor] overload — and because the two steps fail independently.
+   */
+  fun overwrite(file: File, padBytes: Long = PAD_BYTES): Result {
+    // The exact size is read once, here, and every later figure derives from it. Reading it
+    // inside the loop instead would race against our own writes as the file grows.
+    val originalBytes = file.length()
+    val pad = effectivePad(file.parentFile, padBytes, originalBytes)
+
+    return try {
+      RandomAccessFile(file, "rw").use { raf ->
+        raf.seek(0L)
+        writeGarbage(
+          write = { buffer, length -> raf.write(buffer, 0, length) },
+          sync = {
+            // Both barriers matter and they are not the same barrier: force(true) pushes the
+            // channel's own buffering plus file metadata, fd.sync() is the fsync that makes the
+            // kernel commit the data to the storage device. Without them the "overwrite" can sit
+            // in the page cache and be discarded on a crash or battery pull, and the original
+            // blocks would come back untouched.
+            raf.channel.force(true)
+            raf.fd.sync()
+          },
+          originalBytes = originalBytes,
+          padBytes = pad
+        )
+      }
+    } catch (t: Throwable) {
+      Log.e(TAG, "Secure overwrite failed for ${file.absolutePath}", t)
+      Result.failed(originalBytes, t.message ?: t.javaClass.simpleName)
+    }
+  }
+
+  /**
+   * Overwrite the content behind an already-open read/write [pfd].
+   *
+   * This is the path for a `content://` URI, where there is no path to open and no name to
+   * rename: whether the bytes can be reached at all is the provider's decision. The descriptor
+   * must have been opened `"rw"`; a read-only one throws and is reported as a failed overwrite
+   * rather than silently skipped.
+   *
+   * The descriptor is NOT closed here — its owner opened it and still has to delete the row.
+   */
+  fun overwrite(pfd: ParcelFileDescriptor, padBytes: Long = PAD_BYTES): Result {
+    val originalBytes = pfd.statSize.coerceAtLeast(0L)
+
+    return try {
+      // Wrapping an existing descriptor does NOT truncate it (unlike opening a path for write),
+      // so this writes over the provider's blocks from offset 0 exactly as the File path does.
+      val output = FileOutputStream(pfd.fileDescriptor)
+      val descriptor: FileDescriptor = pfd.fileDescriptor
+      writeGarbage(
+        write = { buffer, length -> output.write(buffer, 0, length) },
+        sync = {
+          output.flush()
+          descriptor.sync()
+        },
+        originalBytes = originalBytes,
+        padBytes = padBytes
+      )
+    } catch (t: Throwable) {
+      Log.e(TAG, "Secure overwrite failed for descriptor", t)
+      Result.failed(originalBytes, t.message ?: t.javaClass.simpleName)
+    }
+  }
+
+  /**
+   * The single write loop behind every entry point.
+   *
+   * [write] receives a reused buffer and a length; [sync] is the flush barrier, invoked once the
+   * last byte has been handed over. Both are lambdas so the [File] and [ParcelFileDescriptor]
+   * paths share this logic exactly — an overwrite that behaved differently between a cache file
+   * and a provider-backed one would be the kind of gap that only shows up in the field.
+   *
+   * Partial progress is graded rather than discarded. Reaching at least [originalBytes] means the
+   * media itself is gone even if the padding was cut short by a full volume, which is a materially
+   * different outcome from stopping halfway through the file, and callers are told which happened.
+   */
+  private fun writeGarbage(
+    write: (ByteArray, Int) -> Unit,
+    sync: () -> Unit,
+    originalBytes: Long,
+    padBytes: Long
+  ): Result {
+    val target = originalBytes + padBytes.coerceAtLeast(0L)
+    val chunkBytes = chunkBytes()
+    val garbage = GarbageSource(chunkBytes)
+    var written = 0L
+    var failure: String? = null
+    var flushed = false
+
+    try {
+      while (written < target) {
+        val length = minOf(chunkBytes.toLong(), target - written).toInt()
+        write(garbage.next(length), length)
+        written += length
+      }
+    } catch (t: Throwable) {
+      failure = t.message ?: t.javaClass.simpleName
+      Log.e(TAG, "Secure overwrite stopped after $written/$target bytes", t)
+    }
+
+    // Flushing is graded separately from writing, and a failure here is fatal to the claim even
+    // when every byte was handed over: unflushed writes can still be sitting in the page cache,
+    // and a crash or battery pull would bring the original blocks back intact. Reporting success
+    // on an uncommitted overwrite is exactly the "silently report successful secure deletion"
+    // case this class exists to prevent. It runs even after a write failure, so whatever did land
+    // is at least durable.
+    try {
+      sync()
+      flushed = true
+    } catch (t: Throwable) {
+      Log.e(TAG, "Secure overwrite could not be flushed to storage after $written bytes", t)
+      if (failure == null) failure = "Overwrite not flushed to storage: ${t.message ?: t.javaClass.simpleName}"
+    }
+
+    garbage.destroy()
+
+    // "Secure" requires the whole original extent covered AND committed. Losing only the padding
+    // to a full volume still means the media itself is unrecoverable, so that grades as secure
+    // with `padded = false` rather than as an outright failure.
+    val coveredOriginal = written >= originalBytes && flushed
+    return Result(
+      securelyOverwritten = coveredOriginal,
+      originalBytes = originalBytes,
+      overwrittenBytes = written,
+      padded = written >= target && flushed,
+      error = failure
+    )
+  }
+
+  /**
+   * How far past the end of the file the pass may run, given what the volume can take.
+   *
+   * The in-place portion needs no free space at all — it reuses the file's own blocks — so a
+   * device too full for the padding must still get a complete content wipe. Trimming the pad
+   * here, rather than letting the write fail at the ENOSPC boundary, keeps the common
+   * nearly-full-device case on the clean path.
+   */
+  private fun effectivePad(parent: File?, requestedPad: Long, originalBytes: Long): Long {
+    if (requestedPad <= 0L) return 0L
+    val dir = parent ?: return requestedPad
+    val usable = MediaFileIo.usableSpaceBytes(dir)
+    if (usable == Long.MAX_VALUE) return requestedPad
+
+    val affordable = usable - SPACE_MARGIN_BYTES
+    if (affordable >= requestedPad) return requestedPad
+
+    Log.w(
+      TAG,
+      "Only ${MediaFileIo.formatMegabytes(affordable.coerceAtLeast(0L))} free; " +
+        "padding a ${MediaFileIo.formatMegabytes(originalBytes)} file by less than " +
+        MediaFileIo.formatMegabytes(requestedPad)
+    )
+    return affordable.coerceAtLeast(0L)
+  }
+
+  /**
+   * Rename [file] to an unpredictable name in its own directory so the original name does not
+   * outlive the content. Returns the renamed file, or [file] unchanged when the rename is
+   * refused — the delete that follows works either way.
+   */
+  private fun renameToRandom(file: File): File {
+    val parent = file.parentFile ?: return file
+    val bytes = ByteArray(8).also { SecureRandom().nextBytes(it) }
+    val scrubbed = File(parent, bytes.joinToString("") { "%02x".format(it) })
+    return if (runCatching { file.renameTo(scrubbed) }.getOrDefault(false)) scrubbed else file
+  }
+
+  /** Chunk size for this device — see [SMALL_HEAP_CHUNK_BYTES]. */
+  private fun chunkBytes(): Int =
+    if (Runtime.getRuntime().maxMemory() <= 128L * 1024L * 1024L) {
+      SMALL_HEAP_CHUNK_BYTES
+    } else {
+      CHUNK_BYTES
+    }
+
+  /**
+   * A bounded generator of encrypted cryptographically secure random bytes.
+   *
+   * Two fixed buffers, allocated once and reused for the whole pass: [plain] takes the
+   * [SecureRandom] output and [cipherText] takes the AES-CTR result. Neither is ever sized
+   * against the file, which is what keeps erasing a gigabyte-scale recording within a few hundred
+   * kilobytes of working memory.
+   *
+   * The cipher is a second, independent layer over the CSPRNG rather than a replacement for it.
+   * Random input alone is already unpredictable; passing it through a single-use key means the
+   * written stream also cannot be reproduced by anyone who later learns something about the
+   * device's random source, and the key is gone the moment [destroy] runs.
+   */
+  private class GarbageSource(chunkBytes: Int) {
+    private val random = SecureRandom()
+    private val plain = ByteArray(chunkBytes)
+    private val cipherText = ByteArray(chunkBytes)
+    private val cipher: Cipher? = createCipher()
+
+    /**
+     * Fill the internal buffer with [length] fresh bytes and return it.
+     *
+     * The array is REUSED between calls, so callers must consume `[0, length)` before the next
+     * call — every caller here writes it straight out.
+     *
+     * A cipher that cannot be initialised (a stripped-down or FIPS-restricted provider on some
+     * OEM builds) degrades to the raw CSPRNG output rather than aborting the erase. Plain
+     * SecureRandom bytes are already a sound overwrite; refusing to scrub the file at all
+     * because the optional second layer is unavailable would be the worse failure.
+     */
+    fun next(length: Int): ByteArray {
+      random.nextBytes(plain)
+      val active = cipher ?: return plain
+      return try {
+        val produced = active.update(plain, 0, length, cipherText, 0)
+        if (produced == length) cipherText else plain
+      } catch (t: Throwable) {
+        Log.w(TAG, "Cipher stage unavailable mid-pass; continuing with CSPRNG output", t)
+        plain
+      }
+    }
+
+    /**
+     * Wipe both buffers.
+     *
+     * They hold the exact bytes now sitting on the media's former blocks, so clearing them
+     * shortens the window in which a heap dump reveals what was written. The key itself is
+     * never retained by this class — it is zeroed the instant the cipher is initialised (see
+     * [createCipher]), so there is nothing else here to destroy.
+     */
+    fun destroy() {
+      plain.fill(0)
+      cipherText.fill(0)
+    }
+
+    /**
+     * Build the single-use AES-CTR cipher, or null when the platform has no usable provider.
+     *
+     * The key is generated here, handed to the cipher, and zeroed immediately — it is
+     * deliberately NOT kept in a field. Retaining a copy so it could be wiped later would only
+     * keep live key material on the heap for the whole duration of a multi-second erase, and the
+     * cipher already holds its own copy that this class cannot reach anyway.
+     *
+     * AES-256 first; a provider that rejects the longer key falls back to 128-bit, which is just
+     * as unpredictable for this purpose.
+     */
+    private fun createCipher(): Cipher? {
+      for (keyLength in intArrayOf(KEY_BYTES, 16)) {
+        runCatching {
+          val key = ByteArray(keyLength).also { random.nextBytes(it) }
+          val iv = ByteArray(IV_BYTES).also { random.nextBytes(it) }
+          return Cipher.getInstance("AES/CTR/NoPadding").apply {
+            init(Cipher.ENCRYPT_MODE, SecretKeySpec(key, "AES"), IvParameterSpec(iv))
+          }.also { key.fill(0) }
+        }
+      }
+      Log.w(TAG, "AES/CTR unavailable; overwriting with raw CSPRNG output")
+      return null
+    }
+
+    private companion object {
+      const val KEY_BYTES = 32
+      const val IV_BYTES = 16
+    }
+  }
+}

package/android/src/main/java/com/customcamera/SecureKeyModule.kt

@@ -0,0 +1,88 @@
+package com.customcamera
+
+import android.content.Context
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.security.SecureRandom
+
+/**
+ * SecureKeyModule
+ *
+ * Provisions and persists the SQLCipher database encryption key using the
+ * Android Keystore. On first launch a cryptographically random 256-bit key is
+ * generated and stored inside [EncryptedSharedPreferences], whose contents are
+ * sealed by a [MasterKey] backed by the hardware-protected Android Keystore.
+ *
+ * The raw key material is therefore never shipped in the JS bundle and never
+ * written to disk in plaintext. JavaScript retrieves it once via
+ * [getOrCreateDatabaseKey] and passes it to SQLCipher as the passphrase, and
+ * the native side reuses the SAME key for its own encrypted stores through the
+ * plain-`Context` helper [Companion.getOrCreateDatabaseKey].
+ */
+class SecureKeyModule(
+  private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String = NAME
+
+  /**
+   * Returns the persisted database key, generating and storing a new one on
+   * first use. Resolves with a hex-encoded 256-bit key string.
+   */
+  @ReactMethod
+  fun getOrCreateDatabaseKey(promise: Promise) {
+    try {
+      promise.resolve(getOrCreateDatabaseKey(reactContext))
+    } catch (e: Exception) {
+      promise.reject("SECURE_KEY_ERROR", "Failed to provision database key", e)
+    }
+  }
+
+  companion object {
+    const val NAME = "SecureKeyModule"
+    private const val PREFS_FILE = "rncc_secure_media_keys"
+    private const val KEY_PREF = "sqlcipher_db_key"
+
+    /**
+     * The persisted 64-hex-character SQLCipher passphrase, generating and storing a new one on
+     * first use. Usable from any component with a plain [Context] — the JS bridge above and the
+     * native compression cache ([CompressionCacheStore]) both open their encrypted databases with
+     * the exact same key, so there is a single Keystore-sealed secret rather than one per store.
+     *
+     * Synchronised so two callers racing to provision the key on first launch cannot each mint a
+     * different value and clobber one another.
+     */
+    @Synchronized
+    fun getOrCreateDatabaseKey(context: Context): String {
+      val prefs = openEncryptedPrefs(context)
+      val existing = prefs.getString(KEY_PREF, null)
+      if (existing != null && existing.isNotEmpty()) return existing
+
+      val generated = generateHexKey()
+      prefs.edit().putString(KEY_PREF, generated).apply()
+      return generated
+    }
+
+    private fun openEncryptedPrefs(context: Context) =
+      EncryptedSharedPreferences.create(
+        context.applicationContext,
+        PREFS_FILE,
+        MasterKey.Builder(context.applicationContext)
+          .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+          .build(),
+        EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+        EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+      )
+
+    /** Generates a random 256-bit key encoded as 64 lowercase hex characters. */
+    private fun generateHexKey(): String {
+      val bytes = ByteArray(32)
+      SecureRandom().nextBytes(bytes)
+      return bytes.joinToString("") { "%02x".format(it) }
+    }
+  }
+}