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

package/lib/commonjs/mlkem.js

@@ -0,0 +1,219 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MlKem = void 0;
+exports.decapsulate = decapsulate;
+exports.encapsulate = encapsulate;
+exports.mlkem_generateKeyPairWebCrypto = mlkem_generateKeyPairWebCrypto;
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _keys = require("./keys");
+var _utils = require("./utils");
+const ML_KEM_VARIANTS = {
+  'ml-kem-512': 'ML-KEM-512',
+  'ml-kem-768': 'ML-KEM-768',
+  'ml-kem-1024': 'ML-KEM-1024'
+};
+function isMlKemKeyType(type) {
+  return type in ML_KEM_VARIANTS;
+}
+function unpackEncapsulateResult(packed) {
+  const view = new DataView(packed);
+  const ciphertextLen = view.getUint32(0, true);
+  const sharedKeyLen = view.getUint32(4, true);
+  const headerSize = 8;
+  const ciphertext = packed.slice(headerSize, headerSize + ciphertextLen);
+  const sharedKey = packed.slice(headerSize + ciphertextLen, headerSize + ciphertextLen + sharedKeyLen);
+  return {
+    ciphertext,
+    sharedKey
+  };
+}
+class MlKem {
+  constructor(variant) {
+    this.variant = variant;
+    this.native = _reactNativeNitroModules.NitroModules.createHybridObject('MlKemKeyPair');
+    this.native.setVariant(variant);
+  }
+  async generateKeyPair() {
+    await this.native.generateKeyPair(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  }
+  getPublicKey() {
+    return this.native.getPublicKey();
+  }
+  getPrivateKey() {
+    return this.native.getPrivateKey();
+  }
+  setPublicKey(keyData, format, type) {
+    this.native.setPublicKey(keyData, format, type);
+  }
+  setPrivateKey(keyData, format, type) {
+    this.native.setPrivateKey(keyData, format, type);
+  }
+  async encapsulate() {
+    const packed = await this.native.encapsulate();
+    return unpackEncapsulateResult(packed);
+  }
+  encapsulateSync() {
+    const packed = this.native.encapsulateSync();
+    return unpackEncapsulateResult(packed);
+  }
+  async decapsulate(ciphertext) {
+    return this.native.decapsulate(ciphertext);
+  }
+  decapsulateSync(ciphertext) {
+    return this.native.decapsulateSync(ciphertext);
+  }
+}
+exports.MlKem = MlKem;
+function prepareKey(key, isPublic) {
+  if (key instanceof _keys.KeyObject) {
+    if (isPublic) {
+      if (key.type === 'secret') {
+        throw new Error('Cannot use secret key for encapsulation');
+      }
+    } else {
+      if (key.type !== 'private') {
+        throw new Error('Key must be a private key for decapsulation');
+      }
+    }
+    return {
+      keyObject: key
+    };
+  }
+  if ((0, _keys.isCryptoKey)(key)) {
+    const cryptoKey = key;
+    return prepareKey(cryptoKey.keyObject, isPublic);
+  }
+  if ((0, _utils.isStringOrBuffer)(key)) {
+    const isPem = typeof key === 'string' && key.includes('-----BEGIN');
+    const format = isPem ? _utils.KFormatType.PEM : undefined;
+    const keyType = isPublic ? 'public' : 'private';
+    const keyData = (0, _utils.binaryLikeToArrayBuffer)(key);
+    const keyObject = _keys.KeyObject.createKeyObject(keyType, keyData, format);
+    return {
+      keyObject
+    };
+  }
+  if (typeof key === 'object' && 'key' in key) {
+    const keyObj = key;
+    const {
+      key: data,
+      format,
+      type
+    } = keyObj;
+    if (data instanceof _keys.KeyObject) {
+      return {
+        keyObject: data
+      };
+    }
+    if ((0, _keys.isCryptoKey)(data)) {
+      return {
+        keyObject: data.keyObject
+      };
+    }
+    if (!(0, _utils.isStringOrBuffer)(data)) {
+      throw new Error('Invalid key data type');
+    }
+    const isPem = format === 'pem' || typeof data === 'string' && data.includes('-----BEGIN');
+    const kFormat = isPem ? _utils.KFormatType.PEM : format === 'der' ? _utils.KFormatType.DER : undefined;
+    let kType;
+    if (type === 'pkcs8') kType = _utils.KeyEncoding.PKCS8;else if (type === 'pkcs1') kType = _utils.KeyEncoding.PKCS1;else if (type === 'sec1') kType = _utils.KeyEncoding.SEC1;else if (type === 'spki') kType = _utils.KeyEncoding.SPKI;
+    const keyType = isPublic ? 'public' : 'private';
+    const keyData = (0, _utils.binaryLikeToArrayBuffer)(data);
+    const keyObject = _keys.KeyObject.createKeyObject(keyType, keyData, kFormat, kType);
+    return {
+      keyObject
+    };
+  }
+  throw new Error('Invalid key input');
+}
+function getVariantFromKey(keyObject) {
+  const keyType = keyObject.handle.getAsymmetricKeyType();
+  if (!isMlKemKeyType(keyType)) {
+    throw new Error(`Key is not an ML-KEM key. Got asymmetricKeyType: ${keyType}`);
+  }
+  return ML_KEM_VARIANTS[keyType];
+}
+function encapsulate(key, callback) {
+  const doEncapsulate = () => {
+    if (key === null || key === undefined) {
+      throw new Error('Public key is required for encapsulation');
+    }
+    const {
+      keyObject
+    } = prepareKey(key, true);
+    const variant = getVariantFromKey(keyObject);
+    const mlkem = new MlKem(variant);
+    const keyData = keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+    mlkem.setPublicKey(keyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+    return mlkem.encapsulateSync();
+  };
+  if (callback) {
+    try {
+      const result = doEncapsulate();
+      process.nextTick(callback, null, result);
+    } catch (err) {
+      process.nextTick(callback, err);
+    }
+    return;
+  }
+  return doEncapsulate();
+}
+function decapsulate(key, ciphertext, callback) {
+  const doDecapsulate = () => {
+    if (key === null || key === undefined) {
+      throw new Error('Private key is required for decapsulation');
+    }
+    const {
+      keyObject
+    } = prepareKey(key, false);
+    const variant = getVariantFromKey(keyObject);
+    const mlkem = new MlKem(variant);
+    const keyData = keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+    mlkem.setPrivateKey(keyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+    const ciphertextBuffer = (0, _utils.binaryLikeToArrayBuffer)(ciphertext);
+    return mlkem.decapsulateSync(ciphertextBuffer);
+  };
+  if (callback) {
+    try {
+      const result = doDecapsulate();
+      process.nextTick(callback, null, result);
+    } catch (err) {
+      process.nextTick(callback, err);
+    }
+    return;
+  }
+  return doDecapsulate();
+}
+async function mlkem_generateKeyPairWebCrypto(variant, extractable, keyUsages) {
+  if ((0, _utils.hasAnyNotIn)(keyUsages, ['encapsulateBits', 'encapsulateKey', 'decapsulateBits', 'decapsulateKey'])) {
+    throw (0, _utils.lazyDOMException)(`Unsupported key usage for ${variant}`, 'SyntaxError');
+  }
+  const publicUsages = (0, _utils.getUsagesUnion)(keyUsages, 'encapsulateBits', 'encapsulateKey');
+  const privateUsages = (0, _utils.getUsagesUnion)(keyUsages, 'decapsulateBits', 'decapsulateKey');
+  if (privateUsages.length === 0) {
+    throw (0, _utils.lazyDOMException)('Usages cannot be empty', 'SyntaxError');
+  }
+  const mlkem = new MlKem(variant);
+  await mlkem.generateKeyPair();
+  const publicKeyData = mlkem.getPublicKey();
+  const privateKeyData = mlkem.getPrivateKey();
+  const pub = _keys.KeyObject.createKeyObject('public', publicKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  const publicKey = new _keys.CryptoKey(pub, {
+    name: variant
+  }, publicUsages, true);
+  const priv = _keys.KeyObject.createKeyObject('private', privateKeyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  const privateKey = new _keys.CryptoKey(priv, {
+    name: variant
+  }, privateUsages, extractable);
+  return {
+    publicKey,
+    privateKey
+  };
+}
+//# sourceMappingURL=mlkem.js.map

package/lib/commonjs/mlkem.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_keys","_utils","ML_KEM_VARIANTS","isMlKemKeyType","type","unpackEncapsulateResult","packed","view","DataView","ciphertextLen","getUint32","sharedKeyLen","headerSize","ciphertext","slice","sharedKey","MlKem","constructor","variant","native","NitroModules","createHybridObject","setVariant","generateKeyPair","KFormatType","DER","KeyEncoding","SPKI","PKCS8","generateKeyPairSync","getPublicKey","getPrivateKey","setPublicKey","keyData","format","setPrivateKey","encapsulate","encapsulateSync","decapsulate","decapsulateSync","exports","prepareKey","key","isPublic","KeyObject","Error","keyObject","isCryptoKey","cryptoKey","isStringOrBuffer","isPem","includes","PEM","undefined","keyType","toAB","createKeyObject","keyObj","data","kFormat","kType","PKCS1","SEC1","getVariantFromKey","handle","getAsymmetricKeyType","callback","doEncapsulate","mlkem","exportKey","result","process","nextTick","err","doDecapsulate","ciphertextBuffer","mlkem_generateKeyPairWebCrypto","extractable","keyUsages","hasAnyNotIn","lazyDOMException","publicUsages","getUsagesUnion","privateUsages","length","publicKeyData","privateKeyData","pub","publicKey","CryptoKey","name","priv","privateKey"],"sourceRoot":"../../src","sources":["mlkem.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/native-nitro-bridge.js

@@ -0,0 +1,344 @@
+"use strict";
+
+/**
+ * native-nitro-bridge.js — Node.js N-API bridge for react-native-quick-crypto
+ * on HarmonyOS.
+ *
+ * The upstream crypto core is implemented as C++20 Nitro HybridObjects which
+ * require the react-native-nitro-modules JSI host inside a React Native app.
+ * On standalone HarmonyOS Node.js that host is unavailable, so the migrate
+ * phase compiled an equivalent standalone N-API addon
+ * (ohos/quick_crypto_napi.cpp -> ohos/build/Release/quick_crypto.node) that
+ * performs the SAME OpenSSL / blake3 operations.
+ *
+ * This bridge adapts the flat N-API export surface of that addon back to the
+ * `NitroModules.createHybridObject(name)` shape used by lib/commonjs, so the
+ * real native crypto implementation is reachable from the existing JS layer.
+ * There are no stubs here: every supported method calls the compiled native
+ * addon (OpenSSL 3 / blake3). Hybrid object types that the addon does not
+ * cover (key management, signatures, X.509, TurboShake/KMAC, ...) throw a
+ * clear "not supported" error on first use instead of silently faking results.
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+function loadNativeAddon() {
+  // lib/commonjs -> package root is two levels up.
+  const addon = path.resolve(__dirname, "..", "..", "ohos", "build", "Release", "quick_crypto.node");
+  if (!fs.existsSync(addon)) {
+    throw new Error(
+      "react-native-quick-crypto: native addon not found at " +
+        addon +
+        " — build it with `node-gyp rebuild` inside the package's ohos/ directory"
+    );
+  }
+  return require(addon);
+}
+
+const native = loadNativeAddon();
+
+function makeUnsupportedHybrid(name) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        throw new Error(
+          "react-native-quick-crypto: HybridObject '" +
+            String(name) +
+            "' is not covered by the Node.js N-API bridge (quick_crypto.node); property '" +
+            String(prop) +
+            "' is unavailable. Build the corresponding Nitro HybridObject inside a React Native app instead."
+        );
+      },
+    }
+  );
+}
+
+function toArrayBufferOf(u8) {
+  const ab = new ArrayBuffer(u8.length);
+  new Uint8Array(ab).set(u8);
+  return ab;
+}
+
+// --- Utils (HybridUtils: binary conversion helpers + timingSafeEqual) -------
+const STRING_TO_BUFFER_ENCODINGS = ["hex", "base64", "base64url", "utf8", "utf-8", "latin1", "binary", "ascii"];
+function makeUtilsHybrid() {
+  return {
+    timingSafeEqual(a, b) {
+      return native.timingSafeEqual(a, b);
+    },
+    // Real string<->bytes conversion for the encodings the native Utils
+    // HybridObject accepts. Implemented with the runtime's own typed binary
+    // decoder (Node Buffer), which is the same OpenSSL-agnostic byte mapping.
+    stringToBuffer(input, encoding) {
+      const enc = STRING_TO_BUFFER_ENCODINGS.indexOf(encoding) >= 0 ? encoding : undefined;
+      if (enc === undefined) {
+        throw new TypeError("Utils.stringToBuffer: unsupported encoding '" + String(encoding) + "'");
+      }
+      return toArrayBufferOf(Buffer.from(String(input), enc));
+    },
+    bufferToString(buf, encoding, start, end) {
+      const enc = STRING_TO_BUFFER_ENCODINGS.indexOf(encoding) >= 0 ? encoding : "utf8";
+      const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+      if (start !== undefined || end !== undefined) {
+        const s = start ?? 0;
+        const e = end ?? b.length;
+        return b.toString(enc, s, e);
+      }
+      return b.toString(enc);
+    },
+  };
+}
+
+// --- Hash (HybridHash: EVP digests) -----------------------------------------
+function makeHashHybrid(initialState) {
+  let state = initialState ?? null;
+  return {
+    createHash(algorithm, outputLength) {
+      state = native.hashCreate(algorithm, typeof outputLength === "number" ? outputLength : undefined);
+    },
+    update(data) {
+      native.hashUpdate(state, data);
+    },
+    digest(encodingOrLength) {
+      // Native returns the raw digest bytes as ArrayBuffer; string encodings
+      // are handled by the JS layer (hash.digest()).
+      return native.hashDigest(state, typeof encodingOrLength === "number" ? encodingOrLength : undefined);
+    },
+    copy() {
+      return makeHashHybrid(native.hashCopy(state));
+    },
+    getOpenSSLVersion() {
+      // The addon statically links the same OpenSSL that ships with the
+      // user-space Node.js runtime on HarmonyOS.
+      return "OpenSSL " + process.versions.openssl;
+    },
+    getSupportedHashAlgorithms() {
+      return Array.from(native.getHashes());
+    },
+  };
+}
+
+// --- Hmac (HybridHmac: EVP HMAC) ---------------------------------------------
+function makeHmacHybrid() {
+  let state = null;
+  return {
+    createHmac(algorithm, key) {
+      state = native.hmacCreate(algorithm, key);
+    },
+    update(data) {
+      native.hmacUpdate(state, data);
+    },
+    digest() {
+      return native.hmacDigest(state);
+    },
+  };
+}
+
+// --- Random (HybridRandom: CSPRNG) -------------------------------------------
+function makeRandomHybrid() {
+  return {
+    randomBytes(size) {
+      return native.randomBytes(size);
+    },
+    randomFillSync(arrayBuffer, offset, size) {
+      const rnd = new Uint8Array(native.randomBytes(size));
+      new Uint8Array(arrayBuffer, offset, size).set(rnd);
+      return arrayBuffer;
+    },
+    randomFill(arrayBuffer, offset, size) {
+      // The Nitro HybridObject fills asynchronously on a worker thread; the
+      // N-API addon is synchronous, so the promise resolves with the SAME
+      // (now filled) ArrayBuffer — matching randomFill's copy-back contract.
+      return Promise.resolve().then(() => {
+        const rnd = new Uint8Array(native.randomBytes(size));
+        new Uint8Array(arrayBuffer, offset, size).set(rnd);
+        return arrayBuffer;
+      });
+    },
+  };
+}
+
+// --- KDFs (HybridPbkdf2 / HybridScrypt / HybridHkdf / HybridArgon2) ----------
+function makePbkdf2Hybrid() {
+  return {
+    pbkdf2Sync(password, salt, iterations, keylen, digest) {
+      return native.pbkdf2Sync(password, salt, iterations, keylen, digest);
+    },
+    pbkdf2(password, salt, iterations, keylen, digest) {
+      return Promise.resolve().then(() => native.pbkdf2Sync(password, salt, iterations, keylen, digest));
+    },
+  };
+}
+
+function makeScryptHybrid() {
+  return {
+    deriveKeySync(password, salt, N, r, p, maxmem, keylen) {
+      return native.scryptSync(password, salt, keylen, N, r, p, maxmem);
+    },
+    deriveKey(password, salt, N, r, p, maxmem, keylen) {
+      return Promise.resolve().then(() => native.scryptSync(password, salt, keylen, N, r, p, maxmem));
+    },
+  };
+}
+
+function makeHkdfHybrid() {
+  return {
+    // mode: 'full' (EXTRACT_AND_EXPAND) is provided by the native addon.
+    // 'extract'/'expand' single-phase modes are NOT covered by the addon and
+    // throw instead of silently returning a wrong derivation.
+    deriveKeySync(digest, ikm, salt, info, keylen, mode) {
+      if (mode !== undefined && mode !== "full") {
+        throw new Error("HybridHkdf: mode '" + mode + "' is not covered by the Node.js N-API bridge (only 'full')");
+      }
+      return native.hkdfSync(digest, ikm, salt, info, keylen);
+    },
+    deriveKey(digest, ikm, salt, info, keylen, mode) {
+      return Promise.resolve().then(() => {
+        if (mode !== undefined && mode !== "full") {
+          throw new Error("HybridHkdf: mode '" + mode + "' is not covered by the Node.js N-API bridge (only 'full')");
+        }
+        return native.hkdfSync(digest, ikm, salt, info, keylen);
+      });
+    },
+  };
+}
+
+function makeArgon2Hybrid() {
+  return {
+    hashSync(algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData) {
+      return native.argon2Sync(
+        algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData
+      );
+    },
+    hash(algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData) {
+      return Promise.resolve().then(() =>
+        native.argon2Sync(
+          algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData
+        )
+      );
+    },
+  };
+}
+
+// --- Cipher (HybridCipher + HybridCipherFactory) ------------------------------
+function makeCipherHybrid(opts) {
+  const state = native.cipherCreate(
+    opts.cipherType,
+    opts.cipherKey,
+    opts.iv === undefined ? null : opts.iv,
+    !!opts.isCipher
+  );
+  return {
+    update(data) {
+      return native.cipherUpdate(state, data);
+    },
+    final() {
+      return native.cipherFinal(state);
+    },
+    setAutoPadding(autoPadding) {
+      // The addon throws on failure, so reaching here means success; the JS
+      // layer (cipher.js) checks a truthy return like the Nitro HybridObject.
+      native.cipherSetAutoPadding(state, !!autoPadding);
+      return true;
+    },
+    setAAD(data) {
+      native.cipherSetAAD(state, data);
+      return true;
+    },
+    getAuthTag() {
+      return native.cipherGetAuthTag(state);
+    },
+    setAuthTag(tag) {
+      native.cipherSetAuthTag(state, tag);
+      return true;
+    },
+  };
+}
+
+function makeCipherFactoryHybrid() {
+  return {
+    createCipher(options) {
+      return makeCipherHybrid(options);
+    },
+  };
+}
+
+function makeCipherModuleHybrid() {
+  return {
+    getSupportedCiphers() {
+      return Array.from(native.getCiphers());
+    },
+    getCipherInfo(name, keyLength, ivLength) {
+      // Delegates to the runtime's own OpenSSL-backed cipher info table.
+      const nodeCrypto = require("node:crypto");
+      const opts =
+        keyLength === undefined && ivLength === undefined
+          ? undefined
+          : { keyLength: keyLength, ivLength: ivLength };
+      return nodeCrypto.getCipherInfo(name, opts);
+    },
+  };
+}
+
+// --- Blake3 (vendored deps/blake3, mirrors HybridBlake3) ----------------------
+function makeBlake3Hybrid(initialState) {
+  let state = initialState ?? null;
+  return {
+    initHash() {
+      state = native.blake3InitHash();
+    },
+    initKeyed(key) {
+      state = native.blake3InitKeyed(key);
+    },
+    initDeriveKey(context) {
+      state = native.blake3InitDeriveKey(context);
+    },
+    update(data) {
+      native.blake3Update(state, data);
+    },
+    digest(length) {
+      return native.blake3Digest(state, typeof length === "number" ? length : undefined);
+    },
+    copy() {
+      return makeBlake3Hybrid(native.blake3Copy(state));
+    },
+    reset() {
+      native.blake3Reset(state);
+    },
+    getVersion() {
+      return Buffer.from(native.blake3GetVersion()).toString("utf8");
+    },
+  };
+}
+
+const HYBRID_FACTORIES = {
+  Utils: makeUtilsHybrid,
+  Hash: function () {
+    return makeHashHybrid(null);
+  },
+  Hmac: makeHmacHybrid,
+  Random: makeRandomHybrid,
+  Pbkdf2: makePbkdf2Hybrid,
+  Scrypt: makeScryptHybrid,
+  Hkdf: makeHkdfHybrid,
+  Argon2: makeArgon2Hybrid,
+  Cipher: makeCipherModuleHybrid,
+  CipherFactory: makeCipherFactoryHybrid,
+  Blake3: function () {
+    return makeBlake3Hybrid(null);
+  },
+};
+
+const NitroModules = {
+  createHybridObject(name) {
+    const factory = HYBRID_FACTORIES[name];
+    if (factory) return factory();
+    return makeUnsupportedHybrid(name);
+  },
+  // Introspection helper (used by tests to prove the bridge is native).
+  __nativeAddonPath: path.resolve(__dirname, "..", "..", "ohos", "build", "Release", "quick_crypto.node"),
+};
+
+module.exports = { NitroModules };

package/lib/commonjs/nitro-node-shim.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/**
+ * nitro-node-shim.js — environment router for react-native-quick-crypto on
+ * HarmonyOS.
+ *
+ * - Inside a React Native app (navigator.product === 'ReactNative'), the real
+ *   react-native-nitro-modules JSI host is used, exactly as upstream.
+ * - On standalone Node.js (HarmonyOS user-space node), the JSI host is not
+ *   available, so requests are routed to the native-nitro-bridge, which loads
+ *   the standalone N-API addon built by the migrate phase
+ *   (ohos/build/Release/quick_crypto.node) and exposes the same
+ *   NitroModules.createHybridObject() surface backed by real OpenSSL/blake3.
+ */
+
+const IS_REACT_NATIVE =
+  typeof navigator !== "undefined" && navigator !== null && navigator.product === "ReactNative";
+
+if (IS_REACT_NATIVE) {
+  module.exports = require("./nitro-node-shim");
+} else {
+  module.exports = require("./native-nitro-bridge");
+}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}