@ka-libs/crypto 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kuzuki Azusa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# README\.md
+
+# ka\-crypto
+
+**Zero\-dependency cross\-platform RSA \+ AES hybrid encryption utility for Node\.js \& Browser, fully compatible with PHP RSA\-OAEP\-SHA1\.**
+
+**GitHub:**[https://github\.com/Cirnotsuki/ka\-crypto](https://github.com/Cirnotsuki/ka-crypto)
+
+Built on native Web Crypto / Node\.js Crypto API, no third\-party dependencies\. Lightweight and standard\-compliant\.
+
+**Core advantage: 100% algorithm consistent with PHP openssl OAEP\-SHA1**, perfectly solving front\-end \& PHP backend encryption docking issues\.
+
+## ✨ Features
+
+- **Cross\-platform**: Support Node\.js \& all modern browsers
+
+- **Zero dependency**: Only rely on system native crypto API
+
+- **PHP full compatible**: RSA\-OAEP\-SHA1 strictly matches PHP openssl default OAEP mode
+
+- **Secure hybrid encryption**: RSA key exchange \+ AES\-256\-GCM authenticated encryption
+
+- **Tamper\-proof**: GCM auth tag ensures data integrity
+
+- **Unified structure**: Fixed cipher format for front\-end \& PHP backend interaction
+
+- **Standard key support**: Compatible with PKCS\#1 / PKCS\#8 PEM RSA keys
+
+- **Independent crypto methods**: Expose standalone RSA / AES encrypt \& decrypt functions for flexible usage
+
+## 🔐 Encryption Flow \(PHP Consistent\)
+
+1. Randomly generate AES\-256\-GCM session key and IV
+
+2. Encrypt plainData with AES\-256\-GCM, get ciphertext and auth tag
+
+3. Encrypt AES session key via **RSA\-OAEP\-SHA1** \(PHP standard algorithm\)
+
+4. Package all fields into unified cipher object for transmission
+
+5. Decrypt: Restore AES key with RSA private key, then decrypt AES ciphertext
+
+## 📦 Installation
+
+```Plain Text
+npm install ka-crypto
+```
+
+## 🚀 Quick Usage
+
+### 1\. Generate RSA Key Pairs
+
+```js
+import { keyPairs } from 'ka-crypto';
+
+// Return RSA public key / private key (PEM format)
+const [publicKey, privateKey] = await keyPairs();
+
+```
+
+### 2\. Hybrid Encrypt \(RSA \+ AES\)
+
+```js
+import { encrypt } from 'ka-crypto';
+
+// Param: plainData, RSA publicKey (PEM format)
+const { data, valid } = await encrypt('any type of data', publicKey);
+
+```
+
+### 3\. Hybrid Decrypt \(RSA \+ AES\)
+
+```js
+import { decrypt } from 'ka-crypto';
+
+// Param: data, valid, RSA privateKey (PEM format)
+const plainData = await decrypt(data, valid, privateKey);
+
+```
+
+## 🧩 Standalone AES / RSA Methods
+
+Support independent use of single encryption and decryption algorithm, flexible for custom business scenarios\.
+
+### AES Encrypt / Decrypt \(AES\-256\-GCM\)
+
+```js
+import { aesEncrypt, aesDecrypt } from 'ka-crypto';
+
+// AES encryption
+const aesResult = aesEncrypt(plainData, aesKey, iv);
+
+// AES decryption
+const originText = aesDecrypt(cipherText, aesKey, iv, tag);
+
+```
+
+### RSA Encrypt / Decrypt \(RSA\-OAEP\-SHA1\)
+
+```js
+import { rsaEncrypt, rsaDecrypt } from 'ka-crypto';
+
+// RSA public key encryption
+const rsaCipher = rsaEncrypt(plainData, publicKey);
+
+// RSA private key decryption
+const originData = rsaDecrypt(rsaCipher, privateKey);
+
+```
+
+### Random Bytes Generator
+
+High\-quality pseudo\-random byte generation based on Mersenne Twister algorithm, used for custom IV / key random filling, consistent random logic across Node\.js and browsers\.
+
+```js
+import { getRandomValues } from 'ka-crypto';
+
+// Fill Uint8Array with secure random bytes (0-255)
+const buf = new Uint8Array(16);
+getRandomValues(buf);
+
+```
+
+**Function Description**
+
+- Based on Mersenne Twister pseudo\-random algorithm, stable and high randomness
+
+- Cross\-environment consistency: unified random byte generation logic for browser and Node\.js
+
+- Param: `Uint8Array` — Binary array to be filled with random bytes
+
+- Param: `Uint8Array` — Binary array to be filled with random bytes
+
+- Return: Filled original Uint8Array \(mutate in place\)
+
+### UUID Generator \(RFC4122 Standard\)
+
+Generate standard **RFC4122 Version 4 UUID**, based on internal Mersenne Twister random bytes, cross\-environment consistent and verifiable\.
+
+```js
+import { getUUID } from 'ka-crypto';
+
+// Standard UUID (with dash)
+const uuid = getUUID(false); 
+
+// Simplified UUID (no dash)
+const simpleUuid = getUUID(true);
+
+```
+
+**Function Description**
+
+- Strictly compliant with **RFC4122 v4 UUID** specification
+
+- Random seed based on Mersenne Twister algorithm, uniform with crypto random logic
+
+- Built\-in format verification, throws error if generated UUID is invalid
+
+- Cross\-environment consistent output for Node\.js and browsers
+
+**Parameters**
+
+- `simplify: boolean`
+
+- `false`\(default\): Return standard UUID with dashes `xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx`
+
+- `true`: Return pure 32\-bit hex string without dashes
+
+**Return Value**
+
+- `string`: Valid RFC4122 UUID string
+
+**Exception**
+
+- Throw `TypeError` when UUID format verification fails
+
+## 🔑 Keypairs Export \(Node Environment Only\)
+
+Built\-in RSA key pair automatic generation \& local file export function,**only available in Node\.js environment**, disabled in browsers \(browser prohibits local file writing\)\.
+
+### Function Description
+
+Quickly generate standard RSA PEM key pairs \(public key \+ private key\) and automatically write them to the specified local directory, convenient for project initialization and backend PHP key deployment\.
+
+### Usage
+
+```js
+import { exportKeyPairs } from 'ka-crypto';
+
+// Param: distPath (local folder path)
+await exportKeyPairs('./keys');
+
+```
+
+### Parameter Explanation
+
+- **distPath**: Local directory path for storing key files \(relative/absolute path supported\)
+
+### Export Result
+
+After successful execution, two standard PEM key files will be generated in the target directory:
+
+- `public.pem`: RSA public key \(for frontend encryption / PHP public key encryption\)
+
+- `private.pem`: RSA private key \(for backend decryption / JS private key decryption\)
+
+### Important Notes
+
+- ❌ **Unavailable in browsers**: Browser sandbox restricts local file system writing, calling this function in browser will throw an error
+
+- ✅ **Only for Node\.js**: Suitable for local development, server initialization key generation
+
+- Generated keys fully comply with **RSA\-OAEP\-SHA1** standard, natively compatible with PHP openssl encryption and decryption
+
+## 📄 Cipher Structure \(JS \& PHP Interoperable\)
+
+Unified transmission structure, directly JSON serializable for PHP backend docking:
+
+```ts
+interface CipherData {
+    data: string;       // AES encrypted ciphertext (base64)
+    valid: {
+        key: string;    // RSA-OAEP-SHA1 encrypted AES key (base64)
+        iv: string;     // AES-256-GCM initialization vector (base64)
+    },
+}
+
+```
+
+## 🛡️ Algorithm Standard
+
+- **AES**: AES\-256\-GCM \(authenticated encryption, anti\-tampering\)
+
+- **RSA**: RSA\-OAEP\-SHA1 \(fully compatible with PHP `openssl_public_encrypt` OAEP mode\)
+
+- **Key Format**: Standard PEM public / private key
+
+## 🌍 Compatibility
+
+- Runtime: Node\.js 16\+, Chrome / Edge / Firefox / Safari latest
+
+- Backend: PHP 7\.4\+ / PHP 8\.x \(openssl extension required\)
+
+## 📝 License
+
+MIT

package/dist/cjs/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("fs"),r=require("path");function t(e){const r=e instanceof Uint8Array?e:new Uint8Array(e);if(void 0!==globalThis.Buffer)return globalThis.Buffer.from(r).toString("base64");let t="";for(let e=0;e<r.length;e+=32768)t+=String.fromCharCode(...r.subarray(e,e+32768));return btoa(t)}function n(){if("undefined"!=typeof window&&window.crypto)return window.crypto;if("undefined"!=typeof self&&self.crypto)return self.crypto;if("undefined"!=typeof globalThis&&globalThis.crypto)return globalThis.crypto;if("undefined"!=typeof window&&window.msCrypto)return window.msCrypto;if("undefined"!=typeof global&&global.crypto)return global.crypto;if("function"==typeof require)return require("crypto").webcrypto;throw new Error("WebCrypto not available")}function o(){const e=n().subtle;if(!e)throw new Error("SubtleCrypto not available");return e}async function a(){const e=await o().generateKey({name:"RSA-OAEP",modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:"SHA-1"},!0,["encrypt","decrypt"]);return["-----BEGIN PUBLIC KEY-----\n"+t(await o().exportKey("spki",e.publicKey))+"\n-----END PUBLIC KEY-----","-----BEGIN PRIVATE KEY-----\n"+t(await o().exportKey("pkcs8",e.privateKey))+"\n-----END PRIVATE KEY-----"]}function i(e){return n().getRandomValues(e)}function c(e=16){return i(new Uint8Array(e))}function s(e){return e.replace(/-----BEGIN [^-]+-----/g,"").replace(/-----END [^-]+-----/g,"").replace(/\s+/g,"")}function u(e){const r=s(e);if(void 0!==globalThis.Buffer){const e=globalThis.Buffer.from(r,"base64");return e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)}const t=atob(r),n=new Uint8Array(t.length);for(let e=0;e<t.length;e++)n[e]=t.charCodeAt(e);return n.buffer}async function y(t){if("undefined"!=typeof process&&process.versions?.node){const[n,o]=await a();return e.writeFileSync(r.join(t,"public.pem"),n,"utf-8"),void e.writeFileSync(r.join(t,"private.pem"),o,"utf-8")}throw new Error("require Node runtime environment")}const p=Array.from({length:256},(e,r)=>r.toString(16).padStart(2,"0"));function f(e){const r=e;return p[r[0]]+p[r[1]]+p[r[2]]+p[r[3]]+"-"+p[r[4]]+p[r[5]]+"-"+p[r[6]]+p[r[7]]+"-"+p[r[8]]+p[r[9]]+"-"+p[r[10]]+p[r[11]]+p[r[12]]+p[r[13]]+p[r[14]]+p[r[15]]}function l(e=!1){const r=i(new Uint8Array(16));r[6]=15&r[6]|64,r[8]=63&r[8]|128;const t=f(r);return e?t.replace(/-/g,""):t}const d="6ba7b811-9dad-11d1-80b4-00c04fd430c8";async function w(e,r=d){const t=Uint8Array.from(r.replace(/-/g,"").match(/.{2}/g).map(e=>parseInt(e,16))),n=(new TextEncoder).encode(e),a=new Uint8Array(t.length+n.length);a.set(t,0),a.set(n,t.length);const i=await o().digest("SHA-1",a),c=new Uint8Array(i).slice(0,16);return c[6]=15&c[6]|80,c[8]=63&c[8]|128,f(c)}async function b(e,r=c(32),n=c(16)){const a=await o().importKey("raw",r,{name:"AES-GCM"},!1,["encrypt"]);return{data:t(await o().encrypt({name:"AES-GCM",iv:n},a,(new TextEncoder).encode(JSON.stringify(e)))),key:t(r),iv:t(n)}}async function g(e,r){const n=await async function(e){const r=u(e);return o().importKey("spki",r,{name:"RSA-OAEP",hash:"SHA-1"},!1,["encrypt"])}(r);return t(await o().encrypt({name:"RSA-OAEP"},n,(new TextEncoder).encode(JSON.stringify(e))))}async function A(e,r){if(!r)return null;const t=await b(e);return{valid:await g({key:t.key,iv:t.iv},r),data:t.data}}async function m(e,r,t){try{const n=await o().importKey("raw",u(r),{name:"AES-GCM"},!1,["decrypt"]),a=await o().decrypt({name:"AES-GCM",iv:u(t)},n,u(e));return JSON.parse((new TextDecoder).decode(a))}catch(e){return console.error(e),null}}async function E(e,r){const t=await async function(e){const r=u(e);return o().importKey("pkcs8",r,{name:"RSA-OAEP",hash:"SHA-1"},!1,["decrypt"])}(r),n=await o().decrypt({name:"RSA-OAEP"},t,u(e));return JSON.parse((new TextDecoder).decode(n))}async function h(e,r,t){try{const n=await E(r,t);return m(e,n.key,n.iv)}catch(e){return console.error(e),null}}var x=Object.freeze({__proto__:null,aesDecrypt:m,aesEncrypt:b,arrayBufferToBase64:t,base64Cleaner:s,base64ToArrayBuffer:u,decrypt:h,encrypt:A,exportKeyPairs:y,getRandomBytes:c,getRandomValues:i,keyPairs:a,rsaDecrypt:E,rsaEncrypt:g,uuidv4:l,uuidv5:w});exports.aesDecrypt=m,exports.aesEncrypt=b,exports.arrayBufferToBase64=t,exports.base64Cleaner=s,exports.base64ToArrayBuffer=u,exports.decrypt=h,exports.default=x,exports.encrypt=A,exports.exportKeyPairs=y,exports.getRandomBytes=c,exports.getRandomValues=i,exports.keyPairs=a,exports.rsaDecrypt=E,exports.rsaEncrypt=g,exports.uuidv4=l,exports.uuidv5=w;

package/dist/esm/core/getCrypto.js

@@ -0,0 +1 @@
+function o(){if("undefined"!=typeof window&&window.crypto)return window.crypto;if("undefined"!=typeof self&&self.crypto)return self.crypto;if("undefined"!=typeof globalThis&&globalThis.crypto)return globalThis.crypto;if("undefined"!=typeof window&&window.msCrypto)return window.msCrypto;if("undefined"!=typeof global&&global.crypto)return global.crypto;if("function"==typeof require)return require("crypto").webcrypto;throw new Error("WebCrypto not available")}export{o as getCrypto};

package/dist/esm/core/getSubtle.js

@@ -0,0 +1 @@
+import{getCrypto as t}from"./getCrypto.js";function r(){const r=t().subtle;if(!r)throw new Error("SubtleCrypto not available");return r}export{r as getSubtle};

package/dist/esm/core/importPrivateKey.js

@@ -0,0 +1 @@
+import{base64ToArrayBuffer as r}from"../lib/base64ToArrayBuffer.js";import{getSubtle as t}from"./getSubtle.js";async function e(e){const o=r(e);return t().importKey("pkcs8",o,{name:"RSA-OAEP",hash:"SHA-1"},!1,["decrypt"])}export{e as importPrivateKey};

package/dist/esm/core/importPublicKey.js

@@ -0,0 +1 @@
+import{base64ToArrayBuffer as r}from"../lib/base64ToArrayBuffer.js";import{getSubtle as t}from"./getSubtle.js";async function e(e){const o=r(e);return t().importKey("spki",o,{name:"RSA-OAEP",hash:"SHA-1"},!1,["encrypt"])}export{e as importPublicKey};

package/dist/esm/core/keyPairs.js

@@ -0,0 +1 @@
+import{arrayBufferToBase64 as e}from"../lib/arrayBufferToBase64.js";import{getSubtle as t}from"./getSubtle.js";async function r(){const r=await t().generateKey({name:"RSA-OAEP",modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:"SHA-1"},!0,["encrypt","decrypt"]);return["-----BEGIN PUBLIC KEY-----\n"+e(await t().exportKey("spki",r.publicKey))+"\n-----END PUBLIC KEY-----","-----BEGIN PRIVATE KEY-----\n"+e(await t().exportKey("pkcs8",r.privateKey))+"\n-----END PRIVATE KEY-----"]}export{r as keyPairs};

package/dist/esm/cripter/aesDecrypt.js

@@ -0,0 +1 @@
+import{base64ToArrayBuffer as r}from"../lib/base64ToArrayBuffer.js";import{getSubtle as e}from"../core/getSubtle.js";async function t(t,o,a){try{const c=await e().importKey("raw",r(o),{name:"AES-GCM"},!1,["decrypt"]),n=await e().decrypt({name:"AES-GCM",iv:r(a)},c,r(t));return JSON.parse((new TextDecoder).decode(n))}catch(r){return console.error(r),null}}export{t as aesDecrypt};

package/dist/esm/cripter/aesEncrypt.js

@@ -0,0 +1 @@
+import{arrayBufferToBase64 as e}from"../lib/arrayBufferToBase64.js";import{getSubtle as r}from"../core/getSubtle.js";import{getRandomBytes as t}from"../lib/getRandomBytes.js";async function o(o,a=t(32),n=t(16)){const i=await r().importKey("raw",a,{name:"AES-GCM"},!1,["encrypt"]),m=await r().encrypt({name:"AES-GCM",iv:n},i,(new TextEncoder).encode(JSON.stringify(o)));return{data:e(m),key:e(a),iv:e(n)}}export{o as aesEncrypt};

package/dist/esm/cripter/decrypt.js

@@ -0,0 +1 @@
+import{aesDecrypt as r}from"./aesDecrypt.js";import{rsaDecrypt as t}from"./rsaDecrypt.js";async function o(o,e,c){try{const n=await t(e,c);return r(o,n.key,n.iv)}catch(r){return console.error(r),null}}export{o as decrypt};

package/dist/esm/cripter/encrypt.js

@@ -0,0 +1 @@
+import{aesEncrypt as t}from"./aesEncrypt.js";import{rsaEncrypt as a}from"./rsaEncrypt.js";async function r(r,i){if(!i)return null;const n=await t(r);return{valid:await a({key:n.key,iv:n.iv},i),data:n.data}}export{r as encrypt};

package/dist/esm/cripter/rsaDecrypt.js

@@ -0,0 +1 @@
+import{base64ToArrayBuffer as e}from"../lib/base64ToArrayBuffer.js";import{importPrivateKey as r}from"../core/importPrivateKey.js";import{getSubtle as o}from"../core/getSubtle.js";async function t(t,a){const i=await r(a),c=await o().decrypt({name:"RSA-OAEP"},i,e(t));return JSON.parse((new TextDecoder).decode(c))}export{t as rsaDecrypt};

package/dist/esm/cripter/rsaEncrypt.js

@@ -0,0 +1 @@
+import{arrayBufferToBase64 as r}from"../lib/arrayBufferToBase64.js";import{importPublicKey as e}from"../core/importPublicKey.js";import{getSubtle as o}from"../core/getSubtle.js";async function t(t,i){const n=await e(i),a=await o().encrypt({name:"RSA-OAEP"},n,(new TextEncoder).encode(JSON.stringify(t)));return r(a)}export{t as rsaEncrypt};

package/dist/esm/exports/aes-decrypt.js

@@ -0,0 +1 @@
+export { aesDecrypt } from "../cripter/aesDecrypt.js";export { aesDecrypt as default} from "../cripter/aesDecrypt.js";

package/dist/esm/exports/aes-encrypt.js

@@ -0,0 +1 @@
+export { aesEncrypt } from "../cripter/aesEncrypt.js";export { aesEncrypt as default} from "../cripter/aesEncrypt.js";

package/dist/esm/exports/array-buffer-to-base64.js

@@ -0,0 +1 @@
+export { arrayBufferToBase64 } from "../lib/arrayBufferToBase64.js";export { arrayBufferToBase64 as default} from "../lib/arrayBufferToBase64.js";

package/dist/esm/exports/base64-cleaner.js

@@ -0,0 +1 @@
+export { base64Cleaner } from "../lib/base64Cleaner.js";export { base64Cleaner as default} from "../lib/base64Cleaner.js";

package/dist/esm/exports/base64-to-array-buffer.js

@@ -0,0 +1 @@
+export { base64ToArrayBuffer } from "../lib/base64ToArrayBuffer.js";export { base64ToArrayBuffer as default} from "../lib/base64ToArrayBuffer.js";

package/dist/esm/exports/decrypt.js

@@ -0,0 +1 @@
+export { decrypt } from "../cripter/decrypt.js";export { decrypt as default} from "../cripter/decrypt.js";

package/dist/esm/exports/encrypt.js

@@ -0,0 +1 @@
+export { encrypt } from "../cripter/encrypt.js";export { encrypt as default} from "../cripter/encrypt.js";

package/dist/esm/exports/export-key-pairs.js

@@ -0,0 +1 @@
+export { exportKeyPairs } from "../lib/exportKeyPairs.js";export { exportKeyPairs as default} from "../lib/exportKeyPairs.js";

package/dist/esm/exports/get-random-bytes.js

@@ -0,0 +1 @@
+export { getRandomBytes } from "../lib/getRandomBytes.js";export { getRandomBytes as default} from "../lib/getRandomBytes.js";

package/dist/esm/exports/get-random-values.js

@@ -0,0 +1 @@
+export { getRandomValues } from "../lib/getRandomValues.js";export { getRandomValues as default} from "../lib/getRandomValues.js";

package/dist/esm/exports/key-pairs.js

@@ -0,0 +1 @@
+export { keyPairs } from "../core/keyPairs.js";export { keyPairs as default} from "../core/keyPairs.js";

package/dist/esm/exports/rsa-decrypt.js

@@ -0,0 +1 @@
+export { rsaDecrypt } from "../cripter/rsaDecrypt.js";export { rsaDecrypt as default} from "../cripter/rsaDecrypt.js";

package/dist/esm/exports/rsa-encrypt.js

@@ -0,0 +1 @@
+export { rsaEncrypt } from "../cripter/rsaEncrypt.js";export { rsaEncrypt as default} from "../cripter/rsaEncrypt.js";

package/dist/esm/exports/uuidv4.js

@@ -0,0 +1 @@
+export { uuidv4 } from "../lib/uuidv4.js";export { uuidv4 as default} from "../lib/uuidv4.js";

package/dist/esm/exports/uuidv5.js

@@ -0,0 +1 @@
+export { uuidv5 } from "../lib/uuidv5.js";export { uuidv5 as default} from "../lib/uuidv5.js";

package/dist/esm/exports.js

@@ -0,0 +1 @@
+export { default as keyPairs } from "./exports/key-pairs";export { default as getRandomBytes } from "./exports/get-random-bytes";export { default as arrayBufferToBase64 } from "./exports/array-buffer-to-base64";export { default as base64ToArrayBuffer } from "./exports/base64-to-array-buffer";export { default as getRandomValues } from "./exports/get-random-values";export { default as exportKeyPairs } from "./exports/export-key-pairs";export { default as base64Cleaner } from "./exports/base64-cleaner";export { default as uuidv4 } from "./exports/uuidv4";export { default as uuidv5 } from "./exports/uuidv5";export { default as encrypt } from "./exports/encrypt";export { default as decrypt } from "./exports/decrypt";export { default as rsaEncrypt } from "./exports/rsa-encrypt";export { default as rsaDecrypt } from "./exports/rsa-decrypt";export { default as aesEncrypt } from "./exports/aes-encrypt";export { default as aesDecrypt } from "./exports/aes-decrypt";

package/dist/esm/index.js

@@ -0,0 +1 @@
+import*as r from"./exports.js";export{aesDecrypt}from"./cripter/aesDecrypt.js";export{aesEncrypt}from"./cripter/aesEncrypt.js";export{arrayBufferToBase64}from"./lib/arrayBufferToBase64.js";export{base64Cleaner}from"./lib/base64Cleaner.js";export{base64ToArrayBuffer}from"./lib/base64ToArrayBuffer.js";export{decrypt}from"./cripter/decrypt.js";export{encrypt}from"./cripter/encrypt.js";export{exportKeyPairs}from"./lib/exportKeyPairs.js";export{getRandomBytes}from"./lib/getRandomBytes.js";export{getRandomValues}from"./lib/getRandomValues.js";export{keyPairs}from"./core/keyPairs.js";export{rsaDecrypt}from"./cripter/rsaDecrypt.js";export{rsaEncrypt}from"./cripter/rsaEncrypt.js";export{uuidv4}from"./lib/uuidv4.js";export{uuidv5}from"./lib/uuidv5.js";export{r as default};

package/dist/esm/lib/arrayBufferToBase64.js

@@ -0,0 +1 @@
+function r(r){const t=r instanceof Uint8Array?r:new Uint8Array(r);if(void 0!==globalThis.Buffer)return globalThis.Buffer.from(t).toString("base64");let n="";for(let r=0;r<t.length;r+=32768)n+=String.fromCharCode(...t.subarray(r,r+32768));return btoa(n)}export{r as arrayBufferToBase64};

package/dist/esm/lib/base64Cleaner.js

@@ -0,0 +1 @@
+function e(e){return e.replace(/-----BEGIN [^-]+-----/g,"").replace(/-----END [^-]+-----/g,"").replace(/\s+/g,"")}export{e as base64Cleaner};

package/dist/esm/lib/base64ToArrayBuffer.js

@@ -0,0 +1 @@
+import{base64Cleaner as e}from"./base64Cleaner.js";function t(t){const f=e(t);if(void 0!==globalThis.Buffer){const e=globalThis.Buffer.from(f,"base64");return e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)}const r=atob(f),o=new Uint8Array(r.length);for(let e=0;e<r.length;e++)o[e]=r.charCodeAt(e);return o.buffer}export{t as base64ToArrayBuffer};

package/dist/esm/lib/bytesToUUID.js

@@ -0,0 +1 @@
+const t=Array.from({length:256},(t,r)=>r.toString(16).padStart(2,"0"));function r(r){const n=r;return t[n[0]]+t[n[1]]+t[n[2]]+t[n[3]]+"-"+t[n[4]]+t[n[5]]+"-"+t[n[6]]+t[n[7]]+"-"+t[n[8]]+t[n[9]]+"-"+t[n[10]]+t[n[11]]+t[n[12]]+t[n[13]]+t[n[14]]+t[n[15]]}export{r as bytesToUUID};

package/dist/esm/lib/exportKeyPairs.js

@@ -0,0 +1 @@
+import{keyPairs as r}from"../core/keyPairs.js";import{isNode as i}from"../runtime/isNode.js";import e from"fs";import o from"path";async function t(t){if(i()){const[i,n]=await r();return e.writeFileSync(o.join(t,"public.pem"),i,"utf-8"),void e.writeFileSync(o.join(t,"private.pem"),n,"utf-8")}throw new Error("require Node runtime environment")}export{t as exportKeyPairs};

package/dist/esm/lib/getRandomBytes.js

@@ -0,0 +1 @@
+import{getRandomValues as r}from"./getRandomValues.js";function n(n=16){return r(new Uint8Array(n))}export{n as getRandomBytes};

package/dist/esm/lib/getRandomValues.js

@@ -0,0 +1 @@
+import{getCrypto as o}from"../core/getCrypto.js";function r(r){return o().getRandomValues(r)}export{r as getRandomValues};

package/dist/esm/lib/uuidv4.js

@@ -0,0 +1 @@
+import{bytesToUUID as o}from"./bytesToUUID.js";import{getRandomValues as r}from"./getRandomValues.js";function t(t=!1){const e=r(new Uint8Array(16));e[6]=15&e[6]|64,e[8]=63&e[8]|128;const n=o(e);return t?n.replace(/-/g,""):n}export{t as uuidv4};

package/dist/esm/lib/uuidv5.js

@@ -0,0 +1 @@
+import{getSubtle as t}from"../core/getSubtle.js";import{bytesToUUID as e}from"./bytesToUUID.js";const n={URL:"6ba7b811-9dad-11d1-80b4-00c04fd430c8"};async function r(r,o=n.URL){const c=Uint8Array.from(o.replace(/-/g,"").match(/.{2}/g).map(t=>parseInt(t,16))),a=(new TextEncoder).encode(r),s=new Uint8Array(c.length+a.length);s.set(c,0),s.set(a,c.length);const i=await t().digest("SHA-1",s),d=new Uint8Array(i).slice(0,16);return d[6]=15&d[6]|80,d[8]=63&d[8]|128,e(d)}export{n as UUID_NAMESPACE,r as uuidv5};

package/dist/esm/runtime/isNode.js

@@ -0,0 +1 @@
+function e(){return"undefined"!=typeof process&&process.versions?.node}export{e as isNode};

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+declare function keyPairs(): Promise<string[]>;
+
+declare function getRandomBytes(length?: number): Uint8Array<ArrayBuffer>;
+
+declare function arrayBufferToBase64(input: ArrayBuffer | Uint8Array): string;
+
+declare function base64ToArrayBuffer(input: Base64URLString): ArrayBuffer;
+
+declare function getRandomValues<T extends Exclude<BufferSource, ArrayBuffer>>(abv: T): T;
+
+declare function exportKeyPairs(dist: string): Promise<void>;
+
+declare function base64Cleaner(input: string): string;
+
+declare function uuidv4(simplify?: boolean): string;
+
+/**
+ * UUID v5 generator
+ */
+declare function uuidv5(name: string, namespace?: string): Promise<string>;
+
+/**
+ * 混合加密
+ */
+declare function encrypt<T>(data: T, publicKey: string): Promise<{
+    valid: string;
+    data: string;
+} | null>;
+
+/**
+ * 混合解密
+ */
+declare function decrypt(data: string, valid: string, privateKey: string): Promise<any>;
+
+/**
+ * RSA加密
+ */
+declare function rsaEncrypt<T>(data: T, publicKey: string): Promise<string>;
+
+/**
+ * RSA解密
+ */
+declare function rsaDecrypt(data: string, privateKey: string): Promise<any>;
+
+/**
+ * AES加密
+ */
+declare function aesEncrypt<T>(data: T, aesKey?: Uint8Array<ArrayBuffer>, aesIv?: Uint8Array<ArrayBuffer>): Promise<{
+    data: string;
+    key: string;
+    iv: string;
+}>;
+
+/**
+ * AES解密
+ */
+declare function aesDecrypt(data: string, aesKey: string, aesIv: string): Promise<any>;
+
+declare const KaCrypto_aesDecrypt: typeof aesDecrypt;
+declare const KaCrypto_aesEncrypt: typeof aesEncrypt;
+declare const KaCrypto_arrayBufferToBase64: typeof arrayBufferToBase64;
+declare const KaCrypto_base64Cleaner: typeof base64Cleaner;
+declare const KaCrypto_base64ToArrayBuffer: typeof base64ToArrayBuffer;
+declare const KaCrypto_decrypt: typeof decrypt;
+declare const KaCrypto_encrypt: typeof encrypt;
+declare const KaCrypto_exportKeyPairs: typeof exportKeyPairs;
+declare const KaCrypto_getRandomBytes: typeof getRandomBytes;
+declare const KaCrypto_getRandomValues: typeof getRandomValues;
+declare const KaCrypto_keyPairs: typeof keyPairs;
+declare const KaCrypto_rsaDecrypt: typeof rsaDecrypt;
+declare const KaCrypto_rsaEncrypt: typeof rsaEncrypt;
+declare const KaCrypto_uuidv4: typeof uuidv4;
+declare const KaCrypto_uuidv5: typeof uuidv5;
+declare namespace KaCrypto {
+  export {
+    KaCrypto_aesDecrypt as aesDecrypt,
+    KaCrypto_aesEncrypt as aesEncrypt,
+    KaCrypto_arrayBufferToBase64 as arrayBufferToBase64,
+    KaCrypto_base64Cleaner as base64Cleaner,
+    KaCrypto_base64ToArrayBuffer as base64ToArrayBuffer,
+    KaCrypto_decrypt as decrypt,
+    KaCrypto_encrypt as encrypt,
+    KaCrypto_exportKeyPairs as exportKeyPairs,
+    KaCrypto_getRandomBytes as getRandomBytes,
+    KaCrypto_getRandomValues as getRandomValues,
+    KaCrypto_keyPairs as keyPairs,
+    KaCrypto_rsaDecrypt as rsaDecrypt,
+    KaCrypto_rsaEncrypt as rsaEncrypt,
+    KaCrypto_uuidv4 as uuidv4,
+    KaCrypto_uuidv5 as uuidv5,
+  };
+}
+
+export { aesDecrypt, aesEncrypt, arrayBufferToBase64, base64Cleaner, base64ToArrayBuffer, decrypt, KaCrypto as default, encrypt, exportKeyPairs, getRandomBytes, getRandomValues, keyPairs, rsaDecrypt, rsaEncrypt, uuidv4, uuidv5 };

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@ka-libs/crypto",
+  "version": "1.0.0",
+  "description": "Cross-environment crypto utility for Node.js & Browser, implement RSA-AES hybrid encryption based on native Web Crypto / Node.js crypto without third-party dependencies.",
+  "scripts": {
+    "build:js": "rollup -c",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:clean": "node ./cleanDist.js",
+    "build": "npm run build:clean && npm run build:js"
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "browser": "dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./aes-decrypt": {
+      "import": "./dist/esm/exports/aes-decrypt.js"
+    },
+    "./aes-encrypt": {
+      "import": "./dist/esm/exports/aes-encrypt.js"
+    },
+    "./array-buffer-to-base64": {
+      "import": "./dist/esm/exports/array-buffer-to-base64.js"
+    },
+    "./base64-cleaner": {
+      "import": "./dist/esm/exports/base64-cleaner.js"
+    },
+    "./base64-to-array-buffer": {
+      "import": "./dist/esm/exports/base64-to-array-buffer.js"
+    },
+    "./decrypt": {
+      "import": "./dist/esm/exports/decrypt.js"
+    },
+    "./encrypt": {
+      "import": "./dist/esm/exports/encrypt.js"
+    },
+    "./export-key-pairs": {
+      "import": "./dist/esm/exports/export-key-pairs.js"
+    },
+    "./get-random-bytes": {
+      "import": "./dist/esm/exports/get-random-bytes.js"
+    },
+    "./get-random-values": {
+      "import": "./dist/esm/exports/get-random-values.js"
+    },
+    "./key-pairs": {
+      "import": "./dist/esm/exports/key-pairs.js"
+    },
+    "./rsa-decrypt": {
+      "import": "./dist/esm/exports/rsa-decrypt.js"
+    },
+    "./rsa-encrypt": {
+      "import": "./dist/esm/exports/rsa-encrypt.js"
+    },
+    "./uuidv4": {
+      "import": "./dist/esm/exports/uuidv4.js"
+    },
+    "./uuidv5": {
+      "import": "./dist/esm/exports/uuidv5.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "author": "Kuzuki Azusa",
+  "license": "MIT",
+  "keywords": [
+    "crypto",
+    "rsa",
+    "aes",
+    "hybrid-encrypt",
+    "web-crypto",
+    "node-crypto",
+    "cross-browser",
+    "cross-node",
+    "aes-gcm",
+    "rsa-oaep",
+    "encrypt",
+    "decrypt"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}