react-native-quick-crypto
Version:
A fast implementation of Node's `crypto` module written in C/C++ JSI
381 lines (374 loc) • 12.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "AsymmetricKeyObject", {
enumerable: true,
get: function () {
return _classes.AsymmetricKeyObject;
}
});
Object.defineProperty(exports, "CryptoKey", {
enumerable: true,
get: function () {
return _classes.CryptoKey;
}
});
Object.defineProperty(exports, "KeyObject", {
enumerable: true,
get: function () {
return _classes.KeyObject;
}
});
Object.defineProperty(exports, "PrivateKeyObject", {
enumerable: true,
get: function () {
return _classes.PrivateKeyObject;
}
});
Object.defineProperty(exports, "PublicKeyObject", {
enumerable: true,
get: function () {
return _classes.PublicKeyObject;
}
});
Object.defineProperty(exports, "SecretKeyObject", {
enumerable: true,
get: function () {
return _classes.SecretKeyObject;
}
});
Object.defineProperty(exports, "Sign", {
enumerable: true,
get: function () {
return _signVerify.Sign;
}
});
Object.defineProperty(exports, "Verify", {
enumerable: true,
get: function () {
return _signVerify.Verify;
}
});
exports.createPrivateKey = createPrivateKey;
exports.createPublicKey = createPublicKey;
exports.createSecretKey = createSecretKey;
Object.defineProperty(exports, "createSign", {
enumerable: true,
get: function () {
return _signVerify.createSign;
}
});
Object.defineProperty(exports, "createVerify", {
enumerable: true,
get: function () {
return _signVerify.createVerify;
}
});
exports.generateKey = generateKey;
Object.defineProperty(exports, "generateKeyPair", {
enumerable: true,
get: function () {
return _generateKeyPair.generateKeyPair;
}
});
Object.defineProperty(exports, "generateKeyPairSync", {
enumerable: true,
get: function () {
return _generateKeyPair.generateKeyPairSync;
}
});
exports.generateKeySync = generateKeySync;
Object.defineProperty(exports, "isCryptoKey", {
enumerable: true,
get: function () {
return _utils.isCryptoKey;
}
});
Object.defineProperty(exports, "parseKeyEncoding", {
enumerable: true,
get: function () {
return _utils.parseKeyEncoding;
}
});
Object.defineProperty(exports, "parsePrivateKeyEncoding", {
enumerable: true,
get: function () {
return _utils.parsePrivateKeyEncoding;
}
});
Object.defineProperty(exports, "parsePublicKeyEncoding", {
enumerable: true,
get: function () {
return _utils.parsePublicKeyEncoding;
}
});
Object.defineProperty(exports, "privateDecrypt", {
enumerable: true,
get: function () {
return _publicCipher.privateDecrypt;
}
});
Object.defineProperty(exports, "privateEncrypt", {
enumerable: true,
get: function () {
return _publicCipher.privateEncrypt;
}
});
Object.defineProperty(exports, "publicDecrypt", {
enumerable: true,
get: function () {
return _publicCipher.publicDecrypt;
}
});
Object.defineProperty(exports, "publicEncrypt", {
enumerable: true,
get: function () {
return _publicCipher.publicEncrypt;
}
});
Object.defineProperty(exports, "sign", {
enumerable: true,
get: function () {
return _signVerify.sign;
}
});
Object.defineProperty(exports, "verify", {
enumerable: true,
get: function () {
return _signVerify.verify;
}
});
var _classes = require("./classes");
var _generateKeyPair = require("./generateKeyPair");
var _signVerify = require("./signVerify");
var _publicCipher = require("./publicCipher");
var _utils = require("./utils");
var _reactNativeNitroModules = require("react-native-nitro-modules");
var _utils2 = require("../utils");
var _random = require("../random");
function isRawFormat(format) {
return format === 'raw-public' || format === 'raw-private' || format === 'raw-seed';
}
function createPublicKeyFromRaw(input) {
if (input.format !== 'raw-public') {
throw new Error('Invalid format for createPublicKey raw import');
}
if (typeof input.asymmetricKeyType !== 'string') {
throw new Error('options.asymmetricKeyType is required for raw key import');
}
if (input.asymmetricKeyType === 'ec' && !input.namedCurve) {
throw new Error('options.namedCurve is required for EC raw key import');
}
const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
handle.initRawPublic(input.asymmetricKeyType, (0, _utils2.binaryLikeToArrayBuffer)(input.key), input.namedCurve);
return new _classes.PublicKeyObject(handle);
}
function createPrivateKeyFromRaw(input) {
if (input.format !== 'raw-private' && input.format !== 'raw-seed') {
throw new Error('Invalid format for createPrivateKey raw import');
}
if (typeof input.asymmetricKeyType !== 'string') {
throw new Error('options.asymmetricKeyType is required for raw key import');
}
if (input.asymmetricKeyType === 'ec' && !input.namedCurve) {
throw new Error('options.namedCurve is required for EC raw key import');
}
const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
if (input.format === 'raw-seed') {
handle.initRawSeed(input.asymmetricKeyType, (0, _utils2.binaryLikeToArrayBuffer)(input.key));
} else {
handle.initRawPrivate(input.asymmetricKeyType, (0, _utils2.binaryLikeToArrayBuffer)(input.key), input.namedCurve);
}
return new _classes.PrivateKeyObject(handle);
}
function createSecretKey(key) {
const keyBuffer = (0, _utils2.binaryLikeToArrayBuffer)(key);
return _classes.KeyObject.createKeyObject('secret', keyBuffer);
}
function prepareAsymmetricKey(key, isPublic) {
if (key instanceof _classes.KeyObject) {
if (isPublic) {
// createPublicKey can accept either a public key or extract public from private
if (key.type === 'secret') {
throw new Error('Cannot create public key from secret key');
}
// Export as SPKI (public key format) - works for both public and private keys
const exported = key.handle.exportKey(_utils2.KFormatType.DER, _utils2.KeyEncoding.SPKI);
return {
data: exported,
format: 'der',
type: 'spki'
};
} else {
// createPrivateKey requires a private key
if (key.type !== 'private') {
throw new Error('Key must be a private key');
}
const exported = key.handle.exportKey(_utils2.KFormatType.DER, _utils2.KeyEncoding.PKCS8);
return {
data: exported,
format: 'der',
type: 'pkcs8'
};
}
}
if ((0, _utils.isCryptoKey)(key)) {
const cryptoKey = key;
return prepareAsymmetricKey(cryptoKey.keyObject, isPublic);
}
if ((0, _utils2.isStringOrBuffer)(key)) {
// Detect PEM format from string content
const isPem = typeof key === 'string' && key.includes('-----BEGIN');
return {
data: (0, _utils2.binaryLikeToArrayBuffer)(key),
format: isPem ? 'pem' : undefined
};
}
if (typeof key === 'object' && 'key' in key) {
const keyObj = key;
const {
key: data,
format,
type,
passphrase
} = keyObj;
const passphraseAB = passphrase !== undefined ? (0, _utils2.binaryLikeToArrayBuffer)(passphrase) : undefined;
if (data instanceof _classes.KeyObject) {
return prepareAsymmetricKey(data, isPublic);
}
if ((0, _utils.isCryptoKey)(data)) {
return prepareAsymmetricKey(data.keyObject, isPublic);
}
if (!(0, _utils2.isStringOrBuffer)(data)) {
throw new Error('Invalid key data type');
}
// For PEM format with string data, convert to ArrayBuffer
if ((format === 'pem' || typeof data === 'string' && data.includes('-----BEGIN')) && typeof data === 'string') {
return {
data: (0, _utils2.binaryLikeToArrayBuffer)(data),
format: 'pem',
type,
passphrase: passphraseAB
};
}
// Filter to only 'pem' or 'der' — JWK and raw formats are handled
// separately via dedicated paths.
const filteredFormat = format === 'pem' || format === 'der' ? format : undefined;
return {
data: (0, _utils2.binaryLikeToArrayBuffer)(data),
format: filteredFormat,
type,
passphrase: passphraseAB
};
}
throw new Error('Invalid key input');
}
function createPublicKey(key) {
if (typeof key === 'object' && 'key' in key && isRawFormat(key.format)) {
if (key.format !== 'raw-public') {
throw new Error(`Invalid format ${key.format} for createPublicKey — only 'raw-public' is allowed`);
}
return createPublicKeyFromRaw(key);
}
if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
const keyType = handle.initJwk(key.key);
if (keyType === undefined) {
throw new Error('Failed to import JWK');
}
if (keyType === _utils2.KeyType.PRIVATE) {
// Extract public from private
const exported = handle.exportKey(_utils2.KFormatType.DER, _utils2.KeyEncoding.SPKI);
const pubHandle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
pubHandle.init(_utils2.KeyType.PUBLIC, exported, _utils2.KFormatType.DER, _utils2.KeyEncoding.SPKI);
return new _classes.PublicKeyObject(pubHandle);
}
return new _classes.PublicKeyObject(handle);
}
const {
data,
format,
type,
passphrase
} = prepareAsymmetricKey(key, true);
// Map format string to KFormatType enum
let kFormat;
if (format === 'pem') kFormat = _utils2.KFormatType.PEM;else if (format === 'der') kFormat = _utils2.KFormatType.DER;
// Map type string to KeyEncoding enum
let kType;
if (type === 'spki') kType = _utils2.KeyEncoding.SPKI;else if (type === 'pkcs1') kType = _utils2.KeyEncoding.PKCS1;
return _classes.KeyObject.createKeyObject('public', data, kFormat, kType, passphrase);
}
function createPrivateKey(key) {
if (typeof key === 'object' && 'key' in key && isRawFormat(key.format)) {
if (key.format === 'raw-public') {
throw new Error("Invalid format 'raw-public' for createPrivateKey");
}
return createPrivateKeyFromRaw(key);
}
if (typeof key === 'object' && 'key' in key && key.format === 'jwk') {
const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
const keyType = handle.initJwk(key.key);
if (keyType === undefined || keyType !== _utils2.KeyType.PRIVATE) {
throw new Error('Failed to import private key from JWK');
}
return new _classes.PrivateKeyObject(handle);
}
const {
data,
format,
type,
passphrase
} = prepareAsymmetricKey(key, false);
// Map format string to KFormatType enum
let kFormat;
if (format === 'pem') kFormat = _utils2.KFormatType.PEM;else if (format === 'der') kFormat = _utils2.KFormatType.DER;
// Map type string to KeyEncoding enum
let kType;
if (type === 'pkcs8') kType = _utils2.KeyEncoding.PKCS8;else if (type === 'pkcs1') kType = _utils2.KeyEncoding.PKCS1;else if (type === 'sec1') kType = _utils2.KeyEncoding.SEC1;
return _classes.KeyObject.createKeyObject('private', data, kFormat, kType, passphrase);
}
function generateKeySync(type, options) {
if (typeof type !== 'string') {
throw new TypeError('The "type" argument must be a string');
}
if (typeof options !== 'object' || options === null) {
throw new TypeError('The "options" argument must be an object');
}
const {
length
} = options;
if (typeof length !== 'number' || !Number.isInteger(length)) {
throw new TypeError('The "options.length" property must be an integer');
}
switch (type) {
case 'hmac':
if (length < 8 || length > 2 ** 31 - 1) {
throw new RangeError('The "options.length" property must be >= 8 and <= 2147483647');
}
break;
case 'aes':
if (length !== 128 && length !== 192 && length !== 256) {
throw new RangeError('The "options.length" property must be 128, 192, or 256');
}
break;
default:
throw new TypeError(`The "type" argument must be 'aes' or 'hmac'. Received '${type}'`);
}
const keyBytes = length / 8;
const keyMaterial = (0, _random.randomBytes)(keyBytes);
return createSecretKey(keyMaterial);
}
function generateKey(type, options, callback) {
if (typeof callback !== 'function') {
throw new TypeError('The "callback" argument must be a function');
}
try {
const key = generateKeySync(type, options);
process.nextTick(callback, null, key);
} catch (err) {
process.nextTick(callback, err);
}
}
//# sourceMappingURL=index.js.map