diff --git a/.claude/plans/quick-wins.md b/.claude/plans/quick-wins.md deleted file mode 100644 index 2564b49d4..000000000 --- a/.claude/plans/quick-wins.md +++ /dev/null @@ -1,43 +0,0 @@ -# Quick Implementation Wins - -Items identified during the implementation-coverage audit (#907) that should be -straightforward to implement. - -## crypto.hash() oneshot function -- Node.js v21.7.0+ `crypto.hash(algorithm, data[, outputEncoding])` -- Simply wraps createHash/update/digest in one call -- Trivial to implement — just a convenience function -- Reference: `crypto.createHash(algorithm).update(data).digest(outputEncoding)` - -## subtle.deriveKey with ECDH -- `subtle.deriveBits` already supports ECDH via `ecDeriveBits()` -- `subtle.deriveKey` is missing the ECDH case in its switch statement -- Fix: add `case 'ECDH':` to the deriveKey switch that calls deriveBits (same pattern as X25519/X448) - -## crypto.getCurves() -- Similar to existing `getCiphers()` and `getHashes()` -- Returns list of supported EC curve names -- OpenSSL has APIs to enumerate curves - -## Ed25519/Ed448 JWK export/import -- spki/pkcs8/raw formats already work -- JWK is the remaining gap -- Node.js and WebCrypto both support JWK for Ed25519/Ed448 -- Closes #653 (subtle.importKey with Ed25519) - -## KeyObject.equals() -- Compare two KeyObjects for equality -- Should be straightforward with exported key comparison - -## KeyObject.symmetricKeySize -- Return the size of a symmetric key in bytes -- Simple property accessor - -## createDiffieHellmanGroup alias -- Node.js exports `createDiffieHellmanGroup` as an alias for `getDiffieHellman` -- `getDiffieHellman` already exists and works -- Just add a re-export: `export { getDiffieHellman as createDiffieHellmanGroup }` - -## diffieHellman.verifyError -- DiffieHellman class is fully implemented except this property -- Returns verification errors from DH parameter checking diff --git a/.docs/implementation-coverage.md b/.docs/implementation-coverage.md index 3b257e066..482fa2c9a 100644 --- a/.docs/implementation-coverage.md +++ b/.docs/implementation-coverage.md @@ -43,7 +43,7 @@ These algorithms provide quantum-resistant cryptography. * ✅ `diffieHellman.getPublicKey([encoding])` * ✅ `diffieHellman.setPrivateKey(privateKey[, encoding])` * ✅ `diffieHellman.setPublicKey(publicKey[, encoding])` - * ❌ `diffieHellman.verifyError` + * ✅ `diffieHellman.verifyError` * ✅ Class: `DiffieHellmanGroup` * ✅ Class: `ECDH` * ❌ static `ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])` @@ -65,8 +65,8 @@ These algorithms provide quantum-resistant cryptography. * ❌ `keyObject.asymmetricKeyDetails` * ✅ `keyObject.asymmetricKeyType` * ✅ `keyObject.export([options])` - * ❌ `keyObject.equals(otherKeyObject)` - * ❌ `keyObject.symmetricKeySize` + * ✅ `keyObject.equals(otherKeyObject)` + * ✅ `keyObject.symmetricKeySize` * ❌ `keyObject.toCryptoKey(algorithm, extractable, keyUsages)` * ✅ `keyObject.type` * ✅ Class: `Sign` @@ -111,6 +111,7 @@ These algorithms provide quantum-resistant cryptography. * ✅ `crypto.createDecipheriv(algorithm, key, iv[, options])` * ✅ `crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])` * ✅ `crypto.createDiffieHellman(primeLength[, generator])` + * ✅ `crypto.createDiffieHellmanGroup(groupName)` * ✅ `crypto.getDiffieHellman(groupName)` * ✅ `crypto.createECDH(curveName)` * ✅ `crypto.createHash(algorithm[, options])` @@ -136,7 +137,7 @@ These algorithms provide quantum-resistant cryptography. * ❌ `crypto.getFips()` * ✅ `crypto.getHashes()` * ✅ `crypto.getRandomValues(typedArray)` - * ❌ `crypto.hash(algorithm, data[, options])` + * ✅ `crypto.hash(algorithm, data[, outputEncoding])` * ✅ `crypto.hkdf(digest, ikm, salt, info, keylen, callback)` * ✅ `crypto.hkdfSync(digest, ikm, salt, info, keylen)` * ✅ `crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)` @@ -263,8 +264,8 @@ These ciphers are **not available in Node.js** but are provided by RNQC via libs * ❌ `subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)` * ❌ `subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)` * ✅ `subtle.decrypt(algorithm, key, data)` - * 🚧 `subtle.deriveBits(algorithm, baseKey, length)` - * 🚧 `subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)` + * ✅ `subtle.deriveBits(algorithm, baseKey, length)` + * ✅ `subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)` * 🚧 `subtle.digest(algorithm, data)` * ❌ `subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)` * ❌ `subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)` @@ -299,7 +300,7 @@ These ciphers are **not available in Node.js** but are provided by RNQC via libs ## `subtle.deriveKey` | Algorithm | Status | | --------- | :----: | -| `ECDH` | ❌ | +| `ECDH` | ✅ | | `HKDF` | ✅ | | `PBKDF2` | ✅ | | `X25519` | ✅ | @@ -339,8 +340,8 @@ These ciphers are **not available in Node.js** but are provided by RNQC via libs | `ChaCha20-Poly1305` | | | ✅ | | ✅ | | | | `ECDH` | ✅ | ✅ | ✅ | ✅ | | ✅ | | | `ECDSA` | ✅ | ✅ | ✅ | ✅ | | ✅ | | -| `Ed25519` | ✅ | ✅ | ❌ | ✅ | | ❌ | | -| `Ed448` | ✅ | ✅ | ❌ | ✅ | | ❌ | | +| `Ed25519` | ✅ | ✅ | ✅ | ✅ | | ❌ | | +| `Ed448` | ✅ | ✅ | ✅ | ✅ | | ❌ | | | `HMAC` | | | ✅ | ✅ | ✅ | | | | `ML-DSA-44` | ✅ | ✅ | ✅ | | | ✅ | ✅ | | `ML-DSA-65` | ✅ | ✅ | ✅ | | | ✅ | ✅ | @@ -399,8 +400,8 @@ These ciphers are **not available in Node.js** but are provided by RNQC via libs | `ChaCha20-Poly1305` | | | ✅ | | ✅ | | | | `ECDH` | ✅ | ✅ | ✅ | ✅ | | ✅ | | | `ECDSA` | ✅ | ✅ | ✅ | ✅ | | ✅ | | -| `Ed25519` | ✅ | ✅ | ❌ | ❌ | | ❌ | | -| `Ed448` | ✅ | ✅ | ❌ | ❌ | | ❌ | | +| `Ed25519` | ✅ | ✅ | ✅ | ✅ | | ❌ | | +| `Ed448` | ✅ | ✅ | ✅ | ✅ | | ❌ | | | `HKDF` | | | | ✅ | ❌ | | | | `HMAC` | | | ✅ | ✅ | ✅ | | | | `ML-DSA-44` | ✅ | ✅ | ✅ | | | ✅ | ✅ | diff --git a/docs/data/coverage.ts b/docs/data/coverage.ts index 0aee26da1..d303c20f1 100644 --- a/docs/data/coverage.ts +++ b/docs/data/coverage.ts @@ -115,8 +115,8 @@ export const COVERAGE_DATA: CoverageCategory[] = [ { name: 'export', status: 'implemented' }, { name: 'type', status: 'implemented' }, { name: 'asymmetricKeyDetails', status: 'missing' }, - { name: 'equals', status: 'missing' }, - { name: 'symmetricKeySize', status: 'missing' }, + { name: 'equals', status: 'implemented' }, + { name: 'symmetricKeySize', status: 'implemented' }, { name: 'toCryptoKey', status: 'missing' }, { name: 'from', status: 'missing', note: 'static' }, ], @@ -136,7 +136,7 @@ export const COVERAGE_DATA: CoverageCategory[] = [ { name: 'createCipheriv', status: 'implemented' }, { name: 'createDecipheriv', status: 'implemented' }, { name: 'createDiffieHellman', status: 'implemented' }, - { name: 'createDiffieHellmanGroup', status: 'missing' }, + { name: 'createDiffieHellmanGroup', status: 'implemented' }, { name: 'createECDH', status: 'implemented' }, { name: 'createHash', status: 'implemented' }, { name: 'createHmac', status: 'implemented' }, @@ -209,7 +209,7 @@ export const COVERAGE_DATA: CoverageCategory[] = [ { name: 'getFips', status: 'missing' }, { name: 'getHashes', status: 'implemented' }, { name: 'getRandomValues', status: 'implemented' }, - { name: 'hash', status: 'missing' }, + { name: 'hash', status: 'implemented' }, { name: 'hkdf', status: 'implemented' }, { name: 'pbkdf2', status: 'implemented' }, { name: 'privateDecrypt / privateEncrypt', status: 'implemented' }, @@ -284,7 +284,7 @@ export const COVERAGE_DATA: CoverageCategory[] = [ { name: 'crypto.subtle.deriveKey', subItems: [ - { name: 'ECDH', status: 'missing' }, + { name: 'ECDH', status: 'implemented' }, { name: 'HKDF', status: 'implemented' }, { name: 'PBKDF2', status: 'implemented' }, { name: 'X25519', status: 'implemented' }, @@ -339,8 +339,8 @@ export const COVERAGE_DATA: CoverageCategory[] = [ status: 'partial', note: 'spki, pkcs8, jwk, raw, raw-public', }, - { name: 'Ed25519', status: 'partial', note: 'spki, pkcs8, raw' }, - { name: 'Ed448', status: 'partial', note: 'spki, pkcs8, raw' }, + { name: 'Ed25519', status: 'partial', note: 'spki, pkcs8, raw, jwk' }, + { name: 'Ed448', status: 'partial', note: 'spki, pkcs8, raw, jwk' }, { name: 'HMAC', status: 'partial', note: 'jwk, raw, raw-secret' }, { name: 'ML-DSA-44', @@ -415,8 +415,8 @@ export const COVERAGE_DATA: CoverageCategory[] = [ status: 'partial', note: 'spki, pkcs8, jwk, raw, raw-public', }, - { name: 'Ed25519', status: 'partial', note: 'spki, pkcs8' }, - { name: 'Ed448', status: 'partial', note: 'spki, pkcs8' }, + { name: 'Ed25519', status: 'partial', note: 'spki, pkcs8, raw, jwk' }, + { name: 'Ed448', status: 'partial', note: 'spki, pkcs8, raw, jwk' }, { name: 'HKDF', status: 'partial', note: 'raw' }, { name: 'HMAC', status: 'partial', note: 'jwk, raw, raw-secret' }, { diff --git a/example/src/tests/dh/dh_tests.ts b/example/src/tests/dh/dh_tests.ts index b04842c66..bbc63f584 100644 --- a/example/src/tests/dh/dh_tests.ts +++ b/example/src/tests/dh/dh_tests.ts @@ -88,3 +88,34 @@ test(SUITE, 'should reject prime length below 2048 bits', () => { crypto.createDiffieHellman(512); }, /prime length must be at least 2048 bits/); }); + +// createDiffieHellmanGroup alias +test( + SUITE, + 'createDiffieHellmanGroup should be an alias for getDiffieHellman', + () => { + const dh1 = crypto.getDiffieHellman('modp14'); + const dh2 = crypto.createDiffieHellmanGroup('modp14'); + + assert.strictEqual(dh1.getPrime('hex'), dh2.getPrime('hex')); + assert.strictEqual(dh1.getGenerator('hex'), dh2.getGenerator('hex')); + }, +); + +test(SUITE, 'createDiffieHellmanGroup should throw for unknown group', () => { + assert.throws(() => { + crypto.createDiffieHellmanGroup('modp999'); + }, /Unknown group/); +}); + +// verifyError property +test(SUITE, 'verifyError should return 0 for valid DH params', () => { + const dh = crypto.getDiffieHellman('modp14'); + assert.strictEqual(dh.verifyError, 0); +}); + +test(SUITE, 'verifyError should return 0 for created DH', () => { + const prime = Buffer.from(MODP14_PRIME, 'hex'); + const dh = crypto.createDiffieHellman(prime, 2); + assert.strictEqual(dh.verifyError, 0); +}); diff --git a/example/src/tests/hash/hash_tests.ts b/example/src/tests/hash/hash_tests.ts index 497dcf92b..4ad2aa0fe 100644 --- a/example/src/tests/hash/hash_tests.ts +++ b/example/src/tests/hash/hash_tests.ts @@ -6,6 +6,7 @@ import { Buffer, createHash, + hash, getHashes, type Encoding, } from 'react-native-quick-crypto'; @@ -283,3 +284,40 @@ test(SUITE, 'createHash with null outputLength', () => { createHash('shake128', { outputLength: null }); }).to.throw(/Output length must be a number/); }); + +// crypto.hash() oneshot function tests +test(SUITE, 'hash() oneshot - sha256 hex', () => { + const result = hash('sha256', 'Test123', 'hex'); + const expected = createHash('sha256').update('Test123').digest('hex'); + expect(result).to.equal(expected); +}); + +test(SUITE, 'hash() oneshot - sha256 base64', () => { + const result = hash('sha256', 'Test123', 'base64'); + const expected = createHash('sha256').update('Test123').digest('base64'); + expect(result).to.equal(expected); +}); + +test(SUITE, 'hash() oneshot - returns Buffer without encoding', () => { + const result = hash('sha256', 'Test123'); + expect(Buffer.isBuffer(result)).to.equal(true); + expect(typeof result).to.not.equal('string'); +}); + +test(SUITE, 'hash() oneshot - sha512', () => { + const result = hash('sha512', 'hello world', 'hex'); + const expected = createHash('sha512').update('hello world').digest('hex'); + expect(result).to.equal(expected); +}); + +test(SUITE, 'hash() oneshot - md5', () => { + const result = hash('md5', 'Test123', 'hex'); + expect(result).to.equal('68eacb97d86f0c4621fa2b0e17cabd8c'); +}); + +test(SUITE, 'hash() oneshot - Buffer input', () => { + const data = Buffer.from('hello'); + const result = hash('sha256', data, 'hex'); + const expected = createHash('sha256').update(data).digest('hex'); + expect(result).to.equal(expected); +}); diff --git a/example/src/tests/keys/create_keys.ts b/example/src/tests/keys/create_keys.ts index c8f64bbe9..e7fabca31 100644 --- a/example/src/tests/keys/create_keys.ts +++ b/example/src/tests/keys/create_keys.ts @@ -411,3 +411,47 @@ test( }, ''); }, ); + +// --- KeyObject.equals() Tests --- + +test(SUITE, 'equals - same secret keys are equal', () => { + const keyData = randomBytes(32); + const key1 = createSecretKey(keyData); + const key2 = createSecretKey(keyData); + expect(key1.equals(key2)).to.equal(true); +}); + +test(SUITE, 'equals - different secret keys are not equal', () => { + const key1 = createSecretKey(randomBytes(32)); + const key2 = createSecretKey(randomBytes(32)); + expect(key1.equals(key2)).to.equal(false); +}); + +test(SUITE, 'equals - same RSA public keys are equal', () => { + const key1 = createPublicKey(rsaPublicKeyPem); + const key2 = createPublicKey(rsaPublicKeyPem); + expect(key1.equals(key2)).to.equal(true); +}); + +test(SUITE, 'equals - different key types are not equal', () => { + const secretKey = createSecretKey(randomBytes(32)); + const publicKey = createPublicKey(rsaPublicKeyPem); + expect(secretKey.equals(publicKey)).to.equal(false); +}); + +// --- KeyObject.symmetricKeySize Tests --- + +test(SUITE, 'symmetricKeySize - 16 byte key', () => { + const key = createSecretKey(randomBytes(16)); + expect(key.symmetricKeySize).to.equal(16); +}); + +test(SUITE, 'symmetricKeySize - 32 byte key', () => { + const key = createSecretKey(randomBytes(32)); + expect(key.symmetricKeySize).to.equal(32); +}); + +test(SUITE, 'symmetricKeySize - 64 byte key', () => { + const key = createSecretKey(randomBytes(64)); + expect(key.symmetricKeySize).to.equal(64); +}); diff --git a/example/src/tests/subtle/derive_key.ts b/example/src/tests/subtle/derive_key.ts index b91d0157a..f2dcff6fc 100644 --- a/example/src/tests/subtle/derive_key.ts +++ b/example/src/tests/subtle/derive_key.ts @@ -98,3 +98,67 @@ test(SUITE, 'X25519 deriveKey to AES-GCM', async () => { Buffer.from(bobRaw as ArrayBuffer).toString('hex'), ); }); + +// Test 3: ECDH deriveKey +test(SUITE, 'ECDH P-256 deriveKey to AES-GCM', async () => { + const aliceKeyPair = await subtle.generateKey( + { name: 'ECDH', namedCurve: 'P-256' }, + false, + ['deriveKey', 'deriveBits'], + ); + + const bobKeyPair = await subtle.generateKey( + { name: 'ECDH', namedCurve: 'P-256' }, + false, + ['deriveKey', 'deriveBits'], + ); + + const aliceDerivedKey = await subtleAny.deriveKey( + { + name: 'ECDH', + public: (aliceKeyPair as CryptoKeyPair).publicKey, + }, + (bobKeyPair as CryptoKeyPair).privateKey, + { name: 'AES-GCM', length: 256 }, + true, + ['encrypt', 'decrypt'], + ); + + const bobDerivedKey = await subtleAny.deriveKey( + { + name: 'ECDH', + public: (bobKeyPair as CryptoKeyPair).publicKey, + }, + (aliceKeyPair as CryptoKeyPair).privateKey, + { name: 'AES-GCM', length: 256 }, + true, + ['encrypt', 'decrypt'], + ); + + const aliceRaw = await subtle.exportKey('raw', aliceDerivedKey as CryptoKey); + const bobRaw = await subtle.exportKey('raw', bobDerivedKey as CryptoKey); + + expect(Buffer.from(aliceRaw as ArrayBuffer).toString('hex')).to.equal( + Buffer.from(bobRaw as ArrayBuffer).toString('hex'), + ); + + // Verify key works for encrypt/decrypt + const plaintext = new Uint8Array([1, 2, 3, 4]); + const iv = getRandomValues(new Uint8Array(12)); + + const ciphertext = await subtle.encrypt( + { name: 'AES-GCM', iv }, + aliceDerivedKey as CryptoKey, + plaintext, + ); + + const decrypted = await subtle.decrypt( + { name: 'AES-GCM', iv }, + bobDerivedKey as CryptoKey, + ciphertext, + ); + + expect(Buffer.from(decrypted).toString('hex')).to.equal( + Buffer.from(plaintext).toString('hex'), + ); +}); diff --git a/example/src/tests/subtle/jwk_rfc7517_tests.ts b/example/src/tests/subtle/jwk_rfc7517_tests.ts index dc6b9745a..54c5191bd 100644 --- a/example/src/tests/subtle/jwk_rfc7517_tests.ts +++ b/example/src/tests/subtle/jwk_rfc7517_tests.ts @@ -160,3 +160,115 @@ test(SUITE, 'JWK export - issue #806 - no trailing periods', async () => { ); expect(imported.type).to.equal('private'); }); + +// Ed25519 JWK export/import roundtrip +test(SUITE, 'JWK export/import - Ed25519 keypair roundtrip', async () => { + const { publicKey, privateKey } = (await subtle.generateKey( + { name: 'Ed25519' }, + true, + ['sign', 'verify'], + )) as CryptoKeyPair; + + // Export public key as JWK + const pubJwk = (await subtle.exportKey('jwk', publicKey as CryptoKey)) as JWK; + expect(pubJwk.kty).to.equal('OKP'); + expect(pubJwk.crv).to.equal('Ed25519'); + expect(pubJwk.x).to.match(/^[A-Za-z0-9_-]+$/); + expect(pubJwk.d).to.equal(undefined); + + // Export private key as JWK + const privJwk = (await subtle.exportKey( + 'jwk', + privateKey as CryptoKey, + )) as JWK; + expect(privJwk.kty).to.equal('OKP'); + expect(privJwk.crv).to.equal('Ed25519'); + expect(privJwk.x).to.match(/^[A-Za-z0-9_-]+$/); + expect(privJwk.d).to.match(/^[A-Za-z0-9_-]+$/); + + // Import public key from JWK + const importedPub = await subtle.importKey( + 'jwk', + pubJwk, + { name: 'Ed25519' }, + true, + ['verify'], + ); + expect(importedPub.type).to.equal('public'); + + // Import private key from JWK + const importedPriv = await subtle.importKey( + 'jwk', + privJwk, + { name: 'Ed25519' }, + true, + ['sign'], + ); + expect(importedPriv.type).to.equal('private'); + + // Sign with imported private, verify with imported public + const data = new Uint8Array([1, 2, 3, 4, 5]); + const signature = await subtle.sign( + { name: 'Ed25519' }, + importedPriv as CryptoKey, + data, + ); + const verified = await subtle.verify( + { name: 'Ed25519' }, + importedPub as CryptoKey, + signature, + data, + ); + expect(verified).to.equal(true); +}); + +// Ed448 JWK export/import roundtrip +test(SUITE, 'JWK export/import - Ed448 keypair roundtrip', async () => { + const { publicKey, privateKey } = (await subtle.generateKey( + { name: 'Ed448' }, + true, + ['sign', 'verify'], + )) as CryptoKeyPair; + + const pubJwk = (await subtle.exportKey('jwk', publicKey as CryptoKey)) as JWK; + expect(pubJwk.kty).to.equal('OKP'); + expect(pubJwk.crv).to.equal('Ed448'); + + const privJwk = (await subtle.exportKey( + 'jwk', + privateKey as CryptoKey, + )) as JWK; + expect(privJwk.kty).to.equal('OKP'); + expect(privJwk.crv).to.equal('Ed448'); + expect(privJwk.d).to.match(/^[A-Za-z0-9_-]+$/); + + // Roundtrip: import and sign/verify + const importedPriv = await subtle.importKey( + 'jwk', + privJwk, + { name: 'Ed448' }, + true, + ['sign'], + ); + const importedPub = await subtle.importKey( + 'jwk', + pubJwk, + { name: 'Ed448' }, + true, + ['verify'], + ); + + const data = new Uint8Array([10, 20, 30]); + const signature = await subtle.sign( + { name: 'Ed448' }, + importedPriv as CryptoKey, + data, + ); + const verified = await subtle.verify( + { name: 'Ed448' }, + importedPub as CryptoKey, + signature, + data, + ); + expect(verified).to.equal(true); +}); diff --git a/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.cpp b/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.cpp index 576137e1a..41c077643 100644 --- a/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.cpp +++ b/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.cpp @@ -433,6 +433,16 @@ const DH* HybridDiffieHellman::getDH() const { return dh; } +double HybridDiffieHellman::getVerifyError() { + ensureInitialized(); + const DH* dh = getDH(); + int codes = 0; + if (DH_check(const_cast(dh), &codes) != 1) { + return 0; + } + return static_cast(codes); +} + #pragma clang diagnostic pop } // namespace margelo::nitro::crypto diff --git a/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.hpp b/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.hpp index c4a4bd9e1..8d77a1cf1 100644 --- a/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.hpp +++ b/packages/react-native-quick-crypto/cpp/dh/HybridDiffieHellman.hpp @@ -30,6 +30,7 @@ class HybridDiffieHellman : public HybridDiffieHellmanSpec { std::shared_ptr getPrivateKey() override; void setPublicKey(const std::shared_ptr& publicKey) override; void setPrivateKey(const std::shared_ptr& privateKey) override; + double getVerifyError() override; private: EVP_PKEY_ptr _pkey; diff --git a/packages/react-native-quick-crypto/cpp/hash/HybridHash.cpp b/packages/react-native-quick-crypto/cpp/hash/HybridHash.cpp index 6e03eaff5..c3bdf7976 100644 --- a/packages/react-native-quick-crypto/cpp/hash/HybridHash.cpp +++ b/packages/react-native-quick-crypto/cpp/hash/HybridHash.cpp @@ -68,7 +68,7 @@ void HybridHash::createHash(const std::string& hashAlgorithmArg, const std::opti } } -void HybridHash::update(const std::variant>& data) { +void HybridHash::update(const std::variant, std::string>& data) { if (!ctx) { throw std::runtime_error("Hash context not initialized"); } diff --git a/packages/react-native-quick-crypto/cpp/hash/HybridHash.hpp b/packages/react-native-quick-crypto/cpp/hash/HybridHash.hpp index 907b8dac9..a71f512ce 100644 --- a/packages/react-native-quick-crypto/cpp/hash/HybridHash.hpp +++ b/packages/react-native-quick-crypto/cpp/hash/HybridHash.hpp @@ -21,7 +21,7 @@ class HybridHash : public HybridHashSpec { public: // Methods void createHash(const std::string& algorithm, const std::optional outputLength) override; - void update(const std::variant>& data) override; + void update(const std::variant, std::string>& data) override; std::shared_ptr digest(const std::optional& encoding = std::nullopt) override; std::shared_ptr copy(const std::optional outputLength) override; std::vector getSupportedHashAlgorithms() override; diff --git a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp index 2284fe5a2..378e0dadb 100644 --- a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp +++ b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.cpp @@ -60,7 +60,7 @@ void HybridHmac::createHmac(const std::string& hmacAlgorithm, const std::shared_ } } -void HybridHmac::update(const std::variant>& data) { +void HybridHmac::update(const std::variant, std::string>& data) { if (!ctx) { throw std::runtime_error("HMAC context not initialized"); } diff --git a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp index fdec7dd38..0de204085 100644 --- a/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp +++ b/packages/react-native-quick-crypto/cpp/hmac/HybridHmac.hpp @@ -20,7 +20,7 @@ class HybridHmac : public HybridHmacSpec { public: // Methods void createHmac(const std::string& algorithm, const std::shared_ptr& key) override; - void update(const std::variant>& data) override; + void update(const std::variant, std::string>& data) override; std::shared_ptr digest() override; private: diff --git a/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.cpp b/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.cpp index 4105d245e..e9f64abb5 100644 --- a/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.cpp +++ b/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.cpp @@ -5,6 +5,7 @@ #include "HybridKeyObjectHandle.hpp" #include "QuickCryptoUtils.hpp" #include +#include #include #include #include @@ -292,6 +293,44 @@ JWK HybridKeyObjectHandle::exportJwk(const JWK& key, bool handleRsaPss) { return result; } + // Export OKP keys (Ed25519, Ed448, X25519, X448) per RFC 8037 + if (keyId == EVP_PKEY_ED25519 || keyId == EVP_PKEY_ED448 || keyId == EVP_PKEY_X25519 || keyId == EVP_PKEY_X448) { + result.kty = JWKkty::OKP; + + switch (keyId) { + case EVP_PKEY_ED25519: + result.crv = "Ed25519"; + break; + case EVP_PKEY_ED448: + result.crv = "Ed448"; + break; + case EVP_PKEY_X25519: + result.crv = "X25519"; + break; + case EVP_PKEY_X448: + result.crv = "X448"; + break; + default: + break; + } + + auto pubKey = pkey.rawPublicKey(); + if (!pubKey) { + throw std::runtime_error("Failed to get raw public key for OKP JWK export"); + } + result.x = base64url_encode(reinterpret_cast(pubKey.get()), pubKey.size()); + + if (keyType == KeyType::PRIVATE) { + auto privKey = pkey.rawPrivateKey(); + if (!privKey) { + throw std::runtime_error("Failed to get raw private key for OKP JWK export"); + } + result.d = base64url_encode(reinterpret_cast(privKey.get()), privKey.size()); + } + + return result; + } + throw std::runtime_error("Unsupported key type for JWK export"); } @@ -335,7 +374,7 @@ AsymmetricKeyType HybridKeyObjectHandle::getAsymmetricKeyType() { } } -bool HybridKeyObjectHandle::init(KeyType keyType, const std::variant>& key, +bool HybridKeyObjectHandle::init(KeyType keyType, const std::variant, std::string>& key, std::optional format, std::optional type, const std::optional>& passphrase) { // Reset any existing data to prevent state leakage @@ -597,6 +636,50 @@ std::optional HybridKeyObjectHandle::initJwk(const JWK& keyData, std::o return type; } + // Handle OKP keys (Ed25519, Ed448, X25519, X448) per RFC 8037 + if (kty == JWKkty::OKP) { + bool isPrivate = keyData.d.has_value(); + + if (!keyData.crv.has_value() || !keyData.x.has_value()) { + throw std::runtime_error("JWK OKP key missing required fields (crv, x)"); + } + + std::string crv = keyData.crv.value(); + + int evpType; + if (crv == "Ed25519") { + evpType = EVP_PKEY_ED25519; + } else if (crv == "Ed448") { + evpType = EVP_PKEY_ED448; + } else if (crv == "X25519") { + evpType = EVP_PKEY_X25519; + } else if (crv == "X448") { + evpType = EVP_PKEY_X448; + } else { + throw std::runtime_error("Unsupported OKP curve: " + crv); + } + + if (isPrivate) { + std::string privBytes = base64url_decode(keyData.d.value()); + EVP_PKEY* pkey = + EVP_PKEY_new_raw_private_key(evpType, nullptr, reinterpret_cast(privBytes.data()), privBytes.size()); + if (!pkey) { + throw std::runtime_error("Failed to create OKP private key from JWK"); + } + data_ = KeyObjectData::CreateAsymmetric(KeyType::PRIVATE, ncrypto::EVPKeyPointer(pkey)); + return KeyType::PRIVATE; + } else { + std::string pubBytes = base64url_decode(keyData.x.value()); + EVP_PKEY* pkey = + EVP_PKEY_new_raw_public_key(evpType, nullptr, reinterpret_cast(pubBytes.data()), pubBytes.size()); + if (!pkey) { + throw std::runtime_error("Failed to create OKP public key from JWK"); + } + data_ = KeyObjectData::CreateAsymmetric(KeyType::PUBLIC, ncrypto::EVPKeyPointer(pkey)); + return KeyType::PUBLIC; + } + } + throw std::runtime_error("Unsupported JWK key type"); } @@ -754,4 +837,32 @@ bool HybridKeyObjectHandle::initECRaw(const std::string& namedCurve, const std:: return true; } +bool HybridKeyObjectHandle::keyEquals(const std::shared_ptr& other) { + auto otherHandle = std::dynamic_pointer_cast(other); + if (!otherHandle) + return false; + + const auto& otherData = otherHandle->getKeyObjectData(); + if (data_.GetKeyType() != otherData.GetKeyType()) + return false; + + if (data_.GetKeyType() == KeyType::SECRET) { + auto thisKey = data_.GetSymmetricKey(); + auto otherKey = otherData.GetSymmetricKey(); + if (thisKey->size() != otherKey->size()) + return false; + return CRYPTO_memcmp(thisKey->data(), otherKey->data(), thisKey->size()) == 0; + } + + const auto& thisPkey = data_.GetAsymmetricKey(); + const auto& otherPkey = otherData.GetAsymmetricKey(); + if (!thisPkey || !otherPkey) + return false; + return EVP_PKEY_eq(thisPkey.get(), otherPkey.get()) == 1; +} + +double HybridKeyObjectHandle::getSymmetricKeySize() { + return static_cast(data_.GetSymmetricKeySize()); +} + } // namespace margelo::nitro::crypto diff --git a/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.hpp b/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.hpp index 925f3014e..21d646960 100644 --- a/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.hpp +++ b/packages/react-native-quick-crypto/cpp/keys/HybridKeyObjectHandle.hpp @@ -26,7 +26,7 @@ class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec { AsymmetricKeyType getAsymmetricKeyType() override; - bool init(KeyType keyType, const std::variant>& key, std::optional format, + bool init(KeyType keyType, const std::variant, std::string>& key, std::optional format, std::optional type, const std::optional>& passphrase) override; bool initECRaw(const std::string& namedCurve, const std::shared_ptr& keyData) override; @@ -35,6 +35,10 @@ class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec { KeyDetail keyDetail() override; + bool keyEquals(const std::shared_ptr& other) override; + + double getSymmetricKeySize() override; + KeyObjectData& getKeyObjectData() { return data_; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake index 355473e6a..77f35d98a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake +++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake @@ -2,7 +2,7 @@ # QuickCrypto+autolinking.cmake # This file was generated by nitrogen. DO NOT MODIFY THIS FILE. # https://github.com/mrousavy/nitro -# Copyright © 2025 Marc Rousavy @ Margelo +# Copyright © Marc Rousavy @ Margelo # # This is a CMake file that adds all files generated by Nitrogen @@ -13,6 +13,12 @@ # include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinking.cmake) # ``` +# Define a flag to check if we are building properly +add_definitions(-DBUILDING_QUICKCRYPTO_WITH_GENERATED_CMAKE_PROJECT) + +# Enable Raw Props parsing in react-native (for Nitro Views) +add_definitions(-DRN_SERIALIZABLE_STATE) + # Add all headers that were generated by Nitrogen include_directories( "../nitrogen/generated/shared/c++" @@ -51,12 +57,9 @@ target_sources( ) -# Define a flag to check if we are building properly -add_definitions(-DBUILDING_QUICKCRYPTO_WITH_GENERATED_CMAKE_PROJECT) - # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake # Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake - target_compile_definitions( +target_compile_definitions( QuickCrypto PRIVATE -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle index bb45922d7..5b0cc3685 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle +++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle @@ -2,7 +2,7 @@ /// QuickCrypto+autolinking.gradle /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// /// This is a Gradle file that adds all files generated by Nitrogen diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp index e4a32c35f..cfd3ad5b8 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp @@ -2,7 +2,7 @@ /// QuickCryptoOnLoad.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #ifndef BUILDING_QUICKCRYPTO_WITH_GENERATED_CMAKE_PROJECT @@ -18,23 +18,23 @@ #include "HybridBlake3.hpp" #include "HybridCipher.hpp" #include "HybridCipherFactory.hpp" +#include "HybridDiffieHellman.hpp" +#include "HybridECDH.hpp" #include "HybridEcKeyPair.hpp" #include "HybridEdKeyPair.hpp" #include "HybridHash.hpp" -#include "HybridHmac.hpp" #include "HybridHkdf.hpp" +#include "HybridHmac.hpp" #include "HybridKeyObjectHandle.hpp" +#include "HybridMlDsaKeyPair.hpp" #include "HybridPbkdf2.hpp" #include "HybridRandom.hpp" #include "HybridRsaCipher.hpp" #include "HybridRsaKeyPair.hpp" -#include "HybridSignHandle.hpp" -#include "HybridVerifyHandle.hpp" -#include "HybridMlDsaKeyPair.hpp" #include "HybridScrypt.hpp" +#include "HybridSignHandle.hpp" #include "HybridUtils.hpp" -#include "HybridECDH.hpp" -#include "HybridDiffieHellman.hpp" +#include "HybridVerifyHandle.hpp" namespace margelo::nitro::crypto { @@ -75,6 +75,24 @@ int initialize(JavaVM* vm) { return std::make_shared(); } ); + HybridObjectRegistry::registerHybridObjectConstructor( + "DiffieHellman", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridDiffieHellman\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); + HybridObjectRegistry::registerHybridObjectConstructor( + "ECDH", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridECDH\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); HybridObjectRegistry::registerHybridObjectConstructor( "EcKeyPair", []() -> std::shared_ptr { @@ -103,21 +121,21 @@ int initialize(JavaVM* vm) { } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Hmac", + "Hkdf", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridHmac\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridHkdf\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Hkdf", + "Hmac", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridHkdf\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridHmac\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( @@ -129,6 +147,15 @@ int initialize(JavaVM* vm) { return std::make_shared(); } ); + HybridObjectRegistry::registerHybridObjectConstructor( + "MlDsaKeyPair", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); HybridObjectRegistry::registerHybridObjectConstructor( "Pbkdf2", []() -> std::shared_ptr { @@ -165,33 +192,6 @@ int initialize(JavaVM* vm) { return std::make_shared(); } ); - HybridObjectRegistry::registerHybridObjectConstructor( - "SignHandle", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridSignHandle\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); - HybridObjectRegistry::registerHybridObjectConstructor( - "VerifyHandle", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridVerifyHandle\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); - HybridObjectRegistry::registerHybridObjectConstructor( - "MlDsaKeyPair", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); HybridObjectRegistry::registerHybridObjectConstructor( "Scrypt", []() -> std::shared_ptr { @@ -202,30 +202,30 @@ int initialize(JavaVM* vm) { } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Utils", + "SignHandle", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridUtils\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridSignHandle\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "ECDH", + "Utils", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridECDH\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridUtils\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "DiffieHellman", + "VerifyHandle", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridDiffieHellman\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridVerifyHandle\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); }); diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.hpp b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.hpp index 20644dd80..7086216a8 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.hpp @@ -2,7 +2,7 @@ /// QuickCryptoOnLoad.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/kotlin/com/margelo/nitro/crypto/QuickCryptoOnLoad.kt b/packages/react-native-quick-crypto/nitrogen/generated/android/kotlin/com/margelo/nitro/crypto/QuickCryptoOnLoad.kt index 132580399..d4d164a48 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/android/kotlin/com/margelo/nitro/crypto/QuickCryptoOnLoad.kt +++ b/packages/react-native-quick-crypto/nitrogen/generated/android/kotlin/com/margelo/nitro/crypto/QuickCryptoOnLoad.kt @@ -2,7 +2,7 @@ /// QuickCryptoOnLoad.kt /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// package com.margelo.nitro.crypto diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb index 892447b57..dece5ea57 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb @@ -2,7 +2,7 @@ # QuickCrypto+autolinking.rb # This file was generated by nitrogen. DO NOT MODIFY THIS FILE. # https://github.com/mrousavy/nitro -# Copyright © 2025 Marc Rousavy @ Margelo +# Copyright © Marc Rousavy @ Margelo # # This is a Ruby script that adds all files generated by Nitrogen @@ -52,7 +52,7 @@ def add_nitrogen_files(spec) spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({ # Use C++ 20 "CLANG_CXX_LANGUAGE_STANDARD" => "c++20", - # Enables C++ <-> Swift interop (by default it's only C) + # Enables C++ <-> Swift interop (by default it's only ObjC) "SWIFT_OBJC_INTEROP_MODE" => "objcxx", # Enables stricter modular headers "DEFINES_MODULE" => "YES", diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp index 5cef4e417..adde9e531 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp @@ -2,7 +2,7 @@ /// QuickCrypto-Swift-Cxx-Bridge.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "QuickCrypto-Swift-Cxx-Bridge.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp index 51dca1ef1..ce14819b8 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp @@ -2,7 +2,7 @@ /// QuickCrypto-Swift-Cxx-Bridge.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp index 205ccfaa4..c8e16f4ff 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp @@ -2,7 +2,7 @@ /// QuickCrypto-Swift-Cxx-Umbrella.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm index f952d7859..2470c83bc 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm @@ -2,7 +2,7 @@ /// QuickCryptoAutolinking.mm /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #import @@ -13,23 +13,23 @@ #include "HybridBlake3.hpp" #include "HybridCipher.hpp" #include "HybridCipherFactory.hpp" +#include "HybridDiffieHellman.hpp" +#include "HybridECDH.hpp" #include "HybridEcKeyPair.hpp" #include "HybridEdKeyPair.hpp" #include "HybridHash.hpp" -#include "HybridHmac.hpp" #include "HybridHkdf.hpp" +#include "HybridHmac.hpp" #include "HybridKeyObjectHandle.hpp" +#include "HybridMlDsaKeyPair.hpp" #include "HybridPbkdf2.hpp" #include "HybridRandom.hpp" #include "HybridRsaCipher.hpp" #include "HybridRsaKeyPair.hpp" -#include "HybridSignHandle.hpp" -#include "HybridVerifyHandle.hpp" -#include "HybridMlDsaKeyPair.hpp" #include "HybridScrypt.hpp" +#include "HybridSignHandle.hpp" #include "HybridUtils.hpp" -#include "HybridECDH.hpp" -#include "HybridDiffieHellman.hpp" +#include "HybridVerifyHandle.hpp" @interface QuickCryptoAutolinking : NSObject @end @@ -67,6 +67,24 @@ + (void) load { return std::make_shared(); } ); + HybridObjectRegistry::registerHybridObjectConstructor( + "DiffieHellman", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridDiffieHellman\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); + HybridObjectRegistry::registerHybridObjectConstructor( + "ECDH", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridECDH\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); HybridObjectRegistry::registerHybridObjectConstructor( "EcKeyPair", []() -> std::shared_ptr { @@ -95,21 +113,21 @@ + (void) load { } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Hmac", + "Hkdf", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridHmac\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridHkdf\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Hkdf", + "Hmac", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridHkdf\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridHmac\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( @@ -121,6 +139,15 @@ + (void) load { return std::make_shared(); } ); + HybridObjectRegistry::registerHybridObjectConstructor( + "MlDsaKeyPair", + []() -> std::shared_ptr { + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! " + "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); + return std::make_shared(); + } + ); HybridObjectRegistry::registerHybridObjectConstructor( "Pbkdf2", []() -> std::shared_ptr { @@ -157,33 +184,6 @@ + (void) load { return std::make_shared(); } ); - HybridObjectRegistry::registerHybridObjectConstructor( - "SignHandle", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridSignHandle\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); - HybridObjectRegistry::registerHybridObjectConstructor( - "VerifyHandle", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridVerifyHandle\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); - HybridObjectRegistry::registerHybridObjectConstructor( - "MlDsaKeyPair", - []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! " - "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); - } - ); HybridObjectRegistry::registerHybridObjectConstructor( "Scrypt", []() -> std::shared_ptr { @@ -194,30 +194,30 @@ + (void) load { } ); HybridObjectRegistry::registerHybridObjectConstructor( - "Utils", + "SignHandle", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridUtils\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridSignHandle\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "ECDH", + "Utils", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridECDH\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridUtils\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); HybridObjectRegistry::registerHybridObjectConstructor( - "DiffieHellman", + "VerifyHandle", []() -> std::shared_ptr { - static_assert(std::is_default_constructible_v, - "The HybridObject \"HybridDiffieHellman\" is not default-constructible! " + static_assert(std::is_default_constructible_v, + "The HybridObject \"HybridVerifyHandle\" is not default-constructible! " "Create a public constructor that takes zero arguments to be able to autolink this HybridObject."); - return std::make_shared(); + return std::make_shared(); } ); } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.swift b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.swift index 998d82210..226adcf62 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.swift +++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.swift @@ -2,9 +2,13 @@ /// QuickCryptoAutolinking.swift /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// +import NitroModules + +// TODO: Use empty enums once Swift supports exporting them as namespaces +// See: https://github.com/swiftlang/swift/pull/83616 public final class QuickCryptoAutolinking { public typealias bridge = margelo.nitro.crypto.bridge.swift diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp index ab6e76697..ffa4a27f8 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp @@ -2,7 +2,7 @@ /// AsymmetricKeyType.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CipherArgs.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CipherArgs.hpp index 473a3a28a..232e0363d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CipherArgs.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CipherArgs.hpp @@ -2,7 +2,7 @@ /// CipherArgs.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -17,9 +17,18 @@ #else #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } #include #include @@ -30,7 +39,7 @@ namespace margelo::nitro::crypto { /** * A struct which can be represented as a JavaScript object (CipherArgs). */ - struct CipherArgs { + struct CipherArgs final { public: bool isCipher SWIFT_PRIVATE; std::string cipherType SWIFT_PRIVATE; @@ -41,6 +50,9 @@ namespace margelo::nitro::crypto { public: CipherArgs() = default; explicit CipherArgs(bool isCipher, std::string cipherType, std::shared_ptr cipherKey, std::shared_ptr iv, std::optional authTagLen): isCipher(isCipher), cipherType(cipherType), cipherKey(cipherKey), iv(iv), authTagLen(authTagLen) {} + + public: + friend bool operator==(const CipherArgs& lhs, const CipherArgs& rhs) = default; }; } // namespace margelo::nitro::crypto @@ -53,20 +65,20 @@ namespace margelo::nitro { static inline margelo::nitro::crypto::CipherArgs fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { jsi::Object obj = arg.asObject(runtime); return margelo::nitro::crypto::CipherArgs( - JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isCipher")), - JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "cipherType")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "cipherKey")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "iv")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "authTagLen")) + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isCipher"))), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherType"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherKey"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iv"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authTagLen"))) ); } static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::CipherArgs& arg) { jsi::Object obj(runtime); - obj.setProperty(runtime, "isCipher", JSIConverter::toJSI(runtime, arg.isCipher)); - obj.setProperty(runtime, "cipherType", JSIConverter::toJSI(runtime, arg.cipherType)); - obj.setProperty(runtime, "cipherKey", JSIConverter>::toJSI(runtime, arg.cipherKey)); - obj.setProperty(runtime, "iv", JSIConverter>::toJSI(runtime, arg.iv)); - obj.setProperty(runtime, "authTagLen", JSIConverter>::toJSI(runtime, arg.authTagLen)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "isCipher"), JSIConverter::toJSI(runtime, arg.isCipher)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "cipherType"), JSIConverter::toJSI(runtime, arg.cipherType)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "cipherKey"), JSIConverter>::toJSI(runtime, arg.cipherKey)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "iv"), JSIConverter>::toJSI(runtime, arg.iv)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "authTagLen"), JSIConverter>::toJSI(runtime, arg.authTagLen)); return obj; } static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { @@ -74,11 +86,14 @@ namespace margelo::nitro { return false; } jsi::Object obj = value.getObject(runtime); - if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isCipher"))) return false; - if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "cipherType"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "cipherKey"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "iv"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "authTagLen"))) return false; + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isCipher")))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherType")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherKey")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iv")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authTagLen")))) return false; return true; } }; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.cpp index 006e27dd0..076881af5 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.cpp @@ -2,7 +2,7 @@ /// HybridBlake3Spec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridBlake3Spec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.hpp index bf70761b4..59d18af42 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridBlake3Spec.hpp @@ -2,7 +2,7 @@ /// HybridBlake3Spec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `HybridBlake3Spec` to properly resolve imports. namespace margelo::nitro::crypto { class HybridBlake3Spec; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.cpp index d5b5525a7..cd945cf4e 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.cpp @@ -2,7 +2,7 @@ /// HybridCipherFactorySpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridCipherFactorySpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.hpp index 07c6a9f78..1af6d714b 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherFactorySpec.hpp @@ -2,7 +2,7 @@ /// HybridCipherFactorySpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.cpp index a32443c92..3c5a0ac00 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.cpp @@ -2,7 +2,7 @@ /// HybridCipherSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridCipherSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.hpp index fd86bce18..457d5cb9d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridCipherSpec.hpp @@ -2,7 +2,7 @@ /// HybridCipherSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `CipherArgs` to properly resolve imports. namespace margelo::nitro::crypto { struct CipherArgs; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.cpp index 51e5a9abd..57c1b1f63 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.cpp @@ -2,7 +2,7 @@ /// HybridDiffieHellmanSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridDiffieHellmanSpec.hpp" @@ -24,6 +24,7 @@ namespace margelo::nitro::crypto { prototype.registerHybridMethod("getPrivateKey", &HybridDiffieHellmanSpec::getPrivateKey); prototype.registerHybridMethod("setPublicKey", &HybridDiffieHellmanSpec::setPublicKey); prototype.registerHybridMethod("setPrivateKey", &HybridDiffieHellmanSpec::setPrivateKey); + prototype.registerHybridMethod("getVerifyError", &HybridDiffieHellmanSpec::getVerifyError); }); } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.hpp index ca2162ecb..667c6b51c 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridDiffieHellmanSpec.hpp @@ -2,7 +2,7 @@ /// HybridDiffieHellmanSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include @@ -59,6 +58,7 @@ namespace margelo::nitro::crypto { virtual std::shared_ptr getPrivateKey() = 0; virtual void setPublicKey(const std::shared_ptr& publicKey) = 0; virtual void setPrivateKey(const std::shared_ptr& privateKey) = 0; + virtual double getVerifyError() = 0; protected: // Hybrid Setup diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.cpp index b25dcdd99..10c3c803b 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.cpp @@ -2,7 +2,7 @@ /// HybridECDHSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridECDHSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.hpp index ab0a41578..5d0062a6d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridECDHSpec.hpp @@ -2,7 +2,7 @@ /// HybridECDHSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.cpp index 1d0fc671f..abb20916a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.cpp @@ -2,7 +2,7 @@ /// HybridEcKeyPairSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridEcKeyPairSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.hpp index cec584009..bb5c6731c 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEcKeyPairSpec.hpp @@ -2,7 +2,7 @@ /// HybridEcKeyPairSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -15,8 +15,6 @@ // Forward declaration of `KeyObject` to properly resolve imports. namespace margelo::nitro::crypto { struct KeyObject; } -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } #include #include "KeyObject.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp index 8131871c8..d53a0735a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp @@ -2,7 +2,7 @@ /// HybridEdKeyPairSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridEdKeyPairSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp index ff02f4afd..f91ea004a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp @@ -2,7 +2,7 @@ /// HybridEdKeyPairSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.cpp index 246f62924..594866841 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.cpp @@ -2,7 +2,7 @@ /// HybridHashSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridHashSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.hpp index b256c242a..3f819fe88 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHashSpec.hpp @@ -2,7 +2,7 @@ /// HybridHashSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `HybridHashSpec` to properly resolve imports. namespace margelo::nitro::crypto { class HybridHashSpec; } @@ -58,7 +56,7 @@ namespace margelo::nitro::crypto { public: // Methods virtual void createHash(const std::string& algorithm, std::optional outputLength) = 0; - virtual void update(const std::variant>& data) = 0; + virtual void update(const std::variant, std::string>& data) = 0; virtual std::shared_ptr digest(const std::optional& encoding) = 0; virtual std::shared_ptr copy(std::optional outputLength) = 0; virtual std::vector getSupportedHashAlgorithms() = 0; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.cpp index 65a3cd4c7..a4a1c5a9b 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.cpp @@ -2,7 +2,7 @@ /// HybridHkdfSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridHkdfSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.hpp index f20710d6d..c60f19bc5 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHkdfSpec.hpp @@ -2,7 +2,7 @@ /// HybridHkdfSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp index 502ab3d98..44b8d2e9a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.cpp @@ -2,7 +2,7 @@ /// HybridHmacSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridHmacSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp index 7cb335759..90b9a2b8c 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridHmacSpec.hpp @@ -2,7 +2,7 @@ /// HybridHmacSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include @@ -52,7 +51,7 @@ namespace margelo::nitro::crypto { public: // Methods virtual void createHmac(const std::string& algorithm, const std::shared_ptr& key) = 0; - virtual void update(const std::variant>& data) = 0; + virtual void update(const std::variant, std::string>& data) = 0; virtual std::shared_ptr digest() = 0; protected: diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp index 3094479c2..f6ff88c32 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp @@ -2,7 +2,7 @@ /// HybridKeyObjectHandleSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridKeyObjectHandleSpec.hpp" @@ -21,6 +21,8 @@ namespace margelo::nitro::crypto { prototype.registerHybridMethod("initECRaw", &HybridKeyObjectHandleSpec::initECRaw); prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk); prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail); + prototype.registerHybridMethod("keyEquals", &HybridKeyObjectHandleSpec::keyEquals); + prototype.registerHybridMethod("getSymmetricKeySize", &HybridKeyObjectHandleSpec::getSymmetricKeySize); }); } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp index d7ee37d8b..8a0bd49d0 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp @@ -2,7 +2,7 @@ /// HybridKeyObjectHandleSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `KFormatType` to properly resolve imports. namespace margelo::nitro::crypto { enum class KFormatType; } // Forward declaration of `KeyEncoding` to properly resolve imports. @@ -29,6 +27,8 @@ namespace margelo::nitro::crypto { enum class KeyType; } namespace margelo::nitro::crypto { enum class NamedCurve; } // Forward declaration of `KeyDetail` to properly resolve imports. namespace margelo::nitro::crypto { struct KeyDetail; } +// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports. +namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; } #include #include "KFormatType.hpp" @@ -41,6 +41,8 @@ namespace margelo::nitro::crypto { struct KeyDetail; } #include #include "NamedCurve.hpp" #include "KeyDetail.hpp" +#include +#include "HybridKeyObjectHandleSpec.hpp" namespace margelo::nitro::crypto { @@ -76,10 +78,12 @@ namespace margelo::nitro::crypto { virtual std::shared_ptr exportKey(std::optional format, std::optional type, const std::optional& cipher, const std::optional>& passphrase) = 0; virtual JWK exportJwk(const JWK& key, bool handleRsaPss) = 0; virtual AsymmetricKeyType getAsymmetricKeyType() = 0; - virtual bool init(KeyType keyType, const std::variant>& key, std::optional format, std::optional type, const std::optional>& passphrase) = 0; + virtual bool init(KeyType keyType, const std::variant, std::string>& key, std::optional format, std::optional type, const std::optional>& passphrase) = 0; virtual bool initECRaw(const std::string& namedCurve, const std::shared_ptr& keyData) = 0; virtual std::optional initJwk(const JWK& keyData, std::optional namedCurve) = 0; virtual KeyDetail keyDetail() = 0; + virtual bool keyEquals(const std::shared_ptr& other) = 0; + virtual double getSymmetricKeySize() = 0; protected: // Hybrid Setup diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.cpp index 1a5b1096f..3afa0e1d2 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.cpp @@ -2,7 +2,7 @@ /// HybridMlDsaKeyPairSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridMlDsaKeyPairSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.hpp index 97301c6a1..3f3408f8d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridMlDsaKeyPairSpec.hpp @@ -2,7 +2,7 @@ /// HybridMlDsaKeyPairSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp index e55b70549..4e8b981b0 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp @@ -2,7 +2,7 @@ /// HybridPbkdf2Spec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridPbkdf2Spec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp index 5039fd821..c00d8a424 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp @@ -2,7 +2,7 @@ /// HybridPbkdf2Spec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.cpp index 3aa10bd2f..98ae37141 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.cpp @@ -2,7 +2,7 @@ /// HybridRandomSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridRandomSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp index d769b7bdb..ec34b8e40 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp @@ -2,7 +2,7 @@ /// HybridRandomSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.cpp index bcc0dc2a7..25628b4f6 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.cpp @@ -2,7 +2,7 @@ /// HybridRsaCipherSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridRsaCipherSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.hpp index 9db5dacf9..b3486872e 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaCipherSpec.hpp @@ -2,7 +2,7 @@ /// HybridRsaCipherSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports. namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.cpp index f2885fc50..ad116c894 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.cpp @@ -2,7 +2,7 @@ /// HybridRsaKeyPairSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridRsaKeyPairSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.hpp index 3eedf5d78..c8df50e01 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRsaKeyPairSpec.hpp @@ -2,7 +2,7 @@ /// HybridRsaKeyPairSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `KeyObject` to properly resolve imports. namespace margelo::nitro::crypto { struct KeyObject; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.cpp index 5a94ad8fb..95a4e62c1 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.cpp @@ -2,7 +2,7 @@ /// HybridScryptSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridScryptSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.hpp index bd2f5531d..7a2e893e3 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridScryptSpec.hpp @@ -2,7 +2,7 @@ /// HybridScryptSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.cpp index edeb9be93..0d57b56ae 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.cpp @@ -2,7 +2,7 @@ /// HybridSignHandleSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridSignHandleSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.hpp index 5878beccd..304f10af2 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridSignHandleSpec.hpp @@ -2,7 +2,7 @@ /// HybridSignHandleSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports. namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.cpp index be2330eb5..a3cae7e48 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.cpp @@ -2,7 +2,7 @@ /// HybridUtilsSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridUtilsSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.hpp index d61a41d61..904ae0c07 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridUtilsSpec.hpp @@ -2,7 +2,7 @@ /// HybridUtilsSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,7 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } + #include diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.cpp index cc2c6b842..f2fa1a8f4 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.cpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.cpp @@ -2,7 +2,7 @@ /// HybridVerifyHandleSpec.cpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #include "HybridVerifyHandleSpec.hpp" diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.hpp index 0ff331b6e..ba5596f9f 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridVerifyHandleSpec.hpp @@ -2,7 +2,7 @@ /// HybridVerifyHandleSpec.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -13,8 +13,6 @@ #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif -// Forward declaration of `ArrayBuffer` to properly resolve imports. -namespace NitroModules { class ArrayBuffer; } // Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports. namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; } diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWK.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWK.hpp index 1d305ab4e..1473bcdc2 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWK.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWK.hpp @@ -2,7 +2,7 @@ /// JWK.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -17,6 +17,16 @@ #else #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif // Forward declaration of `JWKkty` to properly resolve imports. namespace margelo::nitro::crypto { enum class JWKkty; } @@ -37,7 +47,7 @@ namespace margelo::nitro::crypto { /** * A struct which can be represented as a JavaScript object (JWK). */ - struct JWK { + struct JWK final { public: std::optional kty SWIFT_PRIVATE; std::optional use SWIFT_PRIVATE; @@ -65,6 +75,9 @@ namespace margelo::nitro::crypto { public: JWK() = default; explicit JWK(std::optional kty, std::optional use, std::optional> key_ops, std::optional alg, std::optional crv, std::optional kid, std::optional x5u, std::optional> x5c, std::optional x5t, std::optional x5t_256, std::optional n, std::optional e, std::optional d, std::optional p, std::optional q, std::optional x, std::optional y, std::optional k, std::optional dp, std::optional dq, std::optional qi, std::optional ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), ext(ext) {} + + public: + friend bool operator==(const JWK& lhs, const JWK& rhs) = default; }; } // namespace margelo::nitro::crypto @@ -77,54 +90,54 @@ namespace margelo::nitro { static inline margelo::nitro::crypto::JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { jsi::Object obj = arg.asObject(runtime); return margelo::nitro::crypto::JWK( - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "kty")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "use")), - JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, "key_ops")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "alg")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "crv")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "kid")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "x5u")), - JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, "x5c")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "x5t")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "x5t#256")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "n")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "e")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "d")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "p")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "q")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "x")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "y")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "k")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "dp")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "dq")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "qi")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "ext")) + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "kty"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "use"))), + JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "key_ops"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "alg"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "crv"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "kid"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5u"))), + JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5c"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5t"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5t#256"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "n"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "e"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "d"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "p"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "q"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "k"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext"))) ); } static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::JWK& arg) { jsi::Object obj(runtime); - obj.setProperty(runtime, "kty", JSIConverter>::toJSI(runtime, arg.kty)); - obj.setProperty(runtime, "use", JSIConverter>::toJSI(runtime, arg.use)); - obj.setProperty(runtime, "key_ops", JSIConverter>>::toJSI(runtime, arg.key_ops)); - obj.setProperty(runtime, "alg", JSIConverter>::toJSI(runtime, arg.alg)); - obj.setProperty(runtime, "crv", JSIConverter>::toJSI(runtime, arg.crv)); - obj.setProperty(runtime, "kid", JSIConverter>::toJSI(runtime, arg.kid)); - obj.setProperty(runtime, "x5u", JSIConverter>::toJSI(runtime, arg.x5u)); - obj.setProperty(runtime, "x5c", JSIConverter>>::toJSI(runtime, arg.x5c)); - obj.setProperty(runtime, "x5t", JSIConverter>::toJSI(runtime, arg.x5t)); - obj.setProperty(runtime, "x5t#256", JSIConverter>::toJSI(runtime, arg.x5t_256)); - obj.setProperty(runtime, "n", JSIConverter>::toJSI(runtime, arg.n)); - obj.setProperty(runtime, "e", JSIConverter>::toJSI(runtime, arg.e)); - obj.setProperty(runtime, "d", JSIConverter>::toJSI(runtime, arg.d)); - obj.setProperty(runtime, "p", JSIConverter>::toJSI(runtime, arg.p)); - obj.setProperty(runtime, "q", JSIConverter>::toJSI(runtime, arg.q)); - obj.setProperty(runtime, "x", JSIConverter>::toJSI(runtime, arg.x)); - obj.setProperty(runtime, "y", JSIConverter>::toJSI(runtime, arg.y)); - obj.setProperty(runtime, "k", JSIConverter>::toJSI(runtime, arg.k)); - obj.setProperty(runtime, "dp", JSIConverter>::toJSI(runtime, arg.dp)); - obj.setProperty(runtime, "dq", JSIConverter>::toJSI(runtime, arg.dq)); - obj.setProperty(runtime, "qi", JSIConverter>::toJSI(runtime, arg.qi)); - obj.setProperty(runtime, "ext", JSIConverter>::toJSI(runtime, arg.ext)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "kty"), JSIConverter>::toJSI(runtime, arg.kty)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "use"), JSIConverter>::toJSI(runtime, arg.use)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "key_ops"), JSIConverter>>::toJSI(runtime, arg.key_ops)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "alg"), JSIConverter>::toJSI(runtime, arg.alg)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "crv"), JSIConverter>::toJSI(runtime, arg.crv)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "kid"), JSIConverter>::toJSI(runtime, arg.kid)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "x5u"), JSIConverter>::toJSI(runtime, arg.x5u)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "x5c"), JSIConverter>>::toJSI(runtime, arg.x5c)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "x5t"), JSIConverter>::toJSI(runtime, arg.x5t)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "x5t#256"), JSIConverter>::toJSI(runtime, arg.x5t_256)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "n"), JSIConverter>::toJSI(runtime, arg.n)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "e"), JSIConverter>::toJSI(runtime, arg.e)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "d"), JSIConverter>::toJSI(runtime, arg.d)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "p"), JSIConverter>::toJSI(runtime, arg.p)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "q"), JSIConverter>::toJSI(runtime, arg.q)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "x"), JSIConverter>::toJSI(runtime, arg.x)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "y"), JSIConverter>::toJSI(runtime, arg.y)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "k"), JSIConverter>::toJSI(runtime, arg.k)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "dp"), JSIConverter>::toJSI(runtime, arg.dp)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "dq"), JSIConverter>::toJSI(runtime, arg.dq)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "qi"), JSIConverter>::toJSI(runtime, arg.qi)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "ext"), JSIConverter>::toJSI(runtime, arg.ext)); return obj; } static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { @@ -132,28 +145,31 @@ namespace margelo::nitro { return false; } jsi::Object obj = value.getObject(runtime); - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "kty"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "use"))) return false; - if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, "key_ops"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "alg"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "crv"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "kid"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "x5u"))) return false; - if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, "x5c"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "x5t"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "x5t#256"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "n"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "e"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "d"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "p"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "q"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "x"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "y"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "k"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "dp"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "dq"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "qi"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "ext"))) return false; + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "kty")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "use")))) return false; + if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "key_ops")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "alg")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "crv")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "kid")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5u")))) return false; + if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5c")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5t")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x5t#256")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "n")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "e")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "d")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "p")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "q")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "k")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext")))) return false; return true; } }; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKkty.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKkty.hpp index 42226dc03..aa2d57881 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKkty.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKkty.hpp @@ -2,7 +2,7 @@ /// JWKkty.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -33,6 +33,7 @@ namespace margelo::nitro::crypto { RSA SWIFT_NAME(rsa) = 1, EC SWIFT_NAME(ec) = 2, OCT SWIFT_NAME(oct) = 3, + OKP SWIFT_NAME(okp) = 4, } CLOSED_ENUM; } // namespace margelo::nitro::crypto @@ -49,6 +50,7 @@ namespace margelo::nitro { case hashString("RSA"): return margelo::nitro::crypto::JWKkty::RSA; case hashString("EC"): return margelo::nitro::crypto::JWKkty::EC; case hashString("oct"): return margelo::nitro::crypto::JWKkty::OCT; + case hashString("OKP"): return margelo::nitro::crypto::JWKkty::OKP; default: [[unlikely]] throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKkty - invalid value!"); } @@ -59,6 +61,7 @@ namespace margelo::nitro { case margelo::nitro::crypto::JWKkty::RSA: return JSIConverter::toJSI(runtime, "RSA"); case margelo::nitro::crypto::JWKkty::EC: return JSIConverter::toJSI(runtime, "EC"); case margelo::nitro::crypto::JWKkty::OCT: return JSIConverter::toJSI(runtime, "oct"); + case margelo::nitro::crypto::JWKkty::OKP: return JSIConverter::toJSI(runtime, "OKP"); default: [[unlikely]] throw std::invalid_argument("Cannot convert JWKkty to JS - invalid value: " + std::to_string(static_cast(arg)) + "!"); @@ -74,6 +77,7 @@ namespace margelo::nitro { case hashString("RSA"): case hashString("EC"): case hashString("oct"): + case hashString("OKP"): return true; default: return false; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKuse.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKuse.hpp index e1ecf0800..eb4c63f5d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKuse.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/JWKuse.hpp @@ -2,7 +2,7 @@ /// JWKuse.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KFormatType.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KFormatType.hpp index 31bec4dc0..0180104c1 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KFormatType.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KFormatType.hpp @@ -2,7 +2,7 @@ /// KFormatType.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyDetail.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyDetail.hpp index e3fb4fc86..4ec385c79 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyDetail.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyDetail.hpp @@ -2,7 +2,7 @@ /// KeyDetail.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -17,6 +17,16 @@ #else #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif @@ -28,7 +38,7 @@ namespace margelo::nitro::crypto { /** * A struct which can be represented as a JavaScript object (KeyDetail). */ - struct KeyDetail { + struct KeyDetail final { public: std::optional length SWIFT_PRIVATE; std::optional publicExponent SWIFT_PRIVATE; @@ -41,6 +51,9 @@ namespace margelo::nitro::crypto { public: KeyDetail() = default; explicit KeyDetail(std::optional length, std::optional publicExponent, std::optional modulusLength, std::optional hashAlgorithm, std::optional mgf1HashAlgorithm, std::optional saltLength, std::optional namedCurve): length(length), publicExponent(publicExponent), modulusLength(modulusLength), hashAlgorithm(hashAlgorithm), mgf1HashAlgorithm(mgf1HashAlgorithm), saltLength(saltLength), namedCurve(namedCurve) {} + + public: + friend bool operator==(const KeyDetail& lhs, const KeyDetail& rhs) = default; }; } // namespace margelo::nitro::crypto @@ -53,24 +66,24 @@ namespace margelo::nitro { static inline margelo::nitro::crypto::KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { jsi::Object obj = arg.asObject(runtime); return margelo::nitro::crypto::KeyDetail( - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "length")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "publicExponent")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "modulusLength")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "hashAlgorithm")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "mgf1HashAlgorithm")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "saltLength")), - JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "namedCurve")) + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "length"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "publicExponent"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "modulusLength"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hashAlgorithm"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mgf1HashAlgorithm"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "saltLength"))), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "namedCurve"))) ); } static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::KeyDetail& arg) { jsi::Object obj(runtime); - obj.setProperty(runtime, "length", JSIConverter>::toJSI(runtime, arg.length)); - obj.setProperty(runtime, "publicExponent", JSIConverter>::toJSI(runtime, arg.publicExponent)); - obj.setProperty(runtime, "modulusLength", JSIConverter>::toJSI(runtime, arg.modulusLength)); - obj.setProperty(runtime, "hashAlgorithm", JSIConverter>::toJSI(runtime, arg.hashAlgorithm)); - obj.setProperty(runtime, "mgf1HashAlgorithm", JSIConverter>::toJSI(runtime, arg.mgf1HashAlgorithm)); - obj.setProperty(runtime, "saltLength", JSIConverter>::toJSI(runtime, arg.saltLength)); - obj.setProperty(runtime, "namedCurve", JSIConverter>::toJSI(runtime, arg.namedCurve)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "length"), JSIConverter>::toJSI(runtime, arg.length)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "publicExponent"), JSIConverter>::toJSI(runtime, arg.publicExponent)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "modulusLength"), JSIConverter>::toJSI(runtime, arg.modulusLength)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "hashAlgorithm"), JSIConverter>::toJSI(runtime, arg.hashAlgorithm)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "mgf1HashAlgorithm"), JSIConverter>::toJSI(runtime, arg.mgf1HashAlgorithm)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "saltLength"), JSIConverter>::toJSI(runtime, arg.saltLength)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "namedCurve"), JSIConverter>::toJSI(runtime, arg.namedCurve)); return obj; } static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { @@ -78,13 +91,16 @@ namespace margelo::nitro { return false; } jsi::Object obj = value.getObject(runtime); - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "length"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "publicExponent"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "modulusLength"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "hashAlgorithm"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "mgf1HashAlgorithm"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "saltLength"))) return false; - if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "namedCurve"))) return false; + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "length")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "publicExponent")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "modulusLength")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hashAlgorithm")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mgf1HashAlgorithm")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "saltLength")))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "namedCurve")))) return false; return true; } }; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyEncoding.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyEncoding.hpp index 83dc16473..430aa395a 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyEncoding.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyEncoding.hpp @@ -2,7 +2,7 @@ /// KeyEncoding.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyObject.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyObject.hpp index e27d4ff95..92925f888 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyObject.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyObject.hpp @@ -2,7 +2,7 @@ /// KeyObject.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once @@ -17,6 +17,16 @@ #else #error NitroModules cannot be found! Are you sure you installed NitroModules properly? #endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif @@ -27,13 +37,16 @@ namespace margelo::nitro::crypto { /** * A struct which can be represented as a JavaScript object (KeyObject). */ - struct KeyObject { + struct KeyObject final { public: bool extractable SWIFT_PRIVATE; public: KeyObject() = default; explicit KeyObject(bool extractable): extractable(extractable) {} + + public: + friend bool operator==(const KeyObject& lhs, const KeyObject& rhs) = default; }; } // namespace margelo::nitro::crypto @@ -46,12 +59,12 @@ namespace margelo::nitro { static inline margelo::nitro::crypto::KeyObject fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { jsi::Object obj = arg.asObject(runtime); return margelo::nitro::crypto::KeyObject( - JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "extractable")) + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "extractable"))) ); } static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::KeyObject& arg) { jsi::Object obj(runtime); - obj.setProperty(runtime, "extractable", JSIConverter::toJSI(runtime, arg.extractable)); + obj.setProperty(runtime, PropNameIDCache::get(runtime, "extractable"), JSIConverter::toJSI(runtime, arg.extractable)); return obj; } static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { @@ -59,7 +72,10 @@ namespace margelo::nitro { return false; } jsi::Object obj = value.getObject(runtime); - if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "extractable"))) return false; + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "extractable")))) return false; return true; } }; diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyType.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyType.hpp index c5a44b4cd..05652c106 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyType.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyType.hpp @@ -2,7 +2,7 @@ /// KeyType.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyUsage.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyUsage.hpp index 0c7dfc6f5..119552a63 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyUsage.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/KeyUsage.hpp @@ -2,7 +2,7 @@ /// KeyUsage.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/NamedCurve.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/NamedCurve.hpp index ed2745ad7..03f64cc7d 100644 --- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/NamedCurve.hpp +++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/NamedCurve.hpp @@ -2,7 +2,7 @@ /// NamedCurve.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro -/// Copyright © 2025 Marc Rousavy @ Margelo +/// Copyright © Marc Rousavy @ Margelo /// #pragma once diff --git a/packages/react-native-quick-crypto/src/diffie-hellman.ts b/packages/react-native-quick-crypto/src/diffie-hellman.ts index af94132b5..84ea8e682 100644 --- a/packages/react-native-quick-crypto/src/diffie-hellman.ts +++ b/packages/react-native-quick-crypto/src/diffie-hellman.ts @@ -111,6 +111,10 @@ export class DiffieHellman { } this._hybrid.setPrivateKey(keyBuf.buffer as ArrayBuffer); } + + get verifyError(): number { + return this._hybrid.getVerifyError(); + } } export function createDiffieHellman( @@ -189,3 +193,5 @@ export function getDiffieHellman(groupName: string): DiffieHellman { // group.prime and group.generator are hex strings return new DiffieHellman(group.prime, group.generator, 'hex'); } + +export { getDiffieHellman as createDiffieHellmanGroup }; diff --git a/packages/react-native-quick-crypto/src/hash.ts b/packages/react-native-quick-crypto/src/hash.ts index cc0f3b58e..583c8bc90 100644 --- a/packages/react-native-quick-crypto/src/hash.ts +++ b/packages/react-native-quick-crypto/src/hash.ts @@ -272,8 +272,19 @@ const internalDigest = ( return arrayBuffer; }; +export function hash( + algorithm: string, + data: BinaryLike, + outputEncoding?: Encoding, +): string | Buffer { + const h = createHash(algorithm); + h.update(data); + return outputEncoding ? h.digest(outputEncoding) : h.digest(); +} + export const hashExports = { createHash, getHashes, + hash, asyncDigest, }; diff --git a/packages/react-native-quick-crypto/src/keys/classes.ts b/packages/react-native-quick-crypto/src/keys/classes.ts index d8414c9e2..c03797b24 100644 --- a/packages/react-native-quick-crypto/src/keys/classes.ts +++ b/packages/react-native-quick-crypto/src/keys/classes.ts @@ -89,6 +89,13 @@ export class KeyObject { throw new Error('export() must be implemented by subclasses'); } + equals(otherKeyObject: KeyObject): boolean { + if (!(otherKeyObject instanceof KeyObject)) { + throw new TypeError('otherKeyObject must be a KeyObject'); + } + return this.handle.keyEquals(otherKeyObject.handle); + } + constructor(type: string, handle: KeyObjectHandle); constructor(type: string, key: ArrayBuffer); constructor(type: string, handleOrKey: KeyObjectHandle | ArrayBuffer) { @@ -197,9 +204,9 @@ export class SecretKeyObject extends KeyObject { super('secret', handle); } - // get symmetricKeySize() { - // return this.handle.getSymmetricKeySize(); - // } + get symmetricKeySize(): number { + return this.handle.getSymmetricKeySize(); + } export(options: { format: 'pem' } & EncodingOptions): never; export(options: { format: 'der' } & EncodingOptions): Buffer; diff --git a/packages/react-native-quick-crypto/src/specs/diffie-hellman.nitro.ts b/packages/react-native-quick-crypto/src/specs/diffie-hellman.nitro.ts index f07bdf3e1..afcb8a369 100644 --- a/packages/react-native-quick-crypto/src/specs/diffie-hellman.nitro.ts +++ b/packages/react-native-quick-crypto/src/specs/diffie-hellman.nitro.ts @@ -12,4 +12,5 @@ export interface DiffieHellman getPrivateKey(): ArrayBuffer; setPublicKey(publicKey: ArrayBuffer): void; setPrivateKey(privateKey: ArrayBuffer): void; + getVerifyError(): number; } diff --git a/packages/react-native-quick-crypto/src/specs/keyObjectHandle.nitro.ts b/packages/react-native-quick-crypto/src/specs/keyObjectHandle.nitro.ts index 08019c233..9ed0155ee 100644 --- a/packages/react-native-quick-crypto/src/specs/keyObjectHandle.nitro.ts +++ b/packages/react-native-quick-crypto/src/specs/keyObjectHandle.nitro.ts @@ -29,4 +29,6 @@ export interface KeyObjectHandle initECRaw(namedCurve: string, keyData: ArrayBuffer): boolean; initJwk(keyData: JWK, namedCurve?: NamedCurve): KeyType | undefined; keyDetail(): KeyDetail; + keyEquals(other: KeyObjectHandle): boolean; + getSymmetricKeySize(): number; } diff --git a/packages/react-native-quick-crypto/src/subtle.ts b/packages/react-native-quick-crypto/src/subtle.ts index 23bdd610e..571d8d3d9 100644 --- a/packages/react-native-quick-crypto/src/subtle.ts +++ b/packages/react-native-quick-crypto/src/subtle.ts @@ -17,7 +17,7 @@ import type { RsaOaepParams, ChaCha20Poly1305Params, } from './utils'; -import { KFormatType, KeyEncoding } from './utils'; +import { KFormatType, KeyEncoding, KeyType } from './utils'; import { CryptoKey, KeyObject, @@ -891,7 +891,7 @@ async function aesImportKey( function edImportKey( format: ImportFormat, - data: BufferLike, + data: BufferLike | JWK, algorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[], @@ -915,7 +915,7 @@ function edImportKey( if (format === 'spki') { // Import public key - const keyData = bufferLikeToArrayBuffer(data); + const keyData = bufferLikeToArrayBuffer(data as BufferLike); keyObject = KeyObject.createKeyObject( 'public', keyData, @@ -924,7 +924,7 @@ function edImportKey( ); } else if (format === 'pkcs8') { // Import private key - const keyData = bufferLikeToArrayBuffer(data); + const keyData = bufferLikeToArrayBuffer(data as BufferLike); keyObject = KeyObject.createKeyObject( 'private', keyData, @@ -933,13 +933,26 @@ function edImportKey( ); } else if (format === 'raw') { // Raw format - public key only for Ed keys - const keyData = bufferLikeToArrayBuffer(data); + const keyData = bufferLikeToArrayBuffer(data as BufferLike); const handle = NitroModules.createHybridObject('KeyObjectHandle'); // For raw Ed keys, we need to create them differently // Raw public keys are just the key bytes handle.init(1, keyData); // 1 = public key type keyObject = new PublicKeyObject(handle); + } else if (format === 'jwk') { + const jwkData = data as JWK; + const handle = + NitroModules.createHybridObject('KeyObjectHandle'); + const keyType = handle.initJwk(jwkData); + if (keyType === undefined) { + throw lazyDOMException('Invalid JWK data', 'DataError'); + } + if (keyType === KeyType.PRIVATE) { + keyObject = new PrivateKeyObject(handle); + } else { + keyObject = new PublicKeyObject(handle); + } } else { throw lazyDOMException( `Unsupported format for ${name} import: ${format}`, @@ -1177,6 +1190,14 @@ const exportKeyJWK = (key: CryptoKey): ArrayBuffer | unknown => { case 'ECDH': jwk.crv ||= key.algorithm.namedCurve; return jwk; + case 'Ed25519': + // Fall through + case 'Ed448': + // Fall through + case 'X25519': + // Fall through + case 'X448': + return jwk; case 'AES-CTR': // Fall through case 'AES-CBC': @@ -1613,6 +1634,9 @@ export class Subtle { case 'X448': derivedBits = await xDeriveBits(algorithm, baseKey, length); break; + case 'ECDH': + derivedBits = await ecDeriveBits(algorithm, baseKey, length); + break; case 'HKDF': derivedBits = hkdfDeriveBits( algorithm as unknown as HkdfAlgorithm, @@ -1969,7 +1993,7 @@ export class Subtle { case 'Ed448': result = edImportKey( format, - data as BufferLike, + data as BufferLike | JWK, normalizedAlgorithm, extractable, keyUsages, diff --git a/packages/react-native-quick-crypto/src/utils/types.ts b/packages/react-native-quick-crypto/src/utils/types.ts index 4d84032af..f8b94a6d2 100644 --- a/packages/react-native-quick-crypto/src/utils/types.ts +++ b/packages/react-native-quick-crypto/src/utils/types.ts @@ -265,7 +265,7 @@ export type AsymmetricKeyType = | CFRGKeyPairType | PQCKeyPairType; -type JWKkty = 'AES' | 'RSA' | 'EC' | 'oct'; +type JWKkty = 'AES' | 'RSA' | 'EC' | 'oct' | 'OKP'; type JWKuse = 'sig' | 'enc'; export interface JWK {