expo-crypto 15.0.9-canary-20260105-6b962e6 → 15.1.0-canary-20260113-0ce2b9c

package/CHANGELOG.md

@@ -6,6 +6,8 @@
 
 ### 🎉 New features
 
+- Added support for AES-GCM encryption. ([#41249](https://github.com/expo/expo/pull/41249) by [@barthap](https://github.com/barthap))
+
 ### 🐛 Bug fixes
 
 ### 💡 Others

package/android/build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '15.0.9-canary-20260105-6b962e6'
+version = '15.1.0-canary-20260113-0ce2b9c'
 
 android {
   namespace "expo.modules.crypto"
   defaultConfig {
     versionCode 25
-    versionName "15.0.9-canary-20260105-6b962e6"
+    versionName "15.1.0-canary-20260113-0ce2b9c"
   }
 }
 

package/android/src/main/java/expo/modules/crypto/aes/AesConfig.kt

@@ -0,0 +1,9 @@
+package expo.modules.crypto.aes
+
+object AesConfig {
+  const val DEFAULT_IV_SIZE: Int = 12
+  const val DEFAULT_TAG_SIZE: Int = 16
+
+  const val CRYPTO_KEY_ALGORITHM = "AES"
+  const val CIPHER_TRANSFORMATION_NAME = "AES/GCM/NoPadding"
+}

package/android/src/main/java/expo/modules/crypto/aes/AesCryptoModule.kt

@@ -0,0 +1,169 @@
+package expo.modules.crypto.aes
+
+import android.util.Base64
+import expo.modules.crypto.aes.AesConfig.CIPHER_TRANSFORMATION_NAME
+import expo.modules.crypto.aes.AesConfig.DEFAULT_TAG_SIZE
+import expo.modules.crypto.aes.enums.DataFormat
+import expo.modules.crypto.aes.enums.KeyEncoding
+import expo.modules.crypto.aes.enums.KeySize
+import expo.modules.crypto.aes.extensions.decrypt
+import expo.modules.crypto.aes.extensions.encoded
+import expo.modules.crypto.aes.extensions.encrypt
+import expo.modules.crypto.aes.extensions.formatted
+import expo.modules.crypto.aes.objects.EncryptionKey
+import expo.modules.crypto.aes.objects.SealedData
+import expo.modules.crypto.aes.records.CiphertextOptions
+import expo.modules.crypto.aes.records.DecryptOptions
+import expo.modules.crypto.aes.records.EncryptOptions
+import expo.modules.crypto.aes.records.SealedDataConfig
+import expo.modules.kotlin.apifeatures.EitherType
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.types.Either
+import java.nio.ByteBuffer
+import java.security.SecureRandom
+import javax.crypto.Cipher
+import javax.crypto.spec.GCMParameterSpec
+
+@OptIn(EitherType::class)
+typealias BinaryInput = Either<ByteArray, String>
+
+@OptIn(EitherType::class, ExperimentalStdlibApi::class)
+class AesCryptoModule : Module() {
+  private val rng: SecureRandom by lazy { SecureRandom() }
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoCryptoAES")
+
+    AsyncFunction("encryptAsync", this@AesCryptoModule::encrypt)
+    AsyncFunction("decryptAsync", this@AesCryptoModule::decrypt)
+
+    Class("EncryptionKey", EncryptionKey::class) {
+      Constructor {
+        throw Exceptions.IllegalArgument("EncryptionKey constructor cannot be used directly")
+      }
+
+      StaticAsyncFunction("generate") { size: KeySize? ->
+        EncryptionKey(size ?: KeySize.AES256)
+      }
+      StaticAsyncFunction("import") { input: Either<ByteArray, String>, encoding: KeyEncoding? ->
+        val bytes = if (input.`is`(ByteArray::class)) {
+          input.get(ByteArray::class)
+        } else {
+          val encodedString = input.get(String::class)
+          when (encoding) {
+            null -> throw MissingStringEncodingException()
+            KeyEncoding.BASE64 -> Base64.decode(encodedString, Base64.NO_WRAP)
+            KeyEncoding.HEX ->
+              encodedString
+                .lowercase()
+                .substringAfter("0x")
+                .hexToByteArray(HexFormat.Default)
+          }
+        }
+        EncryptionKey(bytes)
+      }
+
+      AsyncFunction("bytes") { key: EncryptionKey -> key.bytes }
+      AsyncFunction("encoded") { key: EncryptionKey, encoding: KeyEncoding ->
+        key.bytes.encoded(encoding)
+      }
+
+      Property("size") { key: EncryptionKey -> key.keySize }
+    }
+
+    Class("SealedData", SealedData::class) {
+      Constructor {
+        throw Exceptions.IllegalArgument("SealedData constructor cannot be used directly")
+      }
+
+      StaticFunction("fromParts", this@AesCryptoModule::sealedDataFromParts)
+      StaticFunction("fromCombined") { combined: ByteArray, config: SealedDataConfig? ->
+        val config = config ?: SealedDataConfig()
+        SealedData(config, content = combined)
+      }
+
+      AsyncFunction("iv") { sealedData: SealedData, format: DataFormat? ->
+        sealedData.ivBytes.formatted(format)
+      }
+      AsyncFunction("tag") { sealedData: SealedData, format: DataFormat? ->
+        sealedData.tagBytes.formatted(format)
+      }
+      AsyncFunction("combined") { sealedData: SealedData, format: DataFormat? ->
+        sealedData.combinedArray.formatted(format)
+      }
+      AsyncFunction("ciphertext") { sealedData: SealedData, options: CiphertextOptions? ->
+        val (includeTag, outputFormat) = options ?: CiphertextOptions()
+        sealedData.ciphertextBytes(withTag = includeTag).formatted(outputFormat)
+      }
+
+      Property("combinedSize") { sealedData -> sealedData.combinedSize }
+      Property("ivSize") { sealedData -> sealedData.ivSize }
+      Property("tagSize") { sealedData -> sealedData.tagSize }
+    }
+  }
+
+  private fun encrypt(
+    plaintext: BinaryInput,
+    key: EncryptionKey,
+    options: EncryptOptions?
+  ): SealedData {
+    val key = key.cryptoKey
+    val plaintextBuffer = ByteBuffer.wrap(plaintext.toBytes())
+
+    try {
+      val cipher = Cipher.getInstance(CIPHER_TRANSFORMATION_NAME).apply {
+        val params = options?.gcmParameterSpec(rng)
+        init(Cipher.ENCRYPT_MODE, key, params)
+        options?.additionalData?.let { updateAAD(it.toBytes()) }
+      }
+      return cipher.encrypt(plaintextBuffer)
+    } catch (err: Throwable) {
+      throw EncryptionFailed(err)
+    }
+  }
+
+  private fun decrypt(
+    sealedData: SealedData,
+    key: EncryptionKey,
+    options: DecryptOptions?
+  ): Any {
+    val key = key.cryptoKey
+
+    try {
+      val cipher = Cipher.getInstance(CIPHER_TRANSFORMATION_NAME).apply {
+        val spec = GCMParameterSpec(sealedData.tagSize * 8, sealedData.ivBytes)
+        init(Cipher.DECRYPT_MODE, key, spec)
+      }
+      options?.additionalData?.let { cipher.updateAAD(it.toBytes()) }
+
+      val plaintext = cipher.decrypt(sealedData)
+      return plaintext.array().formatted(options?.output)
+    } catch (err: Throwable) {
+      throw DecryptionFailed(err)
+    }
+  }
+
+  private fun sealedDataFromParts(iv: BinaryInput, ciphertext: BinaryInput, tag: Either<ByteArray, Int>?): SealedData {
+    val iv = iv.toBytes()
+    val ciphertext = ciphertext.toBytes()
+    return if (tag?.`is`(Int::class) == true) {
+      val tagLength = tag.get(Int::class)
+      SealedData(iv, ciphertext, tagLength)
+    } else if (tag?.`is`(ByteArray::class) == true) {
+      val tag = tag.get(ByteArray::class)
+      SealedData(iv, ciphertext + tag, tag.size)
+    } else {
+      SealedData(iv, ciphertext, DEFAULT_TAG_SIZE)
+    }
+  }
+
+  private fun BinaryInput.toBytes(): ByteArray {
+    if (this.`is`(ByteArray::class)) {
+      return this.get(ByteArray::class)
+    }
+
+    return Base64.decode(this.get(String::class), Base64.NO_WRAP)
+  }
+}

package/android/src/main/java/expo/modules/crypto/aes/AesExceptions.kt

@@ -0,0 +1,18 @@
+package expo.modules.crypto.aes
+
+import expo.modules.core.errors.CodedException
+
+class MissingStringEncodingException :
+  CodedException("'encoding' argument must be provided for string input")
+
+class InvalidKeyLengthException(byteLength: Int) :
+  CodedException("EncryptionKey cannot be created from bytes of length '$byteLength'")
+
+class InvalidSealedDataConfigException :
+  CodedException("Invalid SealedData config")
+
+class EncryptionFailed(cause: Throwable) :
+  CodedException("AES encryption failed: ${cause.message}", cause)
+
+class DecryptionFailed(cause: Throwable) :
+  CodedException("AES decryption failed: ${cause.message}", cause)

package/android/src/main/java/expo/modules/crypto/aes/enums/DataFormat.kt

@@ -0,0 +1,8 @@
+package expo.modules.crypto.aes.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class DataFormat(val value: String) : Enumerable {
+  BYTES("bytes"),
+  BASE64("base64")
+}

package/android/src/main/java/expo/modules/crypto/aes/enums/KeyEncoding.kt

@@ -0,0 +1,8 @@
+package expo.modules.crypto.aes.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class KeyEncoding(val value: String) : Enumerable {
+  BASE64("base64"),
+  HEX("hex")
+}

package/android/src/main/java/expo/modules/crypto/aes/enums/KeySize.kt

@@ -0,0 +1,19 @@
+package expo.modules.crypto.aes.enums
+
+import expo.modules.crypto.aes.InvalidKeyLengthException
+import expo.modules.kotlin.types.Enumerable
+
+enum class KeySize(val bitSize: Int) : Enumerable {
+  AES128(128),
+  AES192(192),
+  AES256(256);
+
+  val byteSize: Int
+    get() = bitSize / 8
+
+  companion object {
+    fun fromByteLength(byteLen: Int): KeySize =
+      entries.find { it.byteSize == byteLen }
+        ?: throw InvalidKeyLengthException(byteLen)
+  }
+}

package/android/src/main/java/expo/modules/crypto/aes/extensions/ByteArrayExtensions.kt

@@ -0,0 +1,31 @@
+package expo.modules.crypto.aes.extensions
+
+import android.util.Base64
+import expo.modules.crypto.aes.enums.DataFormat
+import expo.modules.crypto.aes.enums.KeyEncoding
+import java.nio.ByteBuffer
+
+fun ByteBuffer.copiedArray(): ByteArray =
+  ByteArray(remaining()).also { get(it) }
+
+inline fun ByteArray.init(block: ByteBuffer.() -> Unit): ByteArray = apply {
+  ByteBuffer.wrap(this).also { block(it) }
+}
+
+fun ByteArray.base64Encoded(): String =
+  Base64.encodeToString(this, Base64.NO_WRAP)
+
+fun ByteArray.hexEncoded(): String =
+  joinToString("") { "%02x".format(it) }
+
+fun ByteArray.encoded(encoding: KeyEncoding): String =
+  when (encoding) {
+    KeyEncoding.HEX -> this.hexEncoded()
+    KeyEncoding.BASE64 -> this.base64Encoded()
+  }
+
+fun ByteArray.formatted(format: DataFormat?): Any =
+  when (format) {
+    DataFormat.BYTES, null -> this
+    DataFormat.BASE64 -> this.base64Encoded()
+  }

package/android/src/main/java/expo/modules/crypto/aes/extensions/CipherExtensions.kt

@@ -0,0 +1,24 @@
+package expo.modules.crypto.aes.extensions
+
+import expo.modules.crypto.aes.objects.SealedData
+import java.nio.ByteBuffer
+import javax.crypto.Cipher
+
+internal fun Cipher.encrypt(plaintext: ByteBuffer): SealedData {
+  val plaintextSize = plaintext.remaining()
+  val ciphertextWithTagSize = getOutputSize(plaintextSize)
+  val tagSize = ciphertextWithTagSize - plaintextSize
+
+  return SealedData(iv, plaintextSize, tagSize).also {
+    doFinal(plaintext, it.taggedCiphertextBuffer)
+  }
+}
+
+internal fun Cipher.decrypt(sealedData: SealedData): ByteBuffer {
+  val inputBuf = sealedData.taggedCiphertextBuffer
+  val plaintextSize = getOutputSize(inputBuf.remaining())
+
+  return ByteBuffer.allocate(plaintextSize).also { outputBuf ->
+    doFinal(inputBuf, outputBuf)
+  }
+}

package/android/src/main/java/expo/modules/crypto/aes/objects/EncryptionKey.kt

@@ -0,0 +1,32 @@
+package expo.modules.crypto.aes.objects
+
+import expo.modules.crypto.aes.AesConfig.CRYPTO_KEY_ALGORITHM
+import expo.modules.crypto.aes.enums.KeySize
+import expo.modules.kotlin.sharedobjects.SharedObject
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.SecretKeySpec
+
+class EncryptionKey : SharedObject {
+  val keySize: KeySize
+  val cryptoKey: SecretKey
+
+  constructor(size: KeySize) {
+    val keygen = KeyGenerator.getInstance(CRYPTO_KEY_ALGORITHM).apply {
+      init(size.bitSize)
+    }
+
+    keySize = size
+    cryptoKey = keygen.generateKey()
+  }
+
+  constructor(bytes: ByteArray) {
+    keySize = KeySize.fromByteLength(bytes.size)
+    cryptoKey = SecretKeySpec(bytes, CRYPTO_KEY_ALGORITHM)
+  }
+
+  val bytes: ByteArray
+    get() = cryptoKey.encoded
+
+  override fun getAdditionalMemoryPressure(): Int = keySize.byteSize
+}

package/android/src/main/java/expo/modules/crypto/aes/objects/SealedData.kt

@@ -0,0 +1,79 @@
+package expo.modules.crypto.aes.objects
+
+import expo.modules.crypto.aes.InvalidSealedDataConfigException
+import expo.modules.crypto.aes.extensions.copiedArray
+import expo.modules.crypto.aes.extensions.init
+import expo.modules.crypto.aes.records.SealedDataConfig
+import expo.modules.kotlin.sharedobjects.SharedObject
+import java.nio.ByteBuffer
+
+/**
+ * Represents a contiguous memory area containing concatenated IV || ciphertext || tag.
+ */
+class SealedData(
+  private val config: SealedDataConfig,
+  private val content: ByteArray
+) : SharedObject() {
+  init {
+    if (content.size < ivSize + tagSize) {
+      throw InvalidSealedDataConfigException()
+    }
+  }
+
+  /**
+   * Initializes sealed data with given IV, and allocates memory for ciphertext and tag.
+   */
+  constructor(iv: ByteArray, ciphertextLength: Int, tagLength: Int) : this(
+    config = SealedDataConfig(ivLength = iv.size, tagLength = tagLength),
+    content = ByteArray(iv.size + ciphertextLength + tagLength).init {
+      put(iv)
+    }
+  )
+
+  /**
+   * Constructs sealed data from parts.
+   */
+  constructor(iv: ByteArray, ciphertextWithTag: ByteArray, tagLength: Int) : this(
+    config = SealedDataConfig(ivLength = iv.size, tagLength = tagLength),
+    content = iv + ciphertextWithTag
+  )
+
+  // buffers mapping specific memory regions
+  private val ivBuffer: ByteBuffer
+    get() = ByteBuffer.wrap(content, 0, ivSize)
+  private val tagBuffer: ByteBuffer
+    get() = ByteBuffer.wrap(content, content.size - tagSize, tagSize)
+  private val combinedBuffer: ByteBuffer
+    get() = ByteBuffer.wrap(content)
+  private val ciphertextBuffer: ByteBuffer
+    get() = ByteBuffer.wrap(content, ivSize, ciphertextSize)
+
+  /** Buffer used by `[javax.crypto.Cipher]` to perform encryption/decryption */
+  internal val taggedCiphertextBuffer: ByteBuffer
+    get() = ByteBuffer.wrap(content, ivSize, ciphertextSize + tagSize)
+
+  val combinedSize: Int
+    get() = content.size
+  val ivSize: Int
+    get() = config.ivLength
+  val tagSize: Int
+    get() = config.tagLength
+  val ciphertextSize: Int
+    get() = combinedSize - ivSize - tagSize
+
+  val ivBytes: ByteArray
+    get() = ivBuffer.copiedArray()
+  val tagBytes: ByteArray
+    get() = tagBuffer.copiedArray()
+  val combinedArray: ByteArray
+    get() = combinedBuffer.array()
+
+  fun ciphertextBytes(withTag: Boolean): ByteArray =
+    if (withTag) {
+      taggedCiphertextBuffer
+    } else {
+      ciphertextBuffer
+    }.copiedArray()
+
+  override fun getAdditionalMemoryPressure(): Int = content.size
+}

package/android/src/main/java/expo/modules/crypto/aes/records/CiphertextOptions.kt

@@ -0,0 +1,10 @@
+package expo.modules.crypto.aes.records
+
+import expo.modules.crypto.aes.enums.DataFormat
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class CiphertextOptions(
+  @Field val includeTag: Boolean = false,
+  @Field val outputFormat: DataFormat = DataFormat.BYTES
+) : Record

package/android/src/main/java/expo/modules/crypto/aes/records/DecryptOptions.kt

@@ -0,0 +1,16 @@
+package expo.modules.crypto.aes.records
+
+import expo.modules.crypto.aes.BinaryInput
+import expo.modules.crypto.aes.enums.DataFormat
+import expo.modules.kotlin.apifeatures.EitherType
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+@OptIn(EitherType::class)
+class DecryptOptions : Record {
+  @Field
+  val output: DataFormat = DataFormat.BYTES
+
+  @Field
+  val additionalData: BinaryInput? = null
+}

package/android/src/main/java/expo/modules/crypto/aes/records/EncryptOptions.kt

@@ -0,0 +1,44 @@
+package expo.modules.crypto.aes.records
+
+import android.util.Base64
+import expo.modules.crypto.aes.AesConfig.DEFAULT_IV_SIZE
+import expo.modules.crypto.aes.AesConfig.DEFAULT_TAG_SIZE
+import expo.modules.crypto.aes.BinaryInput
+import expo.modules.kotlin.apifeatures.EitherType
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.EitherOfThree
+import java.security.SecureRandom
+import javax.crypto.spec.GCMParameterSpec
+
+@OptIn(EitherType::class)
+class EncryptOptions : Record {
+  @Field
+  val nonce: EitherOfThree<String, ByteArray, Int>? = null
+
+  @Field
+  val tagLength: Int? = null
+
+  @Field
+  val additionalData: BinaryInput? = null
+
+  internal fun gcmParameterSpec(random: SecureRandom): GCMParameterSpec? {
+    // a default will be generated by Cipher
+    if (nonce == null && tagLength == null) {
+      return null
+    }
+
+    val iv = if (nonce == null) {
+      ByteArray(DEFAULT_IV_SIZE).also { random.nextBytes(it) }
+    } else if (nonce.`is`(Int::class)) {
+      ByteArray(nonce.get(Int::class)).also { random.nextBytes(it) }
+    } else if (nonce.`is`(String::class)) {
+      Base64.decode(nonce.get(String::class), Base64.NO_WRAP)
+    } else {
+      nonce.get(ByteArray::class)
+    }
+
+    val tagByteLength = tagLength ?: DEFAULT_TAG_SIZE
+    return GCMParameterSpec(tagByteLength * 8, iv)
+  }
+}

package/android/src/main/java/expo/modules/crypto/aes/records/SealedDataConfig.kt

@@ -0,0 +1,11 @@
+package expo.modules.crypto.aes.records
+
+import expo.modules.crypto.aes.AesConfig.DEFAULT_IV_SIZE
+import expo.modules.crypto.aes.AesConfig.DEFAULT_TAG_SIZE
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class SealedDataConfig(
+  @Field val ivLength: Int = DEFAULT_IV_SIZE,
+  @Field val tagLength: Int = DEFAULT_TAG_SIZE
+) : Record

package/build/Crypto.d.ts

@@ -1,6 +1,7 @@
 import { UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';
 import { CryptoDigestAlgorithm, CryptoDigestOptions, Digest } from './Crypto.types';
 export * from './Crypto.types';
+export * from './aes';
 /**
  * Generates completely random bytes using native implementations. The `byteCount` property
  * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.

package/build/Crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEjG,OAAO,EAAE,qBAAqB,EAAkB,mBAAmB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAKpG,cAAc,gBAAgB,CAAC;AAW/B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAoB5D;AAGD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAUhF;AA0CD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAsD,GAC9D,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,kBAAkB,GAAG,mBAAmB,EAChF,UAAU,EAAE,CAAC,GACZ,CAAC,CAGH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAcjG"}
+{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEjG,OAAO,EAAE,qBAAqB,EAAkB,mBAAmB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAKpG,cAAc,gBAAgB,CAAC;AAC/B,cAAc,OAAO,CAAC;AAWtB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAoB5D;AAGD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAUhF;AA0CD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAsD,GAC9D,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,kBAAkB,GAAG,mBAAmB,EAChF,UAAU,EAAE,CAAC,GACZ,CAAC,CAGH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAcjG"}

package/build/Crypto.js

@@ -2,6 +2,7 @@ import { UnavailabilityError } from 'expo-modules-core';
 import { CryptoDigestAlgorithm, CryptoEncoding } from './Crypto.types';
 import ExpoCrypto from './ExpoCrypto';
 export * from './Crypto.types';
+export * from './aes';
 class CryptoError extends TypeError {
     code = 'ERR_CRYPTO';
     constructor(message) {

package/build/Crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"Crypto.js","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import { UnavailabilityError, UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions, Digest } from './Crypto.types';\nimport ExpoCrypto from './ExpoCrypto';\n\ndeclare const global: any;\n\nexport * from './Crypto.types';\n\nclass CryptoError extends TypeError {\n  code = 'ERR_CRYPTO';\n\n  constructor(message: string) {\n    super(`expo-crypto: ${message}`);\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * Falls back to `Math.random` during development to prevent issues with React Native Debugger.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return An array of random bytes with the same length as the `byteCount`.\n */\nexport function getRandomBytes(byteCount: number): Uint8Array {\n  assertByteCount(byteCount, 'getRandomBytes');\n  const validByteCount = Math.floor(byteCount);\n  if (__DEV__) {\n    if (!global.nativeCallSyncHook || global.__REMOTEDEV__) {\n      // remote javascript debugging is enabled\n      const array = new Uint8Array(validByteCount);\n      for (let i = 0; i < validByteCount; i++) {\n        array[i] = Math.floor(Math.random() * 256);\n      }\n      return array;\n    }\n  }\n  if (ExpoCrypto.getRandomValues) {\n    const byteArray = new Uint8Array(validByteCount);\n    ExpoCrypto.getRandomValues(byteArray);\n    return byteArray;\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytes');\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.\n */\nexport async function getRandomBytesAsync(byteCount: number): Promise<Uint8Array> {\n  assertByteCount(byteCount, 'getRandomBytesAsync');\n  const validByteCount = Math.floor(byteCount);\n  if (ExpoCrypto.getRandomValues) {\n    const byteArray = new Uint8Array(validByteCount);\n    ExpoCrypto.getRandomValues(byteArray);\n    return byteArray;\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytesAsync');\n  }\n}\n\nfunction assertByteCount(value: any, methodName: string): void {\n  if (\n    typeof value !== 'number' ||\n    isNaN(value) ||\n    Math.floor(value) < 0 ||\n    Math.floor(value) > 1024\n  ) {\n    throw new TypeError(\n      `expo-crypto: ${methodName}(${value}) expected a valid number from range 0...1024`\n    );\n  }\n}\n\nfunction assertAlgorithm(algorithm: CryptoDigestAlgorithm): void {\n  if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {\n    throw new CryptoError(\n      `Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(\n        CryptoDigestAlgorithm\n      ).join(', AlgCryptoDigestAlgorithmorithm.')}`\n    );\n  }\n}\n\nfunction assertData(data: string): void {\n  if (typeof data !== 'string') {\n    throw new CryptoError(`Invalid data provided. Expected a string.`);\n  }\n}\n\nfunction assertEncoding(encoding: CryptoEncoding): void {\n  if (!Object.values(CryptoEncoding).includes(encoding)) {\n    throw new CryptoError(\n      `Invalid encoding provided. Expected one of: CryptoEncoding.${Object.keys(\n        CryptoEncoding\n      ).join(', CryptoEncoding.')}`\n    );\n  }\n}\n\n// @needsAudit\n/**\n * The `digestStringAsync()` method of `Crypto` generates a digest of the supplied `data` string with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @param options Format of the digest string. Defaults to: `CryptoDigestOptions.HEX`.\n * @return Return a Promise which fulfills with a value representing the hashed input.\n *\n * @example\n * ```ts\n * const digest = await Crypto.digestStringAsync(\n *   Crypto.CryptoDigestAlgorithm.SHA512,\n *   '🥓 Easy to Digest! 💙'\n * );\n * ```\n */\nexport async function digestStringAsync(\n  algorithm: CryptoDigestAlgorithm,\n  data: string,\n  options: CryptoDigestOptions = { encoding: CryptoEncoding.HEX }\n): Promise<Digest> {\n  if (!ExpoCrypto.digestStringAsync) {\n    throw new UnavailabilityError('expo-crypto', 'digestStringAsync');\n  }\n\n  assertAlgorithm(algorithm);\n  assertData(data);\n  assertEncoding(options.encoding);\n\n  return await ExpoCrypto.digestStringAsync(algorithm, data, options);\n}\n\n/**\n * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.\n *\n * @param typedArray An integer based [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) to fill with cryptographically secure random values. It modifies the input array in place.\n * @return The input array filled with cryptographically secure random values.\n *\n * @example\n * ```ts\n * const byteArray = new Uint8Array(16);\n * Crypto.getRandomValues(byteArray);\n * console.log('Your lucky bytes: ' + byteArray);\n * ```\n */\nexport function getRandomValues<T extends IntBasedTypedArray | UintBasedTypedArray>(\n  typedArray: T\n): T {\n  ExpoCrypto.getRandomValues(typedArray);\n  return typedArray;\n}\n\n/**\n * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).\n * It uses cryptographically secure random values to generate the UUID.\n *\n * @return A string containing a newly generated UUIDv4 identifier\n * @example\n * ```ts\n * const UUID = Crypto.randomUUID();\n * console.log('Your UUID: ' + UUID);\n * ```\n */\nexport function randomUUID(): string {\n  return ExpoCrypto.randomUUID();\n}\n\nconst digestLengths = {\n  [CryptoDigestAlgorithm.SHA1]: 20,\n  [CryptoDigestAlgorithm.SHA256]: 32,\n  [CryptoDigestAlgorithm.SHA384]: 48,\n  [CryptoDigestAlgorithm.SHA512]: 64,\n  [CryptoDigestAlgorithm.MD2]: 16,\n  [CryptoDigestAlgorithm.MD4]: 16,\n  [CryptoDigestAlgorithm.MD5]: 16,\n};\n\n/**\n * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.\n * @example\n * ```ts\n * const array = new Uint8Array([1, 2, 3, 4, 5]);\n * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);\n * console.log('Your digest: ' + digest);\n * ```\n */\nexport function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer> {\n  return new Promise((resolve, reject) => {\n    try {\n      if (typeof ExpoCrypto.digestAsync === 'function') {\n        resolve(ExpoCrypto.digestAsync(algorithm, data));\n      } else {\n        const output = new Uint8Array(digestLengths[algorithm]);\n        ExpoCrypto.digest(algorithm, output, data);\n        resolve(output.buffer);\n      }\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"]}
+{"version":3,"file":"Crypto.js","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import { UnavailabilityError, UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions, Digest } from './Crypto.types';\nimport ExpoCrypto from './ExpoCrypto';\n\ndeclare const global: any;\n\nexport * from './Crypto.types';\nexport * from './aes';\n\nclass CryptoError extends TypeError {\n  code = 'ERR_CRYPTO';\n\n  constructor(message: string) {\n    super(`expo-crypto: ${message}`);\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * Falls back to `Math.random` during development to prevent issues with React Native Debugger.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return An array of random bytes with the same length as the `byteCount`.\n */\nexport function getRandomBytes(byteCount: number): Uint8Array {\n  assertByteCount(byteCount, 'getRandomBytes');\n  const validByteCount = Math.floor(byteCount);\n  if (__DEV__) {\n    if (!global.nativeCallSyncHook || global.__REMOTEDEV__) {\n      // remote javascript debugging is enabled\n      const array = new Uint8Array(validByteCount);\n      for (let i = 0; i < validByteCount; i++) {\n        array[i] = Math.floor(Math.random() * 256);\n      }\n      return array;\n    }\n  }\n  if (ExpoCrypto.getRandomValues) {\n    const byteArray = new Uint8Array(validByteCount);\n    ExpoCrypto.getRandomValues(byteArray);\n    return byteArray;\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytes');\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.\n */\nexport async function getRandomBytesAsync(byteCount: number): Promise<Uint8Array> {\n  assertByteCount(byteCount, 'getRandomBytesAsync');\n  const validByteCount = Math.floor(byteCount);\n  if (ExpoCrypto.getRandomValues) {\n    const byteArray = new Uint8Array(validByteCount);\n    ExpoCrypto.getRandomValues(byteArray);\n    return byteArray;\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytesAsync');\n  }\n}\n\nfunction assertByteCount(value: any, methodName: string): void {\n  if (\n    typeof value !== 'number' ||\n    isNaN(value) ||\n    Math.floor(value) < 0 ||\n    Math.floor(value) > 1024\n  ) {\n    throw new TypeError(\n      `expo-crypto: ${methodName}(${value}) expected a valid number from range 0...1024`\n    );\n  }\n}\n\nfunction assertAlgorithm(algorithm: CryptoDigestAlgorithm): void {\n  if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {\n    throw new CryptoError(\n      `Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(\n        CryptoDigestAlgorithm\n      ).join(', AlgCryptoDigestAlgorithmorithm.')}`\n    );\n  }\n}\n\nfunction assertData(data: string): void {\n  if (typeof data !== 'string') {\n    throw new CryptoError(`Invalid data provided. Expected a string.`);\n  }\n}\n\nfunction assertEncoding(encoding: CryptoEncoding): void {\n  if (!Object.values(CryptoEncoding).includes(encoding)) {\n    throw new CryptoError(\n      `Invalid encoding provided. Expected one of: CryptoEncoding.${Object.keys(\n        CryptoEncoding\n      ).join(', CryptoEncoding.')}`\n    );\n  }\n}\n\n// @needsAudit\n/**\n * The `digestStringAsync()` method of `Crypto` generates a digest of the supplied `data` string with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @param options Format of the digest string. Defaults to: `CryptoDigestOptions.HEX`.\n * @return Return a Promise which fulfills with a value representing the hashed input.\n *\n * @example\n * ```ts\n * const digest = await Crypto.digestStringAsync(\n *   Crypto.CryptoDigestAlgorithm.SHA512,\n *   '🥓 Easy to Digest! 💙'\n * );\n * ```\n */\nexport async function digestStringAsync(\n  algorithm: CryptoDigestAlgorithm,\n  data: string,\n  options: CryptoDigestOptions = { encoding: CryptoEncoding.HEX }\n): Promise<Digest> {\n  if (!ExpoCrypto.digestStringAsync) {\n    throw new UnavailabilityError('expo-crypto', 'digestStringAsync');\n  }\n\n  assertAlgorithm(algorithm);\n  assertData(data);\n  assertEncoding(options.encoding);\n\n  return await ExpoCrypto.digestStringAsync(algorithm, data, options);\n}\n\n/**\n * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.\n *\n * @param typedArray An integer based [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) to fill with cryptographically secure random values. It modifies the input array in place.\n * @return The input array filled with cryptographically secure random values.\n *\n * @example\n * ```ts\n * const byteArray = new Uint8Array(16);\n * Crypto.getRandomValues(byteArray);\n * console.log('Your lucky bytes: ' + byteArray);\n * ```\n */\nexport function getRandomValues<T extends IntBasedTypedArray | UintBasedTypedArray>(\n  typedArray: T\n): T {\n  ExpoCrypto.getRandomValues(typedArray);\n  return typedArray;\n}\n\n/**\n * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).\n * It uses cryptographically secure random values to generate the UUID.\n *\n * @return A string containing a newly generated UUIDv4 identifier\n * @example\n * ```ts\n * const UUID = Crypto.randomUUID();\n * console.log('Your UUID: ' + UUID);\n * ```\n */\nexport function randomUUID(): string {\n  return ExpoCrypto.randomUUID();\n}\n\nconst digestLengths = {\n  [CryptoDigestAlgorithm.SHA1]: 20,\n  [CryptoDigestAlgorithm.SHA256]: 32,\n  [CryptoDigestAlgorithm.SHA384]: 48,\n  [CryptoDigestAlgorithm.SHA512]: 64,\n  [CryptoDigestAlgorithm.MD2]: 16,\n  [CryptoDigestAlgorithm.MD4]: 16,\n  [CryptoDigestAlgorithm.MD5]: 16,\n};\n\n/**\n * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.\n * @example\n * ```ts\n * const array = new Uint8Array([1, 2, 3, 4, 5]);\n * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);\n * console.log('Your digest: ' + digest);\n * ```\n */\nexport function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer> {\n  return new Promise((resolve, reject) => {\n    try {\n      if (typeof ExpoCrypto.digestAsync === 'function') {\n        resolve(ExpoCrypto.digestAsync(algorithm, data));\n      } else {\n        const output = new Uint8Array(digestLengths[algorithm]);\n        ExpoCrypto.digest(algorithm, output, data);\n        resolve(output.buffer);\n      }\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"]}