@pulkitsinha007/hybrid-crypto-js 1.2.2 → 1.3.0

package/README.md

@@ -90,6 +90,32 @@ import { decryptWithSymmetricKey } from '@pulkitsinha007/hybrid-crypto-js';
 const data = await decryptWithSymmetricKey({ encryptedData, iv }, sessionKey);
 ```
 
+### `encryptAsymmetric(data, publicKey)`
+Encrypts data directly using an RSA public key.
+- **Parameters**:
+  - `data`: `string | object` - The payload to encrypt.
+  - `publicKey`: `string` - The RSA public key (Base64).
+- **Returns**: `Promise<string>` (Base64 encoded)
+
+```javascript
+import { encryptAsymmetric } from '@pulkitsinha007/hybrid-crypto-js';
+
+const encryptedData = await encryptAsymmetric({ secret: "data" }, publicKey);
+```
+
+### `decryptAsymmetric(encryptedData, privateKey)`
+Decrypts data directly using an RSA private key.
+- **Parameters**:
+  - `encryptedData`: `string` - The encrypted data (Base64).
+  - `privateKey`: `string` - The RSA private key (Base64).
+- **Returns**: `Promise<string | object>`
+
+```javascript
+import { decryptAsymmetric } from '@pulkitsinha007/hybrid-crypto-js';
+
+const data = await decryptAsymmetric(encryptedData, privateKey);
+```
+
 ---
 
 ## Backend Setup (Dummy Application)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulkitsinha007/hybrid-crypto-js",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Hybrid encryption package using native crypto modules for Node and Browser",
   "type": "module",
   "main": "src/index.js",

package/src/crypto.js

@@ -176,4 +176,71 @@ export async function unwrapKey(wrappedKey, privateKey) {
   );
 
   return key;
+}
+
+/**
+ * Encrypts data directly using an RSA public key (Asymmetric).
+ * @param {string|object} data - The payload to encrypt.
+ * @param {string} publicKey - The RSA public key (Base64).
+ * @returns {Promise<string>} The encrypted data as Base64 string.
+ */
+export async function encryptAsymmetric(data, publicKey) {
+  const crypto = getCrypto();
+  const rsaKeyBuffer = base64ToArrayBuffer(publicKey);
+  const rsaPublicKey = await crypto.subtle.importKey(
+    "spki",
+    rsaKeyBuffer,
+    RSA_ALGO,
+    false,
+    ["encrypt"]
+  );
+
+  const payloadStr = typeof data === 'object' ? JSON.stringify(data) : String(data);
+  const payloadBuffer = str2ab(payloadStr);
+
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    {
+      name: "RSA-OAEP"
+    },
+    rsaPublicKey,
+    payloadBuffer
+  );
+
+  return arrayBufferToBase64(encryptedBuffer);
+}
+
+/**
+ * Decrypts data directly using an RSA private key (Asymmetric).
+ * @param {string} encryptedData - The encrypted data (Base64).
+ * @param {string} privateKey - The RSA private key (Base64).
+ * @returns {Promise<string|object>} The decrypted payload.
+ */
+export async function decryptAsymmetric(encryptedData, privateKey) {
+  const crypto = getCrypto();
+  const rsaKeyBuffer = base64ToArrayBuffer(privateKey);
+  const rsaPrivateKey = await crypto.subtle.importKey(
+    "pkcs8",
+    rsaKeyBuffer,
+    RSA_ALGO,
+    false,
+    ["decrypt"]
+  );
+
+  const encryptedBuffer = base64ToArrayBuffer(encryptedData);
+
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    {
+      name: "RSA-OAEP"
+    },
+    rsaPrivateKey,
+    encryptedBuffer
+  );
+
+  const payloadStr = ab2str(decryptedBuffer);
+
+  try {
+    return JSON.parse(payloadStr);
+  } catch (e) {
+    return payloadStr;
+  }
 }

package/src/index.d.ts

@@ -91,4 +91,20 @@ export function wrapKey(key: CryptoKey, publicKey: string): Promise<string>;
  * @param privateKey - The RSA private key (Base64).
  * @returns The unwrapped AES key.
  */
-export function unwrapKey(wrappedKey: string, privateKey: string): Promise<CryptoKey>;
+export function unwrapKey(wrappedKey: string, privateKey: string): Promise<CryptoKey>;
+
+/**
+ * Encrypts data directly using an RSA public key (Asymmetric).
+ * @param data - The payload to encrypt.
+ * @param publicKey - The RSA public key (Base64).
+ * @returns The encrypted data as Base64 string.
+ */
+export function encryptAsymmetric(data: string | object, publicKey: string): Promise<string>;
+
+/**
+ * Decrypts data directly using an RSA private key (Asymmetric).
+ * @param encryptedData - The encrypted data (Base64).
+ * @param privateKey - The RSA private key (Base64).
+ * @returns The decrypted payload.
+ */
+export function decryptAsymmetric<T = any>(encryptedData: string, privateKey: string): Promise<T>;

package/src/index.js

@@ -4,6 +4,8 @@ export {
   encryptWithSymmetricKey,
   decryptWithSymmetricKey,
   wrapKey,
-  unwrapKey
+  unwrapKey,
+  encryptAsymmetric,
+  decryptAsymmetric
 } from './crypto.js';
 export * from './utils.js';

package/src/utils.js

@@ -1,77 +1,77 @@
-// Utility functions for Hybrid Crypto Package
-
-/**
- * Converts a string to an ArrayBuffer using TextEncoder.
- * @param {string} str - The string to convert.
- * @returns {ArrayBuffer} The resulting ArrayBuffer.
- */
-export function str2ab(str) {
-  return new TextEncoder().encode(str);
-}
-
-/**
- * Converts an ArrayBuffer to a string using TextDecoder.
- * @param {ArrayBuffer} buf - The buffer to convert.
- * @returns {string} The resulting string.
- */
-export function ab2str(buf) {
-  return new TextDecoder().decode(buf);
-}
-
-/**
- * Converts an ArrayBuffer to a Base64 string.
- * @param {ArrayBuffer} buf - The buffer to convert.
- * @returns {string} Base64 string.
- */
-export function arrayBufferToBase64(buf) {
-  let binary = '';
-  const bytes = new Uint8Array(buf);
-  const len = bytes.byteLength;
-  for (let i = 0; i < len; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-
-/**
- * Converts a Base64 string to an ArrayBuffer.
- * @param {string} base64 - The Base64 string.
- * @returns {ArrayBuffer} The resulting ArrayBuffer.
- */
-export function base64ToArrayBuffer(base64) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-
-/**
- * Converts a PEM formatted string to an ArrayBuffer.
- * @param {string} pem - The PEM string.
- * @returns {ArrayBuffer} The raw key data.
- */
-export function pemToArrayBuffer(pem) {
-  // Remove headers, footers, and newlines
-  const b64 = pem
-    .replace(/-----BEGIN [^-]+-----/, '')
-    .replace(/-----END [^-]+-----/, '')
-    .replace(/\s/g, ''); // Removes all whitespace including newlines
-  return base64ToArrayBuffer(b64);
-}
-
-/**
- * Converts an ArrayBuffer to a PEM formatted string.
- * @param {ArrayBuffer} buf - The raw key data.
- * @param {string} type - The key type (e.g., 'PUBLIC KEY', 'PRIVATE KEY').
- * @returns {string} The PEM string.
- */
-export function arrayBufferToPem(buf, type) {
-  const b64 = arrayBufferToBase64(buf);
-  const pemString = `-----BEGIN ${type}-----\n` +
-    b64.match(/.{1,64}/g).join('\n') +
-    `\n-----END ${type}-----\n`;
-  return pemString;
-}
+// Utility functions for Hybrid Crypto Package
+
+/**
+ * Converts a string to an ArrayBuffer using TextEncoder.
+ * @param {string} str - The string to convert.
+ * @returns {ArrayBuffer} The resulting ArrayBuffer.
+ */
+export function str2ab(str) {
+  return new TextEncoder().encode(str);
+}
+
+/**
+ * Converts an ArrayBuffer to a string using TextDecoder.
+ * @param {ArrayBuffer} buf - The buffer to convert.
+ * @returns {string} The resulting string.
+ */
+export function ab2str(buf) {
+  return new TextDecoder().decode(buf);
+}
+
+/**
+ * Converts an ArrayBuffer to a Base64 string.
+ * @param {ArrayBuffer} buf - The buffer to convert.
+ * @returns {string} Base64 string.
+ */
+export function arrayBufferToBase64(buf) {
+  let binary = '';
+  const bytes = new Uint8Array(buf);
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+/**
+ * Converts a Base64 string to an ArrayBuffer.
+ * @param {string} base64 - The Base64 string.
+ * @returns {ArrayBuffer} The resulting ArrayBuffer.
+ */
+export function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+/**
+ * Converts a PEM formatted string to an ArrayBuffer.
+ * @param {string} pem - The PEM string.
+ * @returns {ArrayBuffer} The raw key data.
+ */
+export function pemToArrayBuffer(pem) {
+  // Remove headers, footers, and newlines
+  const b64 = pem
+    .replace(/-----BEGIN [^-]+-----/, '')
+    .replace(/-----END [^-]+-----/, '')
+    .replace(/\s/g, ''); // Removes all whitespace including newlines
+  return base64ToArrayBuffer(b64);
+}
+
+/**
+ * Converts an ArrayBuffer to a PEM formatted string.
+ * @param {ArrayBuffer} buf - The raw key data.
+ * @param {string} type - The key type (e.g., 'PUBLIC KEY', 'PRIVATE KEY').
+ * @returns {string} The PEM string.
+ */
+export function arrayBufferToPem(buf, type) {
+  const b64 = arrayBufferToBase64(buf);
+  const pemString = `-----BEGIN ${type}-----\n` +
+    b64.match(/.{1,64}/g).join('\n') +
+    `\n-----END ${type}-----\n`;
+  return pemString;
+}

package/test/asymmetric.test.js

@@ -0,0 +1,43 @@
+import { test, describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  generateKeyPair,
+  encryptAsymmetric,
+  decryptAsymmetric
+} from '../src/index.js';
+
+describe('Asymmetric Encryption (RSA-OAEP)', () => {
+  it('should encrypt and decrypt a plain string', async () => {
+    const { publicKey, privateKey } = await generateKeyPair();
+    const originalData = "Hello, Asymmetric World!";
+
+    const encryptedData = await encryptAsymmetric(originalData, publicKey);
+    assert.notStrictEqual(encryptedData, originalData);
+
+    const decryptedData = await decryptAsymmetric(encryptedData, privateKey);
+    assert.strictEqual(decryptedData, originalData);
+  });
+
+  it('should encrypt and decrypt a JSON object', async () => {
+    const { publicKey, privateKey } = await generateKeyPair();
+    const originalData = { foo: "bar", baz: 123 };
+
+    const encryptedData = await encryptAsymmetric(originalData, publicKey);
+    const decryptedData = await decryptAsymmetric(encryptedData, privateKey);
+
+    assert.deepStrictEqual(decryptedData, originalData);
+  });
+
+  it('should fail to decrypt with the wrong private key', async () => {
+    const keys1 = await generateKeyPair();
+    const keys2 = await generateKeyPair();
+
+    const originalData = "Secret message";
+    const encryptedData = await encryptAsymmetric(originalData, keys1.publicKey);
+
+    await assert.rejects(
+      () => decryptAsymmetric(encryptedData, keys2.privateKey),
+      /OperationError|DataError/
+    );
+  });
+});