@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/src/blake3.ts

@@ -0,0 +1,124 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Blake3 as NativeBlake3 } from './specs/v1/blake3.nitro';
+import type { BinaryLike, Encoding } from './utils';
+import { binaryLikeToArrayBuffer, ab2str } from './utils';
+import { toArrayBuffer } from './utils/conversion';
+
+const BLAKE3_KEY_LEN = 32;
+const BLAKE3_OUT_LEN = 32;
+
+export interface Blake3Options {
+  dkLen?: number;
+  key?: Uint8Array;
+  context?: string;
+}
+
+export class Blake3 {
+  private native: NativeBlake3;
+  private mode: 'hash' | 'keyed' | 'deriveKey';
+  private keyData?: Uint8Array;
+  private contextData?: string;
+
+  constructor(opts?: Blake3Options) {
+    this.native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+
+    if (opts?.key && opts?.context) {
+      throw new Error(
+        'BLAKE3: cannot use both key and context options together',
+      );
+    }
+
+    if (opts?.key) {
+      if (opts.key.length !== BLAKE3_KEY_LEN) {
+        throw new Error(`BLAKE3: key must be exactly ${BLAKE3_KEY_LEN} bytes`);
+      }
+      this.mode = 'keyed';
+      this.keyData = opts.key;
+      this.native.initKeyed(toArrayBuffer(opts.key));
+    } else if (opts?.context !== undefined) {
+      if (typeof opts.context !== 'string' || opts.context.length === 0) {
+        throw new Error('BLAKE3: context must be a non-empty string');
+      }
+      this.mode = 'deriveKey';
+      this.contextData = opts.context;
+      this.native.initDeriveKey(opts.context);
+    } else {
+      this.mode = 'hash';
+      this.native.initHash();
+    }
+  }
+
+  update(data: BinaryLike, inputEncoding?: Encoding): this {
+    const buffer = binaryLikeToArrayBuffer(data, inputEncoding ?? 'utf8');
+    this.native.update(buffer);
+    return this;
+  }
+
+  digest(): Buffer;
+  digest(encoding: Encoding): string;
+  digest(length: number): Buffer;
+  digest(encodingOrLength?: Encoding | number): Buffer | string {
+    let length: number | undefined;
+    let encoding: Encoding | undefined;
+
+    if (typeof encodingOrLength === 'number') {
+      length = encodingOrLength;
+    } else if (encodingOrLength) {
+      encoding = encodingOrLength;
+    }
+
+    const result = this.native.digest(length);
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(result, encoding);
+    }
+
+    return Buffer.from(result);
+  }
+
+  digestLength(length: number): Buffer {
+    return Buffer.from(this.native.digest(length));
+  }
+
+  reset(): this {
+    this.native.reset();
+    return this;
+  }
+
+  copy(): Blake3 {
+    const copied = new Blake3();
+    // Replace the native with a copy
+    copied.native = this.native.copy() as NativeBlake3;
+    copied.mode = this.mode;
+    copied.keyData = this.keyData;
+    copied.contextData = this.contextData;
+    return copied;
+  }
+
+  static getVersion(): string {
+    const native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+    native.initHash();
+    return native.getVersion();
+  }
+}
+
+export function createBlake3(opts?: Blake3Options): Blake3 {
+  return new Blake3(opts);
+}
+
+export function blake3(data: BinaryLike, opts?: Blake3Options): Uint8Array {
+  const hasher = new Blake3(opts);
+  hasher.update(data);
+  const length = opts?.dkLen ?? BLAKE3_OUT_LEN;
+  const result = hasher.digestLength(length);
+  return new Uint8Array(result);
+}
+
+blake3.create = createBlake3;
+
+export const blake3Exports = {
+  Blake3,
+  createBlake3,
+  blake3,
+};

package/src/certificate.ts

@@ -0,0 +1,41 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Certificate as NativeCertificate } from './specs/v1/certificate.nitro';
+import type { BinaryLike } from './utils';
+import { binaryLikeToArrayBuffer } from './utils';
+
+let native: NativeCertificate;
+function getNative(): NativeCertificate {
+  if (native == null) {
+    native = NitroModules.createHybridObject<NativeCertificate>('Certificate');
+  }
+  return native;
+}
+
+function toArrayBuffer(
+  spkac: BinaryLike,
+  encoding?: BufferEncoding,
+): ArrayBuffer {
+  if (typeof spkac === 'string') {
+    return binaryLikeToArrayBuffer(spkac, encoding || 'utf8');
+  }
+  return binaryLikeToArrayBuffer(spkac);
+}
+
+export class Certificate {
+  static exportChallenge(spkac: BinaryLike, encoding?: BufferEncoding): Buffer {
+    return Buffer.from(
+      getNative().exportChallenge(toArrayBuffer(spkac, encoding)),
+    );
+  }
+
+  static exportPublicKey(spkac: BinaryLike, encoding?: BufferEncoding): Buffer {
+    return Buffer.from(
+      getNative().exportPublicKey(toArrayBuffer(spkac, encoding)),
+    );
+  }
+
+  static verifySpkac(spkac: BinaryLike, encoding?: BufferEncoding): boolean {
+    return getNative().verifySpkac(toArrayBuffer(spkac, encoding));
+  }
+}

package/src/cipher.ts

@@ -0,0 +1,373 @@
+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/v1/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);
+}
+
+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
+
+    const authTagLen: number =
+      getUIntOption(options ?? {}, 'authTagLength') !== -1
+        ? getUIntOption(options ?? {}, 'authTagLength')
+        : 16; // defaults to 16 bytes
+
+    const factory =
+      NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+    this.native = factory.createCipher({
+      isCipher,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      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);
+  }
+
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.push(this.update(chunk, normalizeEncoding(encoding)));
+    callback();
+  }
+
+  _flush(callback: () => void) {
+    this.push(this.final());
+    callback();
+  }
+
+  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.');
+    }
+    const res = this.native.setAAD(buffer.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-ignore haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  output?: Uint8Array | undefined,
+  // @ts-ignore haven't implemented this part of @noble/ciphers API
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  counter?: number,
+): Uint8Array {
+  const factory =
+    NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+  const native = factory.createCipher({
+    isCipher: true,
+    cipherType: 'xsalsa20',
+    cipherKey: binaryLikeToArrayBuffer(key),
+    iv: binaryLikeToArrayBuffer(nonce),
+  });
+  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',
+  },
+};