volter 0.0.171 → 0.0.173

package/dist/crypto.js

@@ -0,0 +1,141 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/crypto.ts
+function hash(password, hmac) {
+  const hasher = new Bun.CryptoHasher("sha256", hmac);
+  return hasher.update(password).digest("hex");
+}
+async function cryptoKey(raw) {
+  if (raw) {
+    if (raw instanceof CryptoKey)
+      return raw;
+    if (raw instanceof Uint8Array) {
+      if (raw.length === 32) {
+        return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
+      }
+      return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
+    }
+    if (raw.length === 64) {
+      return await crypto.subtle.importKey("raw", Uint8Array.fromHex(raw), {
+        name: "AES-GCM",
+        length: 256
+      }, true, ["encrypt", "decrypt"]);
+    } else {
+      return await crypto.subtle.importKey("raw", Uint8Array.fromHex(hash(raw)), {
+        name: "AES-GCM",
+        length: 256
+      }, true, ["encrypt", "decrypt"]);
+    }
+  } else {
+    return await crypto.subtle.generateKey({
+      name: "AES-GCM",
+      length: 256
+    }, true, ["encrypt", "decrypt"]);
+  }
+}
+async function exportKey(key, format) {
+  const buffer = await crypto.subtle.exportKey(format, key);
+  return new Uint8Array(buffer).toBase64();
+}
+async function generateECDSAKeyPair() {
+  return await crypto.subtle.generateKey({
+    name: "ECDSA",
+    namedCurve: "P-256"
+  }, true, ["sign", "verify"]);
+}
+async function exportJWK(key) {
+  return await crypto.subtle.exportKey("jwk", key);
+}
+async function importJWK(jwk, usage) {
+  return await crypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, true, usage);
+}
+async function sign(message, key) {
+  const data = new TextEncoder().encode(message);
+  const signature = await crypto.subtle.sign({
+    name: "ECDSA",
+    hash: { name: "SHA-256" }
+  }, key, data);
+  return new Uint8Array(signature);
+}
+async function verifySign(message, signature, key) {
+  const data = new TextEncoder().encode(message);
+  return await crypto.subtle.verify({
+    name: "ECDSA",
+    hash: { name: "SHA-256" }
+  }, key, signature, data);
+}
+async function cipher(text, key) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(text);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const buffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, await cryptoKey(key), data);
+  return {
+    text: new Uint8Array(buffer).toHex(),
+    iv,
+    buffer
+  };
+}
+async function decipher(cipher2, key) {
+  const decoder = new TextDecoder;
+  const buffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv: cipher2.iv }, await cryptoKey(key), Uint8Array.fromHex(cipher2.text));
+  const data = decoder.decode(buffer);
+  return data;
+}
+async function keypair() {
+  return await crypto.subtle.generateKey({
+    name: "RSA-OAEP",
+    modulusLength: 2048,
+    publicExponent: new Uint8Array([1, 0, 1]),
+    hash: { name: "SHA-256" }
+  }, true, ["encrypt", "decrypt"]);
+}
+async function encrypt(text, key) {
+  const data = new TextEncoder().encode(text);
+  const buffer = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, key, data);
+  return new Uint8Array(buffer);
+}
+async function decrypt(text, key) {
+  const buffer = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, key, text);
+  const data = new TextDecoder().decode(buffer);
+  return data;
+}
+export {
+  verifySign,
+  sign,
+  keypair,
+  importJWK,
+  hash,
+  generateECDSAKeyPair,
+  exportKey,
+  exportJWK,
+  encrypt,
+  decrypt,
+  decipher,
+  cryptoKey,
+  cipher
+};