@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/src/cipher.ts

@@ -0,0 +1,497 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import Stream, { type TransformOptions } from 'readable-stream';
+import { StringDecoder } from 'string_decoder';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, BinaryLikeNode, Encoding } from './utils';
+import type {
+  CipherCCMOptions,
+  CipherCCMTypes,
+  CipherGCMTypes,
+  CipherGCMOptions,
+  CipherOCBOptions,
+  CipherOCBTypes,
+} from 'crypto'; // @types/node
+import type {
+  Cipher as NativeCipher,
+  CipherFactory,
+} from './specs/cipher.nitro';
+import { binaryLikeToArrayBuffer } from './utils';
+import {
+  getDefaultEncoding,
+  getUIntOption,
+  normalizeEncoding,
+  validateEncoding,
+} from './utils/cipher';
+
+export type CipherOptions =
+  | CipherCCMOptions
+  | CipherOCBOptions
+  | CipherGCMOptions
+  | TransformOptions;
+
+export interface CipherInfoResult {
+  name: string;
+  nid: number;
+  mode: string;
+  keyLength: number;
+  blockSize?: number;
+  ivLength?: number;
+}
+
+class CipherUtils {
+  private static native =
+    NitroModules.createHybridObject<NativeCipher>('Cipher');
+  public static getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+  public static getCipherInfo(
+    name: string,
+    keyLength?: number,
+    ivLength?: number,
+  ): CipherInfoResult | undefined {
+    return this.native.getCipherInfo(name, keyLength, ivLength);
+  }
+}
+
+export function getCiphers(): string[] {
+  return CipherUtils.getSupportedCiphers();
+}
+
+export function getCipherInfo(
+  name: string,
+  options?: { keyLength?: number; ivLength?: number },
+): CipherInfoResult | undefined {
+  if (typeof name !== 'string' || name.length === 0) return undefined;
+  return CipherUtils.getCipherInfo(name, options?.keyLength, options?.ivLength);
+}
+
+// libsodium ciphers aren't visible to OpenSSL's EVP_CIPHER_fetch, so
+// getCipherInfo() returns undefined for them. Hard-code the (key, iv)
+// byte-lengths the C++ factory will accept.
+const LIBSODIUM_CIPHER_PARAMS: Readonly<
+  Record<string, { keyLength: number; ivLength: number }>
+> = {
+  xsalsa20: { keyLength: 32, ivLength: 24 },
+  'xsalsa20-poly1305': { keyLength: 32, ivLength: 24 },
+  'xchacha20-poly1305': { keyLength: 32, ivLength: 24 },
+};
+
+function validateCipherParams(
+  cipherType: string,
+  keyByteLength: number,
+  ivByteLength: number,
+): void {
+  if (typeof cipherType !== 'string' || cipherType.length === 0) {
+    throw new TypeError('cipher algorithm must be a non-empty string');
+  }
+  // ArrayBuffer.byteLength is always a non-negative integer, so the only
+  // out-of-range value we need to guard is 0 — empty key buffers must not
+  // reach OpenSSL's EVP_CipherInit_ex.
+  if (keyByteLength === 0) {
+    throw new RangeError(`Invalid key length 0 for cipher ${cipherType}`);
+  }
+
+  const lower = cipherType.toLowerCase();
+  const sodium = LIBSODIUM_CIPHER_PARAMS[lower];
+  if (sodium) {
+    // libsodium parlance: "nonce" rather than "iv". Phrase the expected
+    // size as a natural-language clause so callers asserting on either
+    // `key must be N bytes` or `Invalid key length N` both match.
+    if (keyByteLength !== sodium.keyLength) {
+      throw new RangeError(
+        `Invalid key length ${keyByteLength} for cipher ${cipherType} ` +
+          `(key must be ${sodium.keyLength} bytes)`,
+      );
+    }
+    if (ivByteLength !== sodium.ivLength) {
+      throw new RangeError(
+        `Invalid nonce length ${ivByteLength} for cipher ${cipherType} ` +
+          `(nonce must be ${sodium.ivLength} bytes)`,
+      );
+    }
+    return;
+  }
+
+  // OpenSSL path. Look up the cipher's defaults once. Most callers pass
+  // exactly the cipher's default key/iv lengths (e.g. AES-128-CBC always
+  // wants 16/16) — short-circuit those to a single native round-trip.
+  // Variable-length ciphers (GCM, CCM, OCB, ChaCha20-Poly1305) fall through
+  // to per-parameter validation calls so the error message can name which
+  // of {key, iv} is wrong.
+  const info = CipherUtils.getCipherInfo(cipherType);
+  if (info === undefined) {
+    throw new TypeError(`Unsupported or unknown cipher type: ${cipherType}`);
+  }
+
+  const expectedIv = info.ivLength ?? 0;
+  if (expectedIv === 0 && ivByteLength > 0) {
+    throw new RangeError(
+      `Cipher ${cipherType} does not use an iv (got ${ivByteLength} bytes)`,
+    );
+  }
+  if (expectedIv > 0 && ivByteLength === 0) {
+    throw new RangeError(
+      `Cipher ${cipherType} requires an iv but none was provided`,
+    );
+  }
+
+  // Fast path: lengths match the cipher's defaults exactly.
+  if (info.keyLength === keyByteLength && expectedIv === ivByteLength) {
+    return;
+  }
+
+  // Variable-length: verify against native one parameter at a time.
+  if (
+    CipherUtils.getCipherInfo(cipherType, keyByteLength, undefined) ===
+    undefined
+  ) {
+    throw new RangeError(
+      `Invalid key length ${keyByteLength} for cipher ${cipherType}`,
+    );
+  }
+  if (
+    expectedIv > 0 &&
+    CipherUtils.getCipherInfo(cipherType, undefined, ivByteLength) === undefined
+  ) {
+    throw new RangeError(
+      `Invalid iv length ${ivByteLength} for cipher ${cipherType}`,
+    );
+  }
+}
+
+interface CipherArgs {
+  isCipher: boolean;
+  cipherType: string;
+  cipherKey: BinaryLikeNode;
+  iv: BinaryLike;
+  options?: CipherOptions;
+}
+
+class CipherCommon extends Stream.Transform {
+  private native: NativeCipher;
+  private _decoder: StringDecoder | null = null;
+  private _decoderEncoding: string | undefined = undefined;
+
+  constructor({ isCipher, cipherType, cipherKey, iv, options }: CipherArgs) {
+    // Explicitly create TransformOptions for super()
+    const streamOptions: TransformOptions = {};
+    if (options) {
+      // List known TransformOptions keys (adjust if needed)
+      const transformKeys: Array<keyof TransformOptions> = [
+        'readableHighWaterMark',
+        'writableHighWaterMark',
+        'decodeStrings',
+        'defaultEncoding',
+        'objectMode',
+        'destroy',
+        'read',
+        'write',
+        'writev',
+        'final',
+        'transform',
+        'flush',
+        // Add any other relevant keys from readable-stream's TransformOptions
+      ];
+      for (const key of transformKeys) {
+        if (key in options) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (streamOptions as any)[key] = (options as any)[key];
+        }
+      }
+    }
+    super(streamOptions); // Pass filtered options
+
+    // defaults to 16 bytes for AEAD modes; non-AEAD callers ignore it.
+    const authTagLen =
+      getUIntOption(
+        options as Readonly<Record<string, unknown>> | undefined,
+        'authTagLength',
+      ) ?? 16;
+
+    const cipherKeyAB = binaryLikeToArrayBuffer(cipherKey);
+    const ivAB = binaryLikeToArrayBuffer(iv);
+    validateCipherParams(cipherType, cipherKeyAB.byteLength, ivAB.byteLength);
+
+    const factory =
+      NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+    this.native = factory.createCipher({
+      isCipher,
+      cipherType,
+      cipherKey: cipherKeyAB,
+      iv: ivAB,
+      authTagLen,
+    });
+  }
+
+  private getDecoder(encoding: string): StringDecoder {
+    const normalized = normalizeEncoding(encoding);
+    if (!this._decoder) {
+      this._decoder = new StringDecoder(encoding as BufferEncoding);
+      this._decoderEncoding = normalized;
+    } else if (this._decoderEncoding !== normalized) {
+      throw new Error('Cannot change encoding');
+    }
+    return this._decoder;
+  }
+
+  update(data: Buffer): Buffer;
+  update(data: BinaryLike, inputEncoding?: Encoding): Buffer;
+  update(
+    data: BinaryLike,
+    inputEncoding: Encoding,
+    outputEncoding: Encoding,
+  ): string;
+  update(
+    data: BinaryLike,
+    inputEncoding?: Encoding,
+    outputEncoding?: Encoding,
+  ): Buffer | string {
+    const defaultEncoding = getDefaultEncoding();
+    inputEncoding = inputEncoding ?? defaultEncoding;
+    outputEncoding = outputEncoding ?? defaultEncoding;
+
+    if (typeof data === 'string') {
+      validateEncoding(data, inputEncoding);
+    } else if (!ArrayBuffer.isView(data)) {
+      throw new Error('Invalid data argument');
+    }
+
+    const ret = this.native.update(
+      binaryLikeToArrayBuffer(data, inputEncoding),
+    );
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return this.getDecoder(outputEncoding).write(Buffer.from(ret));
+    }
+
+    return Buffer.from(ret);
+  }
+
+  final(): Buffer;
+  final(outputEncoding: BufferEncoding | 'buffer'): string;
+  final(outputEncoding?: BufferEncoding | 'buffer'): Buffer | string {
+    const ret = this.native.final();
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return this.getDecoder(outputEncoding).end(Buffer.from(ret));
+    }
+
+    return Buffer.from(ret);
+  }
+
+  // Stream interface — surface synchronous errors (bad encoding,
+  // OpenSSL EVP failures, AEAD tag mismatch in `final()`, etc.) via
+  // the callback so they emit as stream 'error' events instead of
+  // throwing out of the Transform plumbing and crashing the host
+  // pipeline.
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: (err?: Error | null) => void,
+  ) {
+    try {
+      this.push(this.update(chunk, normalizeEncoding(encoding)));
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  _flush(callback: (err?: Error | null) => void) {
+    try {
+      this.push(this.final());
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  public setAutoPadding(autoPadding?: boolean): this {
+    const res = this.native.setAutoPadding(!!autoPadding);
+    if (!res) {
+      throw new Error('setAutoPadding failed');
+    }
+    return this;
+  }
+
+  public setAAD(
+    buffer: Buffer,
+    options?: {
+      plaintextLength: number;
+    },
+  ): this {
+    // Check if native parts are initialized
+    if (!this.native || typeof this.native.setAAD !== 'function') {
+      throw new Error('Cipher native object or setAAD method not initialized.');
+    }
+    // Use binaryLikeToArrayBuffer (not `buffer.buffer`) so that sliced /
+    // offset views send only the AAD bytes the caller intended. Passing the
+    // raw backing ArrayBuffer authenticates the wrong data and silently
+    // breaks the AEAD integrity guarantee.
+    const res = this.native.setAAD(
+      binaryLikeToArrayBuffer(buffer),
+      options?.plaintextLength,
+    );
+    if (!res) {
+      throw new Error('setAAD failed (native call returned false)');
+    }
+    return this;
+  }
+
+  public getAuthTag(): Buffer {
+    return Buffer.from(this.native.getAuthTag());
+  }
+
+  public setAuthTag(tag: Buffer): this {
+    const res = this.native.setAuthTag(binaryLikeToArrayBuffer(tag));
+    if (!res) {
+      throw new Error('setAuthTag failed');
+    }
+    return this;
+  }
+
+  public getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+}
+
+class Cipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: true,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+export type Cipher = Cipheriv;
+
+class Decipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: false,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+export type Decipher = Decipheriv;
+
+export function createDecipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Decipher {
+  return new Decipheriv(algorithm, key, iv, options);
+}
+
+export function createCipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Cipher {
+  return new Cipheriv(algorithm, key, iv, options);
+}
+
+/**
+ * xsalsa20 stream encryption with @noble/ciphers compatible API
+ *
+ * @param key - 32 bytes
+ * @param nonce - 24 bytes
+ * @param data - data to encrypt
+ * @param output - unused
+ * @param counter - unused
+ * @returns encrypted data
+ */
+export function xsalsa20(
+  key: Uint8Array,
+  nonce: Uint8Array,
+  data: Uint8Array,
+  // @ts-expect-error haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  output?: Uint8Array | undefined,
+  // @ts-expect-error haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  counter?: number,
+): Uint8Array {
+  const cipherKeyAB = binaryLikeToArrayBuffer(key);
+  const ivAB = binaryLikeToArrayBuffer(nonce);
+  validateCipherParams('xsalsa20', cipherKeyAB.byteLength, ivAB.byteLength);
+
+  const factory =
+    NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+  const native = factory.createCipher({
+    isCipher: true,
+    cipherType: 'xsalsa20',
+    cipherKey: cipherKeyAB,
+    iv: ivAB,
+  });
+  const result = native.update(binaryLikeToArrayBuffer(data));
+  return new Uint8Array(result);
+}

package/src/constants.ts

@@ -0,0 +1,32 @@
+export const constants = {
+  // RSA Padding
+  RSA_PKCS1_PADDING: 1,
+  RSA_NO_PADDING: 3,
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_X931_PADDING: 5,
+  RSA_PKCS1_PSS_PADDING: 6,
+
+  // RSA PSS Salt Length
+  RSA_PSS_SALTLEN_DIGEST: -1,
+  RSA_PSS_SALTLEN_MAX_SIGN: -2,
+  RSA_PSS_SALTLEN_AUTO: -2,
+
+  // Point Conversion
+  POINT_CONVERSION_COMPRESSED: 2,
+  POINT_CONVERSION_UNCOMPRESSED: 4,
+  POINT_CONVERSION_HYBRID: 6,
+
+  // DH Check
+  DH_CHECK_P_NOT_PRIME: 1,
+  DH_CHECK_P_NOT_SAFE_PRIME: 2,
+  DH_UNABLE_TO_CHECK_GENERATOR: 4,
+  DH_NOT_SUITABLE_GENERATOR: 8,
+
+  // OpenSSL Version (3.0.0 = 0x30000000)
+  OPENSSL_VERSION_NUMBER: 0x30000000,
+} as const;
+
+export const defaultCoreCipherList =
+  'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256';
+export const defaultCipherList =
+  'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256';

package/src/dh-groups.ts

@@ -0,0 +1,27 @@
+export const DH_GROUPS: Record<string, { prime: string; generator: string }> = {
+  modp14: {
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff',
+    generator: '02',
+  },
+  modp15: {
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff',
+    generator: '02',
+  },
+  modp16: {
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff',
+    generator: '02',
+  },
+  modp17: {
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff',
+    generator: '02',
+  },
+  modp18: {
+    prime:
+      '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',
+    generator: '02',
+  },
+};