@avieldr/react-native-rsa 1.0.0

package/lib/module/encoding.js

@@ -0,0 +1,116 @@
+"use strict";
+
+/**
+ * Pure-JS UTF-8 ↔ Base64 encoding utilities.
+ *
+ * These work in all React Native JS engines (Hermes, JSC) without
+ * external dependencies. They handle full Unicode including surrogate pairs.
+ *
+ * Used by the public API to convert UTF-8 input strings to base64
+ * before sending them across the native bridge.
+ */
+
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+/**
+ * Encode a UTF-8 string to base64.
+ *
+ * Steps:
+ *   1. Convert the JS string (UTF-16) to UTF-8 byte values
+ *   2. Encode those bytes as base64
+ *
+ * Handles multi-byte characters and surrogate pairs correctly.
+ */
+export function utf8ToBase64(str) {
+  // Step 1: UTF-16 string → UTF-8 byte array
+  const bytes = [];
+  for (let i = 0; i < str.length; i++) {
+    let codePoint = str.codePointAt(i);
+    // Skip the low surrogate of a surrogate pair (codePointAt already decoded it)
+    if (codePoint > 0xffff) {
+      i++;
+    }
+    if (codePoint < 0x80) {
+      // 1-byte: ASCII (0xxxxxxx)
+      bytes.push(codePoint);
+    } else if (codePoint < 0x800) {
+      // 2-byte: (110xxxxx 10xxxxxx)
+      bytes.push(0xc0 | codePoint >> 6, 0x80 | codePoint & 0x3f);
+    } else if (codePoint < 0x10000) {
+      // 3-byte: (1110xxxx 10xxxxxx 10xxxxxx)
+      bytes.push(0xe0 | codePoint >> 12, 0x80 | codePoint >> 6 & 0x3f, 0x80 | codePoint & 0x3f);
+    } else {
+      // 4-byte: (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx) — for emoji, etc.
+      bytes.push(0xf0 | codePoint >> 18, 0x80 | codePoint >> 12 & 0x3f, 0x80 | codePoint >> 6 & 0x3f, 0x80 | codePoint & 0x3f);
+    }
+  }
+
+  // Step 2: Byte array → Base64 string (3 bytes per group → 4 base64 chars)
+  let result = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    result += BASE64_CHARS[a >> 2];
+    result += BASE64_CHARS[(a & 3) << 4 | b >> 4];
+    result += i + 1 < bytes.length ? BASE64_CHARS[(b & 0xf) << 2 | c >> 6] : '=';
+    result += i + 2 < bytes.length ? BASE64_CHARS[c & 0x3f] : '=';
+  }
+  return result;
+}
+
+/**
+ * Decode a base64 string to a UTF-8 string.
+ *
+ * Steps:
+ *   1. Decode base64 → raw byte values
+ *   2. Interpret those bytes as UTF-8 and build a JS string
+ *
+ * Useful for reading decrypted plaintext that was originally UTF-8 text.
+ */
+export function base64ToUtf8(base64) {
+  // Step 1: Base64 string → byte array
+  const cleaned = base64.replace(/[^A-Za-z0-9+/=]/g, '');
+  const bytes = [];
+  for (let i = 0; i < cleaned.length; i += 4) {
+    const a = BASE64_CHARS.indexOf(cleaned[i]);
+    const b = BASE64_CHARS.indexOf(cleaned[i + 1]);
+    const c = cleaned[i + 2] === '=' ? 0 : BASE64_CHARS.indexOf(cleaned[i + 2]);
+    const d = cleaned[i + 3] === '=' ? 0 : BASE64_CHARS.indexOf(cleaned[i + 3]);
+    const bits = a << 18 | b << 12 | c << 6 | d;
+    bytes.push(bits >> 16 & 0xff);
+    if (cleaned[i + 2] !== '=') {
+      bytes.push(bits >> 8 & 0xff);
+    }
+    if (cleaned[i + 3] !== '=') {
+      bytes.push(bits & 0xff);
+    }
+  }
+
+  // Step 2: UTF-8 byte array → JS string
+  let str = '';
+  let idx = 0;
+  while (idx < bytes.length) {
+    const byte = bytes[idx];
+    if (byte < 0x80) {
+      // 1-byte: ASCII
+      str += String.fromCodePoint(byte);
+      idx++;
+    } else if ((byte & 0xe0) === 0xc0) {
+      // 2-byte character
+      str += String.fromCodePoint((byte & 0x1f) << 6 | bytes[idx + 1] & 0x3f);
+      idx += 2;
+    } else if ((byte & 0xf0) === 0xe0) {
+      // 3-byte character
+      str += String.fromCodePoint((byte & 0x0f) << 12 | (bytes[idx + 1] & 0x3f) << 6 | bytes[idx + 2] & 0x3f);
+      idx += 3;
+    } else {
+      // 4-byte character (emoji, etc.)
+      const codePoint = (byte & 0x07) << 18 | (bytes[idx + 1] & 0x3f) << 12 | (bytes[idx + 2] & 0x3f) << 6 | bytes[idx + 3] & 0x3f;
+      str += String.fromCodePoint(codePoint);
+      idx += 4;
+    }
+  }
+  return str;
+}
+//# sourceMappingURL=encoding.js.map

package/lib/module/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BASE64_CHARS","utf8ToBase64","str","bytes","i","length","codePoint","codePointAt","push","result","a","b","c","base64ToUtf8","base64","cleaned","replace","indexOf","d","bits","idx","byte","String","fromCodePoint"],"sourceRoot":"../../src","sources":["encoding.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/errors.js

@@ -0,0 +1,135 @@
+"use strict";
+
+import { VALID_KEY_SIZES } from "./constants.js";
+
+/**
+ * Error codes thrown by @avieldr/react-native-rsa.
+ *
+ * Validation errors (thrown before native call):
+ *   - INVALID_INPUT: Required parameter is missing or empty
+ *   - INVALID_KEY: Key format is wrong or key type mismatch
+ *   - INVALID_KEY_SIZE: Unsupported key size
+ *   - INVALID_PADDING: Unknown padding mode
+ *   - INVALID_HASH: Unknown hash algorithm
+ *   - INVALID_FORMAT: Unknown key format
+ *   - INVALID_ENCODING: Unknown encoding type
+ *
+ * Native operation errors (thrown by platform crypto):
+ *   - KEY_GENERATION_FAILED: Native key generation failed
+ *   - KEY_EXTRACTION_FAILED: Failed to extract public key from private
+ *   - KEY_CONVERSION_FAILED: Failed to convert key format
+ *   - ENCRYPTION_FAILED: Native encryption operation failed
+ *   - DECRYPTION_FAILED: Native decryption operation failed
+ *   - SIGNING_FAILED: Native signing operation failed
+ *   - VERIFICATION_FAILED: Native signature verification failed
+ */
+
+/**
+ * Error thrown by @avieldr/react-native-rsa for invalid inputs or native failures.
+ * Extends Error with a `code` property for programmatic handling.
+ */
+export class RsaError extends Error {
+  /** The original error from the native layer, if any */
+
+  constructor(code, message, cause) {
+    super(message);
+    this.name = 'RsaError';
+    this.code = code;
+    this.cause = cause;
+  }
+}
+
+/**
+ * Map of native error codes to RsaErrorCode.
+ * Native modules reject with codes like "RSAEncryptError" — we normalize them.
+ */
+const NATIVE_ERROR_CODE_MAP = {
+  RSAKeyGenerationError: 'KEY_GENERATION_FAILED',
+  RSAKeyExtractionError: 'KEY_EXTRACTION_FAILED',
+  RSAConvertKeyError: 'KEY_CONVERSION_FAILED',
+  RSAEncryptError: 'ENCRYPTION_FAILED',
+  RSADecryptError: 'DECRYPTION_FAILED',
+  RSASignError: 'SIGNING_FAILED',
+  RSAVerifyError: 'VERIFICATION_FAILED'
+};
+
+/**
+ * Wrap a native error into an RsaError with a normalized code.
+ * If the error is already an RsaError, returns it unchanged.
+ */
+export function wrapNativeError(error, fallbackCode) {
+  if (error instanceof RsaError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    // React Native errors from native modules have a `code` property
+    const nativeCode = error.code;
+    const code = nativeCode && NATIVE_ERROR_CODE_MAP[nativeCode] || fallbackCode;
+    return new RsaError(code, error.message, error);
+  }
+
+  // Unknown error type
+  return new RsaError(fallbackCode, String(error));
+}
+
+// --- Validation helpers ---
+
+export function requireString(value, name) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new RsaError('INVALID_INPUT', `'${name}' must be a non-empty string`);
+  }
+}
+export function requirePrivateKey(pem) {
+  requireString(pem, 'privateKey');
+  if (pem.includes('BEGIN PUBLIC KEY')) {
+    throw new RsaError('INVALID_KEY', 'Expected a private key (BEGIN RSA PRIVATE KEY or BEGIN PRIVATE KEY), but received a public key');
+  }
+  if (!pem.includes('BEGIN RSA PRIVATE KEY') && !pem.includes('BEGIN PRIVATE KEY')) {
+    throw new RsaError('INVALID_KEY', 'Expected a private key (BEGIN RSA PRIVATE KEY or BEGIN PRIVATE KEY)');
+  }
+}
+export function requirePublicKey(pem) {
+  requireString(pem, 'publicKey');
+  if (pem.includes('BEGIN RSA PRIVATE KEY') || pem.includes('BEGIN PRIVATE KEY')) {
+    throw new RsaError('INVALID_KEY', 'Expected a public key (BEGIN PUBLIC KEY), but received a private key');
+  }
+  if (!pem.includes('BEGIN PUBLIC KEY')) {
+    throw new RsaError('INVALID_KEY', 'Expected a public key (BEGIN PUBLIC KEY)');
+  }
+}
+export function validateKeySize(keySize) {
+  if (!VALID_KEY_SIZES.includes(keySize)) {
+    throw new RsaError('INVALID_KEY_SIZE', `Invalid key size ${keySize}. Supported sizes: ${VALID_KEY_SIZES.join(', ')}`);
+  }
+}
+const VALID_ENCRYPTION_PADDINGS = ['oaep', 'pkcs1'];
+export function validateEncryptionPadding(padding) {
+  if (!VALID_ENCRYPTION_PADDINGS.includes(padding)) {
+    throw new RsaError('INVALID_PADDING', `Invalid encryption padding '${padding}'. Must be 'oaep' or 'pkcs1'`);
+  }
+}
+const VALID_SIGNATURE_PADDINGS = ['pss', 'pkcs1'];
+export function validateSignaturePadding(padding) {
+  if (!VALID_SIGNATURE_PADDINGS.includes(padding)) {
+    throw new RsaError('INVALID_PADDING', `Invalid signature padding '${padding}'. Must be 'pss' or 'pkcs1'`);
+  }
+}
+const VALID_HASHES = ['sha1', 'sha256', 'sha384', 'sha512'];
+export function validateHash(hash) {
+  if (!VALID_HASHES.includes(hash)) {
+    throw new RsaError('INVALID_HASH', `Invalid hash '${hash}'. Must be 'sha1', 'sha256', 'sha384', or 'sha512'`);
+  }
+}
+const VALID_KEY_FORMATS = ['pkcs1', 'pkcs8'];
+export function validateKeyFormat(format) {
+  if (!VALID_KEY_FORMATS.includes(format)) {
+    throw new RsaError('INVALID_FORMAT', `Invalid key format '${format}'. Must be 'pkcs1' or 'pkcs8'`);
+  }
+}
+const VALID_ENCODINGS = ['utf8', 'base64'];
+export function validateEncoding(encoding) {
+  if (!VALID_ENCODINGS.includes(encoding)) {
+    throw new RsaError('INVALID_ENCODING', `Invalid encoding '${encoding}'. Must be 'utf8' or 'base64'`);
+  }
+}
+//# sourceMappingURL=errors.js.map

package/lib/module/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["VALID_KEY_SIZES","RsaError","Error","constructor","code","message","cause","name","NATIVE_ERROR_CODE_MAP","RSAKeyGenerationError","RSAKeyExtractionError","RSAConvertKeyError","RSAEncryptError","RSADecryptError","RSASignError","RSAVerifyError","wrapNativeError","error","fallbackCode","nativeCode","String","requireString","value","length","requirePrivateKey","pem","includes","requirePublicKey","validateKeySize","keySize","join","VALID_ENCRYPTION_PADDINGS","validateEncryptionPadding","padding","VALID_SIGNATURE_PADDINGS","validateSignaturePadding","VALID_HASHES","validateHash","hash","VALID_KEY_FORMATS","validateKeyFormat","format","VALID_ENCODINGS","validateEncoding","encoding"],"sourceRoot":"../../src","sources":["errors.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,232 @@
+"use strict";
+
+import NativeRsa from "./NativeRsa.js";
+import { getKeyInfo } from "./keyInfo.js";
+import { utf8ToBase64 } from "./encoding.js";
+import { DEFAULTS } from "./constants.js";
+import { requireString, requirePrivateKey, requirePublicKey, validateKeySize, validateEncryptionPadding, validateSignaturePadding, validateHash, validateKeyFormat, validateEncoding, wrapNativeError } from "./errors.js";
+
+// Re-export all public types
+
+// Re-export error class, error code type, and utilities that consumers may need
+export { RsaError } from "./errors.js";
+export { getKeyInfo } from "./keyInfo.js";
+export { utf8ToBase64, base64ToUtf8 } from "./encoding.js";
+
+// --- Key Generation ---
+
+/**
+ * Generate an RSA key pair (public + private) using native platform crypto.
+ *
+ * @param keySize RSA key size in bits. Default: 2048. Supported: 1024, 2048, 4096.
+ * @param options Optional configuration (format: 'pkcs1' | 'pkcs8')
+ * @returns Object with publicKey and privateKey in PEM format
+ * @throws {RsaError} INVALID_KEY_SIZE if keySize is not 1024, 2048, or 4096
+ * @throws {RsaError} INVALID_FORMAT if options.format is not 'pkcs1' or 'pkcs8'
+ * @throws {RsaError} KEY_GENERATION_FAILED if native key generation fails
+ */
+async function generateKeyPair(keySize = 2048, options) {
+  validateKeySize(keySize);
+  const format = options?.format ?? DEFAULTS.KEY_FORMAT;
+  validateKeyFormat(format);
+  try {
+    return await NativeRsa.generateKeyPair(keySize, format);
+  } catch (error) {
+    throw wrapNativeError(error, 'KEY_GENERATION_FAILED');
+  }
+}
+
+/**
+ * Extract the public key from an RSA private key PEM string.
+ *
+ * @param privateKeyPEM RSA private key in PEM format (PKCS#1 or PKCS#8)
+ * @returns Public key in PEM format (SPKI/X.509)
+ * @throws {RsaError} INVALID_INPUT if privateKeyPEM is empty
+ * @throws {RsaError} INVALID_KEY if privateKeyPEM is not a valid private key
+ * @throws {RsaError} KEY_EXTRACTION_FAILED if native operation fails
+ */
+async function getPublicKeyFromPrivate(privateKeyPEM) {
+  requirePrivateKey(privateKeyPEM);
+  try {
+    return await NativeRsa.getPublicKeyFromPrivate(privateKeyPEM);
+  } catch (error) {
+    throw wrapNativeError(error, 'KEY_EXTRACTION_FAILED');
+  }
+}
+
+// --- Encrypt / Decrypt ---
+
+/**
+ * Encrypt plaintext with an RSA public key.
+ *
+ * The input string is UTF-8 encoded to base64 by default before sending to native.
+ * Set `options.encoding = 'base64'` if the input is already base64-encoded binary.
+ *
+ * @param data         The plaintext to encrypt (UTF-8 string or base64, depending on encoding option)
+ * @param publicKeyPEM The public key in SPKI PEM format
+ * @param options      Padding, hash, and encoding options (defaults: oaep, sha256, utf8)
+ * @returns Base64-encoded ciphertext
+ * @throws {RsaError} INVALID_INPUT if data or publicKeyPEM is empty
+ * @throws {RsaError} INVALID_KEY if publicKeyPEM is not a valid public key
+ * @throws {RsaError} INVALID_PADDING if options.padding is invalid
+ * @throws {RsaError} INVALID_HASH if options.hash is invalid
+ * @throws {RsaError} INVALID_ENCODING if options.encoding is invalid
+ * @throws {RsaError} ENCRYPTION_FAILED if native encryption fails
+ */
+async function encrypt(data, publicKeyPEM, options) {
+  requireString(data, 'data');
+  requirePublicKey(publicKeyPEM);
+  const padding = options?.padding ?? DEFAULTS.ENCRYPTION_PADDING;
+  const hash = options?.hash ?? DEFAULTS.HASH;
+  const encoding = options?.encoding ?? DEFAULTS.ENCODING;
+  validateEncryptionPadding(padding);
+  validateHash(hash);
+  validateEncoding(encoding);
+
+  // Convert UTF-8 text to base64 for the native bridge; pass through if already base64
+  const dataBase64 = encoding === 'utf8' ? utf8ToBase64(data) : data;
+  try {
+    return await NativeRsa.encrypt(dataBase64, publicKeyPEM, padding, hash);
+  } catch (error) {
+    throw wrapNativeError(error, 'ENCRYPTION_FAILED');
+  }
+}
+
+/**
+ * Decrypt ciphertext with an RSA private key.
+ *
+ * Always returns base64-encoded plaintext. If the original data was UTF-8 text,
+ * use `base64ToUtf8()` to decode the result.
+ *
+ * @param encrypted    Base64-encoded ciphertext (from encrypt())
+ * @param privateKeyPEM The private key in PEM format (PKCS#1 or PKCS#8)
+ * @param options      Padding and hash options — must match what was used for encryption
+ * @returns Base64-encoded decrypted plaintext
+ * @throws {RsaError} INVALID_INPUT if encrypted or privateKeyPEM is empty
+ * @throws {RsaError} INVALID_KEY if privateKeyPEM is not a valid private key
+ * @throws {RsaError} INVALID_PADDING if options.padding is invalid
+ * @throws {RsaError} INVALID_HASH if options.hash is invalid
+ * @throws {RsaError} DECRYPTION_FAILED if native decryption fails
+ */
+async function decrypt(encrypted, privateKeyPEM, options) {
+  requireString(encrypted, 'encrypted');
+  requirePrivateKey(privateKeyPEM);
+  const padding = options?.padding ?? DEFAULTS.ENCRYPTION_PADDING;
+  const hash = options?.hash ?? DEFAULTS.HASH;
+  validateEncryptionPadding(padding);
+  validateHash(hash);
+  try {
+    return await NativeRsa.decrypt(encrypted, privateKeyPEM, padding, hash);
+  } catch (error) {
+    throw wrapNativeError(error, 'DECRYPTION_FAILED');
+  }
+}
+
+// --- Sign / Verify ---
+
+/**
+ * Sign data with an RSA private key.
+ *
+ * The input string is UTF-8 encoded to base64 by default before sending to native.
+ * Set `options.encoding = 'base64'` if the input is already base64-encoded binary.
+ *
+ * @param data         The data to sign (UTF-8 string or base64, depending on encoding option)
+ * @param privateKeyPEM The private key in PEM format (PKCS#1 or PKCS#8)
+ * @param options      Padding, hash, and encoding options (defaults: pss, sha256, utf8)
+ * @returns Base64-encoded signature
+ * @throws {RsaError} INVALID_INPUT if data or privateKeyPEM is empty
+ * @throws {RsaError} INVALID_KEY if privateKeyPEM is not a valid private key
+ * @throws {RsaError} INVALID_PADDING if options.padding is invalid
+ * @throws {RsaError} INVALID_HASH if options.hash is invalid
+ * @throws {RsaError} INVALID_ENCODING if options.encoding is invalid
+ * @throws {RsaError} SIGNING_FAILED if native signing fails
+ */
+async function sign(data, privateKeyPEM, options) {
+  requireString(data, 'data');
+  requirePrivateKey(privateKeyPEM);
+  const padding = options?.padding ?? DEFAULTS.SIGNATURE_PADDING;
+  const hash = options?.hash ?? DEFAULTS.HASH;
+  const encoding = options?.encoding ?? DEFAULTS.ENCODING;
+  validateSignaturePadding(padding);
+  validateHash(hash);
+  validateEncoding(encoding);
+  const dataBase64 = encoding === 'utf8' ? utf8ToBase64(data) : data;
+  try {
+    return await NativeRsa.sign(dataBase64, privateKeyPEM, padding, hash);
+  } catch (error) {
+    throw wrapNativeError(error, 'SIGNING_FAILED');
+  }
+}
+
+/**
+ * Verify a signature against data using an RSA public key.
+ *
+ * The input string encoding must match what was used during signing.
+ *
+ * @param data         The original data that was signed
+ * @param signature    Base64-encoded signature (from sign())
+ * @param publicKeyPEM The public key in SPKI PEM format
+ * @param options      Padding, hash, and encoding options — must match signing options
+ * @returns true if the signature is valid, false otherwise
+ * @throws {RsaError} INVALID_INPUT if data, signature, or publicKeyPEM is empty
+ * @throws {RsaError} INVALID_KEY if publicKeyPEM is not a valid public key
+ * @throws {RsaError} INVALID_PADDING if options.padding is invalid
+ * @throws {RsaError} INVALID_HASH if options.hash is invalid
+ * @throws {RsaError} INVALID_ENCODING if options.encoding is invalid
+ * @throws {RsaError} VERIFICATION_FAILED if native verification fails
+ */
+async function verify(data, signature, publicKeyPEM, options) {
+  requireString(data, 'data');
+  requireString(signature, 'signature');
+  requirePublicKey(publicKeyPEM);
+  const padding = options?.padding ?? DEFAULTS.SIGNATURE_PADDING;
+  const hash = options?.hash ?? DEFAULTS.HASH;
+  const encoding = options?.encoding ?? DEFAULTS.ENCODING;
+  validateSignaturePadding(padding);
+  validateHash(hash);
+  validateEncoding(encoding);
+  const dataBase64 = encoding === 'utf8' ? utf8ToBase64(data) : data;
+  try {
+    return await NativeRsa.verify(dataBase64, signature, publicKeyPEM, padding, hash);
+  } catch (error) {
+    throw wrapNativeError(error, 'VERIFICATION_FAILED');
+  }
+}
+
+// --- Key Format Conversion ---
+
+/**
+ * Convert a private key PEM between PKCS#1 and PKCS#8 formats.
+ *
+ * @param pem          The private key in PEM format
+ * @param targetFormat 'pkcs1' or 'pkcs8'
+ * @returns The private key re-encoded in the target format
+ * @throws {RsaError} INVALID_INPUT if pem is empty
+ * @throws {RsaError} INVALID_KEY if pem is not a valid private key
+ * @throws {RsaError} INVALID_FORMAT if targetFormat is invalid
+ * @throws {RsaError} KEY_CONVERSION_FAILED if native conversion fails
+ */
+async function convertPrivateKey(pem, targetFormat) {
+  requirePrivateKey(pem);
+  validateKeyFormat(targetFormat);
+  try {
+    return await NativeRsa.convertPrivateKey(pem, targetFormat);
+  } catch (error) {
+    throw wrapNativeError(error, 'KEY_CONVERSION_FAILED');
+  }
+}
+
+// --- Default Export ---
+
+const RSA = {
+  generateKeyPair,
+  getPublicKeyFromPrivate,
+  getKeyInfo,
+  encrypt,
+  decrypt,
+  sign,
+  verify,
+  convertPrivateKey
+};
+export default RSA;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeRsa","getKeyInfo","utf8ToBase64","DEFAULTS","requireString","requirePrivateKey","requirePublicKey","validateKeySize","validateEncryptionPadding","validateSignaturePadding","validateHash","validateKeyFormat","validateEncoding","wrapNativeError","RsaError","base64ToUtf8","generateKeyPair","keySize","options","format","KEY_FORMAT","error","getPublicKeyFromPrivate","privateKeyPEM","encrypt","data","publicKeyPEM","padding","ENCRYPTION_PADDING","hash","HASH","encoding","ENCODING","dataBase64","decrypt","encrypted","sign","SIGNATURE_PADDING","verify","signature","convertPrivateKey","pem","targetFormat","RSA"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":"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","ignoreList":[]}