expo-crypto 12.0.0 → 12.2.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 12.2.0 — 2023-02-03
+
+### 🎉 New features
+
+- Added a `digest` method to get a cryptographic digest of a typed array. ([#20886](https://github.com/expo/expo/pull/20886) by [@aleqsio](https://github.com/aleqsio))
+
+### 💡 Others
+
+- On Android bump `compileSdkVersion` and `targetSdkVersion` to `33`. ([#20721](https://github.com/expo/expo/pull/20721) by [@lukmccall](https://github.com/lukmccall))
+
+## 12.1.0 — 2022-12-30
+
+### 🎉 New features
+
+- Added a `randomUUID` method to get a random UUIDv4 string. ([#20274](https://github.com/expo/expo/pull/20274) by [@aleqsio](https://github.com/aleqsio))
+- Added a `getRandomValues` method to fill typed arrays. ([#20257](https://github.com/expo/expo/pull/20257) by [@aleqsio](https://github.com/aleqsio))
+- Ported over `getRandomBytes`, `getRandomBytesAsync` methods from `expo-random`. ([#20217](https://github.com/expo/expo/pull/20217) by [@aleqsio](https://github.com/aleqsio))
+
 ## 12.0.0 — 2022-10-25
 
 ### 🛠 Breaking changes

package/README.md

@@ -4,7 +4,7 @@ Provides cryptography primitives.
 
 # API documentation
 
-- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/crypto.md)
+- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/crypto.mdx)
 - [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/crypto/)
 
 # Installation in managed Expo projects

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '12.0.0'
+version = '12.2.0'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -59,7 +59,7 @@ afterEvaluate {
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 31)
+  compileSdkVersion safeExtGet("compileSdkVersion", 33)
 
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_11
@@ -72,9 +72,9 @@ android {
 
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 31)
+    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 25
-    versionName "12.0.0"
+    versionName "12.2.0"
   }
   lintOptions {
     abortOnError false

package/android/src/main/java/expo/modules/crypto/CryptoModule.kt

@@ -3,14 +3,32 @@ package expo.modules.crypto
 import android.util.Base64
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.typedarray.TypedArray
 import java.security.MessageDigest
+import java.security.SecureRandom
+import java.util.UUID
 
 class CryptoModule : Module() {
+  private val secureRandom by lazy { SecureRandom() }
+
   override fun definition() = ModuleDefinition {
     Name("ExpoCrypto")
 
     Function("digestString", this@CryptoModule::digestString)
     AsyncFunction("digestStringAsync", this@CryptoModule::digestString)
+    Function("getRandomBase64String", this@CryptoModule::getRandomBase64String)
+    AsyncFunction("getRandomBase64StringAsync", this@CryptoModule::getRandomBase64String)
+    Function("getRandomValues", this@CryptoModule::getRandomValues)
+    Function("digest", this@CryptoModule::digest)
+    Function("randomUUID") {
+      UUID.randomUUID().toString()
+    }
+  }
+
+  private fun getRandomBase64String(randomByteCount: Int): String {
+    val output = ByteArray(randomByteCount)
+    secureRandom.nextBytes(output)
+    return Base64.encodeToString(output, Base64.NO_WRAP)
   }
 
   private fun digestString(algorithm: DigestAlgorithm, data: String, options: DigestOptions): String {
@@ -30,4 +48,17 @@ class CryptoModule : Module() {
       }
     }
   }
+
+  private fun digest(algorithm: DigestAlgorithm, output: TypedArray, data: TypedArray) {
+    val messageDigest = MessageDigest.getInstance(algorithm.value).apply { update(data.toDirectBuffer()) }
+
+    val digest: ByteArray = messageDigest.digest()
+    output.write(digest, output.byteOffset, output.byteLength)
+  }
+
+  private fun getRandomValues(typedArray: TypedArray) {
+    val array = ByteArray(typedArray.byteLength)
+    secureRandom.nextBytes(array)
+    typedArray.write(array, typedArray.byteOffset, typedArray.byteLength)
+  }
 }

package/build/Crypto.d.ts

@@ -1,11 +1,27 @@
+import { UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';
 import { CryptoDigestAlgorithm, CryptoDigestOptions, Digest } from './Crypto.types';
 export * from './Crypto.types';
+/**
+ * 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`.
+ * Falls back to `Math.random` during development to prevent issues with React Native Debugger.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return An array of random bytes with the same length as the `byteCount`.
+ */
+export declare function getRandomBytes(byteCount: number): Uint8Array;
+/**
+ * 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`.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.
+ */
+export declare function getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
 /**
  * The `digestStringAsync()` method of `Crypto` generates a digest of the supplied `data` string with the provided digest `algorithm`.
  * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
  * meaning that it's very difficult to generate multiple inputs that have equal digest values.
  * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.
- * On web, this method can only be called from a secure origin (https) otherwise an error will be thrown.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
  *
  * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
  * @param data The value that will be used to generate a digest.
@@ -21,4 +37,47 @@ export * from './Crypto.types';
  * ```
  */
 export declare function digestStringAsync(algorithm: CryptoDigestAlgorithm, data: string, options?: CryptoDigestOptions): Promise<Digest>;
+/**
+ * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.
+ *
+ * @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.
+ * @return The input array filled with cryptographically secure random values.
+ *
+ * @example
+ * ```ts
+ * const byteArray = new Uint8Array(16);
+ * Crypto.getRandomValues(byteArray);
+ * console.log('Your lucky bytes: ' + byteArray);
+ * ```
+ */
+export declare function getRandomValues<T extends IntBasedTypedArray | UintBasedTypedArray>(typedArray: T): T;
+/**
+ * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).
+ * It uses cryptographically secure random values to generate the UUID.
+ *
+ * @return A string containing a newly generated UUIDv4 identifier
+ * @example
+ * ```ts
+ * const UUID = Crypto.randomUUID();
+ * console.log('Your UUID: ' + UUID);
+ * ```
+ */
+export declare function randomUUID(): any;
+/**
+ * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.
+ * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
+ * meaning that it's very difficult to generate multiple inputs that have equal digest values.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
+ *
+ * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
+ * @param data The value that will be used to generate a digest.
+ * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.
+ * @example
+ * ```ts
+ * const array = new Uint8Array([1, 2, 3, 4, 5]);
+ * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);
+ * console.log('Your digest: ' + digest);
+ * ```
+ */
+export declare function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
 //# sourceMappingURL=Crypto.d.ts.map

package/build/Crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAkB,mBAAmB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGpG,cAAc,gBAAgB,CAAC;AAqC/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAsD,GAC9D,OAAO,CAAC,MAAM,CAAC,CAUjB"}
+{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"AACA,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,CAqB5D;AAGD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAWhF;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,QAEzB;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAcjG"}

package/build/Crypto.js

@@ -1,3 +1,4 @@
+import { toByteArray } from 'base64-js';
 import { UnavailabilityError } from 'expo-modules-core';
 import { CryptoDigestAlgorithm, CryptoEncoding } from './Crypto.types';
 import ExpoCrypto from './ExpoCrypto';
@@ -8,6 +9,67 @@ class CryptoError extends TypeError {
         super(`expo-crypto: ${message}`);
     }
 }
+// @needsAudit
+/**
+ * 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`.
+ * Falls back to `Math.random` during development to prevent issues with React Native Debugger.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return An array of random bytes with the same length as the `byteCount`.
+ */
+export function getRandomBytes(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytes');
+    const validByteCount = Math.floor(byteCount);
+    if (__DEV__) {
+        if (!global.nativeCallSyncHook || global.__REMOTEDEV__) {
+            // remote javascript debugging is enabled
+            const array = new Uint8Array(validByteCount);
+            for (let i = 0; i < validByteCount; i++) {
+                array[i] = Math.floor(Math.random() * 256);
+            }
+            return array;
+        }
+    }
+    if (ExpoCrypto.getRandomBytes) {
+        return ExpoCrypto.getRandomBytes(validByteCount);
+    }
+    else if (ExpoCrypto.getRandomBase64String) {
+        const base64 = ExpoCrypto.getRandomBase64String(validByteCount);
+        return toByteArray(base64);
+    }
+    else {
+        throw new UnavailabilityError('expo-crypto', 'getRandomBytes');
+    }
+}
+// @needsAudit
+/**
+ * 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`.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.
+ */
+export async function getRandomBytesAsync(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytesAsync');
+    const validByteCount = Math.floor(byteCount);
+    if (ExpoCrypto.getRandomBytesAsync) {
+        return await ExpoCrypto.getRandomBytesAsync(validByteCount);
+    }
+    else if (ExpoCrypto.getRandomBase64StringAsync) {
+        const base64 = await ExpoCrypto.getRandomBase64StringAsync(validByteCount);
+        return toByteArray(base64);
+    }
+    else {
+        throw new UnavailabilityError('expo-crypto', 'getRandomBytesAsync');
+    }
+}
+function assertByteCount(value, methodName) {
+    if (typeof value !== 'number' ||
+        isNaN(value) ||
+        Math.floor(value) < 0 ||
+        Math.floor(value) > 1024) {
+        throw new TypeError(`expo-crypto: ${methodName}(${value}) expected a valid number from range 0...1024`);
+    }
+}
 function assertAlgorithm(algorithm) {
     if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {
         throw new CryptoError(`Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(CryptoDigestAlgorithm).join(', AlgCryptoDigestAlgorithmorithm.')}`);
@@ -29,7 +91,7 @@ function assertEncoding(encoding) {
  * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
  * meaning that it's very difficult to generate multiple inputs that have equal digest values.
  * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.
- * On web, this method can only be called from a secure origin (https) otherwise an error will be thrown.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
  *
  * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
  * @param data The value that will be used to generate a digest.
@@ -53,4 +115,77 @@ export async function digestStringAsync(algorithm, data, options = { encoding: C
     assertEncoding(options.encoding);
     return await ExpoCrypto.digestStringAsync(algorithm, data, options);
 }
+/**
+ * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.
+ *
+ * @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.
+ * @return The input array filled with cryptographically secure random values.
+ *
+ * @example
+ * ```ts
+ * const byteArray = new Uint8Array(16);
+ * Crypto.getRandomValues(byteArray);
+ * console.log('Your lucky bytes: ' + byteArray);
+ * ```
+ */
+export function getRandomValues(typedArray) {
+    ExpoCrypto.getRandomValues(typedArray);
+    return typedArray;
+}
+/**
+ * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).
+ * It uses cryptographically secure random values to generate the UUID.
+ *
+ * @return A string containing a newly generated UUIDv4 identifier
+ * @example
+ * ```ts
+ * const UUID = Crypto.randomUUID();
+ * console.log('Your UUID: ' + UUID);
+ * ```
+ */
+export function randomUUID() {
+    return ExpoCrypto.randomUUID();
+}
+const digestLengths = {
+    [CryptoDigestAlgorithm.SHA1]: 20,
+    [CryptoDigestAlgorithm.SHA256]: 32,
+    [CryptoDigestAlgorithm.SHA384]: 48,
+    [CryptoDigestAlgorithm.SHA512]: 64,
+    [CryptoDigestAlgorithm.MD2]: 16,
+    [CryptoDigestAlgorithm.MD4]: 16,
+    [CryptoDigestAlgorithm.MD5]: 16,
+};
+/**
+ * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.
+ * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
+ * meaning that it's very difficult to generate multiple inputs that have equal digest values.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
+ *
+ * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
+ * @param data The value that will be used to generate a digest.
+ * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.
+ * @example
+ * ```ts
+ * const array = new Uint8Array([1, 2, 3, 4, 5]);
+ * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);
+ * console.log('Your digest: ' + digest);
+ * ```
+ */
+export function digest(algorithm, data) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (typeof ExpoCrypto.digestAsync === 'function') {
+                resolve(ExpoCrypto.digestAsync(algorithm, data));
+            }
+            else {
+                const output = new Uint8Array(digestLengths[algorithm]);
+                ExpoCrypto.digest(algorithm, output, data);
+                resolve(output.buffer);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
 //# sourceMappingURL=Crypto.js.map

package/build/Crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"Crypto.js","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAA+B,MAAM,gBAAgB,CAAC;AACpG,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAY,SAAQ,SAAS;IACjC,IAAI,GAAG,YAAY,CAAC;IAEpB,YAAY,OAAe;QACzB,KAAK,CAAC,gBAAgB,OAAO,EAAE,CAAC,CAAC;IACnC,CAAC;CACF;AAED,SAAS,eAAe,CAAC,SAAgC;IACvD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;QAC7D,MAAM,IAAI,WAAW,CACnB,sEAAsE,MAAM,CAAC,IAAI,CAC/E,qBAAqB,CACtB,CAAC,IAAI,CAAC,mCAAmC,CAAC,EAAE,CAC9C,CAAC;KACH;AACH,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,WAAW,CAAC,2CAA2C,CAAC,CAAC;KACpE;AACH,CAAC;AAED,SAAS,cAAc,CAAC,QAAwB;IAC9C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACrD,MAAM,IAAI,WAAW,CACnB,8DAA8D,MAAM,CAAC,IAAI,CACvE,cAAc,CACf,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAC9B,CAAC;KACH;AACH,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAgC,EAChC,IAAY,EACZ,UAA+B,EAAE,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE;IAE/D,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE;QACjC,MAAM,IAAI,mBAAmB,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC;KACnE;IAED,eAAe,CAAC,SAAS,CAAC,CAAC;IAC3B,UAAU,CAAC,IAAI,CAAC,CAAC;IACjB,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEjC,OAAO,MAAM,UAAU,CAAC,iBAAiB,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AACtE,CAAC","sourcesContent":["import { UnavailabilityError } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions, Digest } from './Crypto.types';\nimport ExpoCrypto from './ExpoCrypto';\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\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"]}
+{"version":3,"file":"Crypto.js","sourceRoot":"","sources":["../src/Crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import { toByteArray } from 'base64-js';\nimport { 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.getRandomBytes) {\n    return ExpoCrypto.getRandomBytes(validByteCount);\n  } else if (ExpoCrypto.getRandomBase64String) {\n    const base64 = ExpoCrypto.getRandomBase64String(validByteCount);\n    return toByteArray(base64);\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.getRandomBytesAsync) {\n    return await ExpoCrypto.getRandomBytesAsync(validByteCount);\n  } else if (ExpoCrypto.getRandomBase64StringAsync) {\n    const base64 = await ExpoCrypto.getRandomBase64StringAsync(validByteCount);\n    return toByteArray(base64);\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() {\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"]}

package/build/Crypto.types.d.ts

@@ -42,11 +42,11 @@ export declare enum CryptoEncoding {
      */
     BASE64 = "base64"
 }
-export declare type CryptoDigestOptions = {
+export type CryptoDigestOptions = {
     /**
      * Format the digest is returned in.
      */
     encoding: CryptoEncoding;
 };
-export declare type Digest = string;
+export type Digest = string;
 //# sourceMappingURL=Crypto.types.d.ts.map

package/build/Crypto.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Crypto.types.d.ts","sourceRoot":"","sources":["../src/Crypto.types.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,oBAAY,qBAAqB;IAC/B;;OAEG;IACH,IAAI,UAAU;IACd;;OAEG;IACH,MAAM,YAAY;IAClB;;OAEG;IACH,MAAM,YAAY;IAClB;;OAEG;IACH,MAAM,YAAY;IAClB;;;OAGG;IACH,GAAG,QAAQ;IACX;;;OAGG;IACH,GAAG,QAAQ;IACX;;;;OAIG;IACH,GAAG,QAAQ;CACZ;AAGD,oBAAY,cAAc;IACxB,GAAG,QAAQ;IACX;;OAEG;IACH,MAAM,WAAW;CAClB;AAGD,oBAAY,mBAAmB,GAAG;IAChC;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAAC;AAGF,oBAAY,MAAM,GAAG,MAAM,CAAC"}
+{"version":3,"file":"Crypto.types.d.ts","sourceRoot":"","sources":["../src/Crypto.types.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,oBAAY,qBAAqB;IAC/B;;OAEG;IACH,IAAI,UAAU;IACd;;OAEG;IACH,MAAM,YAAY;IAClB;;OAEG;IACH,MAAM,YAAY;IAClB;;OAEG;IACH,MAAM,YAAY;IAClB;;;OAGG;IACH,GAAG,QAAQ;IACX;;;OAGG;IACH,GAAG,QAAQ;IACX;;;;OAIG;IACH,GAAG,QAAQ;CACZ;AAGD,oBAAY,cAAc;IACxB,GAAG,QAAQ;IACX;;OAEG;IACH,MAAM,WAAW;CAClB;AAGD,MAAM,MAAM,mBAAmB,GAAG;IAChC;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAAC;AAGF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC"}

package/build/ExpoCrypto.web.d.ts

@@ -1,7 +1,13 @@
+import { TypedArray } from 'expo-modules-core';
 import { CryptoDigestAlgorithm, CryptoDigestOptions } from './Crypto.types';
 declare const _default: {
     readonly name: string;
     digestStringAsync(algorithm: CryptoDigestAlgorithm, data: string, options: CryptoDigestOptions): Promise<string>;
+    getRandomBytes(length: number): Uint8Array;
+    getRandomBytesAsync(length: number): Promise<Uint8Array>;
+    getRandomValues(typedArray: TypedArray): TypedArray;
+    randomUUID(): string;
+    digestAsync(algorithm: AlgorithmIdentifier, data: ArrayBuffer): Promise<ArrayBuffer>;
 };
 export default _default;
 //# sourceMappingURL=ExpoCrypto.web.d.ts.map

package/build/ExpoCrypto.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoCrypto.web.d.ts","sourceRoot":"","sources":["../src/ExpoCrypto.web.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAkB,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;;;iCAO7E,qBAAqB,QAC1B,MAAM,WACH,mBAAmB,GAC3B,QAAQ,MAAM,CAAC;;AARpB,wBAyBE"}
+{"version":3,"file":"ExpoCrypto.web.d.ts","sourceRoot":"","sources":["../src/ExpoCrypto.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAkB,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;;;iCAS7E,qBAAqB,QAC1B,MAAM,WACH,mBAAmB,GAC3B,QAAQ,MAAM,CAAC;2BAiBK,MAAM,GAAG,UAAU;gCAIR,MAAM,GAAG,QAAQ,UAAU,CAAC;gCAIlC,UAAU;;2BAMf,mBAAmB,QAAQ,WAAW,GAAG,QAAQ,WAAW,CAAC;;AAvCtF,wBA0CE"}

package/build/ExpoCrypto.web.js

@@ -1,5 +1,6 @@
 import { CodedError } from 'expo-modules-core';
 import { CryptoEncoding } from './Crypto.types';
+const getCrypto = () => window.crypto ?? window.msCrypto;
 export default {
     get name() {
         return 'ExpoCrypto';
@@ -19,6 +20,23 @@ export default {
         }
         throw new CodedError('ERR_CRYPTO_DIGEST', 'Invalid encoding type provided.');
     },
+    getRandomBytes(length) {
+        const array = new Uint8Array(length);
+        return getCrypto().getRandomValues(array);
+    },
+    async getRandomBytesAsync(length) {
+        const array = new Uint8Array(length);
+        return getCrypto().getRandomValues(array);
+    },
+    getRandomValues(typedArray) {
+        return getCrypto().getRandomValues(typedArray);
+    },
+    randomUUID() {
+        return getCrypto().randomUUID();
+    },
+    digestAsync(algorithm, data) {
+        return getCrypto().subtle.digest(algorithm, data);
+    },
 };
 function hexString(buffer) {
     const byteArray = new Uint8Array(buffer);

package/build/ExpoCrypto.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoCrypto.web.js","sourceRoot":"","sources":["../src/ExpoCrypto.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,EAAyB,cAAc,EAAuB,MAAM,gBAAgB,CAAC;AAE5F,eAAe;IACb,IAAI,IAAI;QACN,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,KAAK,CAAC,iBAAiB,CACrB,SAAgC,EAChC,IAAY,EACZ,OAA4B;QAE5B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAClB,MAAM,IAAI,UAAU,CAClB,wBAAwB,EACxB,sEAAsE,CACvE,CAAC;SACH;QACD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACjE,IAAI,OAAO,CAAC,QAAQ,KAAK,cAAc,CAAC,GAAG,EAAE;YAC3C,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;SAC9B;aAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,cAAc,CAAC,MAAM,EAAE;YACrD,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;SACjE;QACD,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAC;IAC/E,CAAC;CACF,CAAC;AAEF,SAAS,SAAS,CAAC,MAAmB;IACpC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACnC,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC/C,OAAO,aAAa,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC","sourcesContent":["import { CodedError } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions } from './Crypto.types';\n\nexport default {\n  get name(): string {\n    return 'ExpoCrypto';\n  },\n  async digestStringAsync(\n    algorithm: CryptoDigestAlgorithm,\n    data: string,\n    options: CryptoDigestOptions\n  ): Promise<string> {\n    if (!crypto.subtle) {\n      throw new CodedError(\n        'ERR_CRYPTO_UNAVAILABLE',\n        'Access to the WebCrypto API is restricted to secure origins (https).'\n      );\n    }\n    const encoder = new TextEncoder();\n    const buffer = encoder.encode(data);\n    const hashedData = await crypto.subtle.digest(algorithm, buffer);\n    if (options.encoding === CryptoEncoding.HEX) {\n      return hexString(hashedData);\n    } else if (options.encoding === CryptoEncoding.BASE64) {\n      return btoa(String.fromCharCode(...new Uint8Array(hashedData)));\n    }\n    throw new CodedError('ERR_CRYPTO_DIGEST', 'Invalid encoding type provided.');\n  },\n};\n\nfunction hexString(buffer: ArrayBuffer): string {\n  const byteArray = new Uint8Array(buffer);\n\n  const hexCodes = [...byteArray].map((value) => {\n    const hexCode = value.toString(16);\n    const paddedHexCode = hexCode.padStart(2, '0');\n    return paddedHexCode;\n  });\n\n  return hexCodes.join('');\n}\n"]}
+{"version":3,"file":"ExpoCrypto.web.js","sourceRoot":"","sources":["../src/ExpoCrypto.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAyB,cAAc,EAAuB,MAAM,gBAAgB,CAAC;AAE5F,MAAM,SAAS,GAAG,GAAW,EAAE,CAAC,MAAM,CAAC,MAAM,IAAK,MAAc,CAAC,QAAQ,CAAC;AAE1E,eAAe;IACb,IAAI,IAAI;QACN,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,KAAK,CAAC,iBAAiB,CACrB,SAAgC,EAChC,IAAY,EACZ,OAA4B;QAE5B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAClB,MAAM,IAAI,UAAU,CAClB,wBAAwB,EACxB,sEAAsE,CACvE,CAAC;SACH;QACD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACjE,IAAI,OAAO,CAAC,QAAQ,KAAK,cAAc,CAAC,GAAG,EAAE;YAC3C,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;SAC9B;aAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,cAAc,CAAC,MAAM,EAAE;YACrD,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;SACjE;QACD,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAC;IAC/E,CAAC;IACD,cAAc,CAAC,MAAc;QAC3B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,SAAS,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD,KAAK,CAAC,mBAAmB,CAAC,MAAc;QACtC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,SAAS,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD,eAAe,CAAC,UAAsB;QACpC,OAAO,SAAS,EAAE,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC;IACD,UAAU;QACR,OAAO,SAAS,EAAE,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IACD,WAAW,CAAC,SAA8B,EAAE,IAAiB;QAC3D,OAAO,SAAS,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;CACF,CAAC;AAEF,SAAS,SAAS,CAAC,MAAmB;IACpC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IAEzC,MAAM,QAAQ,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACnC,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC/C,OAAO,aAAa,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC","sourcesContent":["import { CodedError, TypedArray } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions } from './Crypto.types';\n\nconst getCrypto = (): Crypto => window.crypto ?? (window as any).msCrypto;\n\nexport default {\n  get name(): string {\n    return 'ExpoCrypto';\n  },\n  async digestStringAsync(\n    algorithm: CryptoDigestAlgorithm,\n    data: string,\n    options: CryptoDigestOptions\n  ): Promise<string> {\n    if (!crypto.subtle) {\n      throw new CodedError(\n        'ERR_CRYPTO_UNAVAILABLE',\n        'Access to the WebCrypto API is restricted to secure origins (https).'\n      );\n    }\n    const encoder = new TextEncoder();\n    const buffer = encoder.encode(data);\n    const hashedData = await crypto.subtle.digest(algorithm, buffer);\n    if (options.encoding === CryptoEncoding.HEX) {\n      return hexString(hashedData);\n    } else if (options.encoding === CryptoEncoding.BASE64) {\n      return btoa(String.fromCharCode(...new Uint8Array(hashedData)));\n    }\n    throw new CodedError('ERR_CRYPTO_DIGEST', 'Invalid encoding type provided.');\n  },\n  getRandomBytes(length: number): Uint8Array {\n    const array = new Uint8Array(length);\n    return getCrypto().getRandomValues(array);\n  },\n  async getRandomBytesAsync(length: number): Promise<Uint8Array> {\n    const array = new Uint8Array(length);\n    return getCrypto().getRandomValues(array);\n  },\n  getRandomValues(typedArray: TypedArray) {\n    return getCrypto().getRandomValues(typedArray);\n  },\n  randomUUID() {\n    return getCrypto().randomUUID();\n  },\n  digestAsync(algorithm: AlgorithmIdentifier, data: ArrayBuffer): Promise<ArrayBuffer> {\n    return getCrypto().subtle.digest(algorithm, data);\n  },\n};\n\nfunction hexString(buffer: ArrayBuffer): string {\n  const byteArray = new Uint8Array(buffer);\n\n  const hexCodes = [...byteArray].map((value) => {\n    const hexCode = value.toString(16);\n    const paddedHexCode = hexCode.padStart(2, '0');\n    return paddedHexCode;\n  });\n\n  return hexCodes.join('');\n}\n"]}

package/ios/CryptoModule.swift

@@ -10,9 +10,31 @@ public class CryptoModule: Module {
     AsyncFunction("digestStringAsync", digestString)
 
     Function("digestString", digestString)
+
+    AsyncFunction("getRandomBase64StringAsync", getRandomBase64String)
+
+    Function("getRandomBase64String", getRandomBase64String)
+
+    Function("getRandomValues", getRandomValues)
+
+    Function("digest", digest)
+
+    Function("randomUUID") {
+      UUID().uuidString
+    }
   }
 }
 
+private func getRandomBase64String(length: Int) throws -> String {
+  var bytes = [UInt8](repeating: 0, count: length)
+  let status = SecRandomCopyBytes(kSecRandomDefault, length, &bytes)
+
+  guard status == errSecSuccess else {
+    throw FailedGeneratingRandomBytesException(status)
+  }
+  return Data(bytes).base64EncodedString()
+}
+
 private func digestString(algorithm: DigestAlgorithm, str: String, options: DigestOptions) throws -> String {
   guard let data = str.data(using: .utf8) else {
     throw LossyConversionException()
@@ -33,8 +55,33 @@ private func digestString(algorithm: DigestAlgorithm, str: String, options: Dige
   }
 }
 
+private func getRandomValues(array: TypedArray) throws -> TypedArray {
+  let status = SecRandomCopyBytes(
+    kSecRandomDefault,
+    array.byteLength,
+    array.rawPointer
+  )
+
+  guard status == errSecSuccess else {
+    throw FailedGeneratingRandomBytesException(status)
+  }
+  return array
+}
+
+private func digest(algorithm: DigestAlgorithm, output: TypedArray, data: TypedArray) {
+  let length = Int(algorithm.digestLength)
+  let outputPtr = output.rawPointer.assumingMemoryBound(to: UInt8.self)
+  algorithm.digest(data.rawPointer, UInt32(data.byteLength), outputPtr)
+}
+
 private class LossyConversionException: Exception {
   override var reason: String {
     "Unable to convert given string without losing some information"
   }
 }
+
+private class FailedGeneratingRandomBytesException: GenericException<OSStatus> {
+  override var reason: String {
+    "Generating random bytes has failed with OSStatus code: \(param)"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-crypto",
-  "version": "12.0.0",
+  "version": "12.2.0",
   "description": "Expo universal module for crypto",
   "main": "build/Crypto.js",
   "types": "build/Crypto.d.ts",
@@ -38,12 +38,14 @@
   "jest": {
     "preset": "expo-module-scripts"
   },
-  "dependencies": {},
+  "dependencies": {
+    "base64-js": "^1.3.0"
+  },
   "devDependencies": {
     "expo-module-scripts": "^3.0.0"
   },
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "eab2b09c735fb0fc2bf734a3f29a6593adba3838"
+  "gitHead": "1815e2eaad8c753588c7b1eb74420174a28e01f4"
 }

package/src/Crypto.ts

@@ -1,8 +1,11 @@
-import { UnavailabilityError } from 'expo-modules-core';
+import { toByteArray } from 'base64-js';
+import { UnavailabilityError, UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';
 
 import { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions, Digest } from './Crypto.types';
 import ExpoCrypto from './ExpoCrypto';
 
+declare const global: any;
+
 export * from './Crypto.types';
 
 class CryptoError extends TypeError {
@@ -13,6 +16,70 @@ class CryptoError extends TypeError {
   }
 }
 
+// @needsAudit
+/**
+ * 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`.
+ * Falls back to `Math.random` during development to prevent issues with React Native Debugger.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return An array of random bytes with the same length as the `byteCount`.
+ */
+export function getRandomBytes(byteCount: number): Uint8Array {
+  assertByteCount(byteCount, 'getRandomBytes');
+  const validByteCount = Math.floor(byteCount);
+  if (__DEV__) {
+    if (!global.nativeCallSyncHook || global.__REMOTEDEV__) {
+      // remote javascript debugging is enabled
+      const array = new Uint8Array(validByteCount);
+      for (let i = 0; i < validByteCount; i++) {
+        array[i] = Math.floor(Math.random() * 256);
+      }
+      return array;
+    }
+  }
+  if (ExpoCrypto.getRandomBytes) {
+    return ExpoCrypto.getRandomBytes(validByteCount);
+  } else if (ExpoCrypto.getRandomBase64String) {
+    const base64 = ExpoCrypto.getRandomBase64String(validByteCount);
+    return toByteArray(base64);
+  } else {
+    throw new UnavailabilityError('expo-crypto', 'getRandomBytes');
+  }
+}
+
+// @needsAudit
+/**
+ * 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`.
+ * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.
+ * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.
+ */
+export async function getRandomBytesAsync(byteCount: number): Promise<Uint8Array> {
+  assertByteCount(byteCount, 'getRandomBytesAsync');
+  const validByteCount = Math.floor(byteCount);
+  if (ExpoCrypto.getRandomBytesAsync) {
+    return await ExpoCrypto.getRandomBytesAsync(validByteCount);
+  } else if (ExpoCrypto.getRandomBase64StringAsync) {
+    const base64 = await ExpoCrypto.getRandomBase64StringAsync(validByteCount);
+    return toByteArray(base64);
+  } else {
+    throw new UnavailabilityError('expo-crypto', 'getRandomBytesAsync');
+  }
+}
+
+function assertByteCount(value: any, methodName: string): void {
+  if (
+    typeof value !== 'number' ||
+    isNaN(value) ||
+    Math.floor(value) < 0 ||
+    Math.floor(value) > 1024
+  ) {
+    throw new TypeError(
+      `expo-crypto: ${methodName}(${value}) expected a valid number from range 0...1024`
+    );
+  }
+}
+
 function assertAlgorithm(algorithm: CryptoDigestAlgorithm): void {
   if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {
     throw new CryptoError(
@@ -45,7 +112,7 @@ function assertEncoding(encoding: CryptoEncoding): void {
  * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
  * meaning that it's very difficult to generate multiple inputs that have equal digest values.
  * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.
- * On web, this method can only be called from a secure origin (https) otherwise an error will be thrown.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
  *
  * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
  * @param data The value that will be used to generate a digest.
@@ -75,3 +142,80 @@ export async function digestStringAsync(
 
   return await ExpoCrypto.digestStringAsync(algorithm, data, options);
 }
+
+/**
+ * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.
+ *
+ * @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.
+ * @return The input array filled with cryptographically secure random values.
+ *
+ * @example
+ * ```ts
+ * const byteArray = new Uint8Array(16);
+ * Crypto.getRandomValues(byteArray);
+ * console.log('Your lucky bytes: ' + byteArray);
+ * ```
+ */
+export function getRandomValues<T extends IntBasedTypedArray | UintBasedTypedArray>(
+  typedArray: T
+): T {
+  ExpoCrypto.getRandomValues(typedArray);
+  return typedArray;
+}
+
+/**
+ * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).
+ * It uses cryptographically secure random values to generate the UUID.
+ *
+ * @return A string containing a newly generated UUIDv4 identifier
+ * @example
+ * ```ts
+ * const UUID = Crypto.randomUUID();
+ * console.log('Your UUID: ' + UUID);
+ * ```
+ */
+export function randomUUID() {
+  return ExpoCrypto.randomUUID();
+}
+
+const digestLengths = {
+  [CryptoDigestAlgorithm.SHA1]: 20,
+  [CryptoDigestAlgorithm.SHA256]: 32,
+  [CryptoDigestAlgorithm.SHA384]: 48,
+  [CryptoDigestAlgorithm.SHA512]: 64,
+  [CryptoDigestAlgorithm.MD2]: 16,
+  [CryptoDigestAlgorithm.MD4]: 16,
+  [CryptoDigestAlgorithm.MD5]: 16,
+};
+
+/**
+ * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.
+ * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,
+ * meaning that it's very difficult to generate multiple inputs that have equal digest values.
+ * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.
+ *
+ * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.
+ * @param data The value that will be used to generate a digest.
+ * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.
+ * @example
+ * ```ts
+ * const array = new Uint8Array([1, 2, 3, 4, 5]);
+ * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);
+ * console.log('Your digest: ' + digest);
+ * ```
+ */
+export function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (typeof ExpoCrypto.digestAsync === 'function') {
+        resolve(ExpoCrypto.digestAsync(algorithm, data));
+      } else {
+        const output = new Uint8Array(digestLengths[algorithm]);
+        ExpoCrypto.digest(algorithm, output, data);
+        resolve(output.buffer);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}

package/src/ExpoCrypto.web.ts

@@ -1,7 +1,9 @@
-import { CodedError } from 'expo-modules-core';
+import { CodedError, TypedArray } from 'expo-modules-core';
 
 import { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions } from './Crypto.types';
 
+const getCrypto = (): Crypto => window.crypto ?? (window as any).msCrypto;
+
 export default {
   get name(): string {
     return 'ExpoCrypto';
@@ -27,6 +29,23 @@ export default {
     }
     throw new CodedError('ERR_CRYPTO_DIGEST', 'Invalid encoding type provided.');
   },
+  getRandomBytes(length: number): Uint8Array {
+    const array = new Uint8Array(length);
+    return getCrypto().getRandomValues(array);
+  },
+  async getRandomBytesAsync(length: number): Promise<Uint8Array> {
+    const array = new Uint8Array(length);
+    return getCrypto().getRandomValues(array);
+  },
+  getRandomValues(typedArray: TypedArray) {
+    return getCrypto().getRandomValues(typedArray);
+  },
+  randomUUID() {
+    return getCrypto().randomUUID();
+  },
+  digestAsync(algorithm: AlgorithmIdentifier, data: ArrayBuffer): Promise<ArrayBuffer> {
+    return getCrypto().subtle.digest(algorithm, data);
+  },
 };
 
 function hexString(buffer: ArrayBuffer): string {