@sebastienrousseau/crypto-lib 0.0.3 → 0.0.8

package/dist/keys/keygen.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_ALGORITHMS = void 0;
+exports.generateKeyPair = generateKeyPair;
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const ed448_js_1 = require("@noble/curves/ed448.js");
+const nist_js_1 = require("@noble/curves/nist.js");
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const ml_dsa_js_1 = require("@noble/post-quantum/ml-dsa.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const serialize_1 = require("./serialize");
+exports.KEY_ALGORITHMS = [
+    "ed25519",
+    "x25519",
+    "ed448",
+    "x448",
+    "p256",
+    "p384",
+    "ml-kem-512",
+    "ml-kem-768",
+    "ml-kem-1024",
+    "ml-dsa-44",
+    "ml-dsa-65",
+    "ml-dsa-87",
+];
+function toHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+function generateKid(publicKey) {
+    const digest = (0, sha2_js_1.sha256)(publicKey);
+    return (0, serialize_1.bytesToBase64url)(digest.subarray(0, 16));
+}
+function generateKeyPair(algorithm, metadata = {}) {
+    let publicKey;
+    let privateKey;
+    switch (algorithm) {
+        case "ed25519": {
+            const priv = ed25519_js_1.ed25519.utils.randomSecretKey();
+            const pub = ed25519_js_1.ed25519.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "x25519": {
+            const priv = (0, utils_js_1.randomBytes)(32);
+            const pub = ed25519_js_1.x25519.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "ed448": {
+            const priv = ed448_js_1.ed448.utils.randomSecretKey();
+            const pub = ed448_js_1.ed448.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "x448": {
+            const priv = (0, utils_js_1.randomBytes)(56);
+            const pub = ed448_js_1.x448.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "p256": {
+            const priv = nist_js_1.p256.utils.randomSecretKey();
+            const pub = nist_js_1.p256.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "p384": {
+            const priv = nist_js_1.p384.utils.randomSecretKey();
+            const pub = nist_js_1.p384.getPublicKey(priv);
+            privateKey = priv;
+            publicKey = pub;
+            break;
+        }
+        case "ml-kem-512": {
+            const kp = ml_kem_js_1.ml_kem512.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        case "ml-kem-768": {
+            const kp = ml_kem_js_1.ml_kem768.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        case "ml-kem-1024": {
+            const kp = ml_kem_js_1.ml_kem1024.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        case "ml-dsa-44": {
+            const kp = ml_dsa_js_1.ml_dsa44.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        case "ml-dsa-65": {
+            const kp = ml_dsa_js_1.ml_dsa65.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        case "ml-dsa-87": {
+            const kp = ml_dsa_js_1.ml_dsa87.keygen();
+            publicKey = kp.publicKey;
+            privateKey = kp.secretKey;
+            break;
+        }
+        default:
+            throw new Error(`Unsupported algorithm: ${algorithm}. Supported: ${exports.KEY_ALGORITHMS.join(", ")}`);
+    }
+    const kid = metadata.kid ?? generateKid(publicKey);
+    return {
+        publicKey: toHex(publicKey),
+        privateKey: toHex(privateKey),
+        algorithm,
+        kid,
+        metadata: { ...metadata, kid },
+    };
+}
+//# sourceMappingURL=keygen.js.map

package/dist/keys/keyring.d.ts

@@ -0,0 +1,35 @@
+import { type KeyAlgorithm, type KeyMetadata } from "./keygen";
+import { type Jwk } from "./serialize";
+export interface KeyEntry {
+    kid: string;
+    algorithm: KeyAlgorithm;
+    publicKey: string;
+    privateKey: string;
+    use?: "sig" | "enc" | undefined;
+    exp?: string | undefined;
+    createdAt: string;
+    archived: boolean;
+}
+export interface Jwks {
+    keys: Jwk[];
+}
+export declare class Keyring {
+    private keys;
+    get size(): number;
+    add(algorithm: KeyAlgorithm, metadata?: KeyMetadata): KeyEntry;
+    import(entry: KeyEntry): void;
+    get(kid: string): KeyEntry | undefined;
+    delete(kid: string): boolean;
+    list(filters?: {
+        algorithm?: KeyAlgorithm;
+        use?: "sig" | "enc";
+        includeArchived?: boolean;
+    }): KeyEntry[];
+    rotate(kid: string): KeyEntry;
+    toJwks(): Jwks;
+    serialize(): string;
+    static deserialize(json: string): Keyring;
+    toEncrypted(key: string | Uint8Array): string;
+    static fromEncrypted(key: string | Uint8Array, encrypted: string): Keyring;
+}
+//# sourceMappingURL=keyring.d.ts.map

package/dist/keys/keyring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.d.ts","sourceRoot":"","sources":["../../src/keys/keyring.ts"],"names":[],"mappings":"AAeA,OAAO,EAAmB,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAA6B,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AAMlE,MAAM,WAAW,QAAQ;IAEvB,GAAG,EAAE,MAAM,CAAC;IAEZ,SAAS,EAAE,YAAY,CAAC;IAExB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;IAEhC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEzB,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAGD,MAAM,WAAW,IAAI;IAEnB,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAKD,qBAAa,OAAO;IAClB,OAAO,CAAC,IAAI,CAAoC;IAGhD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAKD,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAE,WAAgB,GAAG,QAAQ;IAmBlE,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAO7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAOtC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAO5B,IAAI,CAAC,OAAO,CAAC,EAAE;QACb,SAAS,CAAC,EAAE,YAAY,CAAC;QACzB,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;QACpB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,GAAG,QAAQ,EAAE;IAsBd,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAgB7B,MAAM,IAAI,IAAI;IA2Bd,SAAS,IAAI,MAAM;IAOnB,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAczC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM;IAY7C,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;CAK3E"}

package/dist/keys/keyring.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keyring = void 0;
+const keygen_1 = require("./keygen");
+const serialize_1 = require("./serialize");
+const secretbox = __importStar(require("../high-level/secretbox"));
+class Keyring {
+    keys = new Map();
+    get size() {
+        return this.keys.size;
+    }
+    add(algorithm, metadata = {}) {
+        const kp = (0, keygen_1.generateKeyPair)(algorithm, metadata);
+        const entry = {
+            kid: kp.kid,
+            algorithm: kp.algorithm,
+            publicKey: kp.publicKey,
+            privateKey: kp.privateKey,
+            use: metadata.use,
+            exp: metadata.exp,
+            createdAt: new Date().toISOString(),
+            archived: false,
+        };
+        this.keys.set(entry.kid, entry);
+        return entry;
+    }
+    import(entry) {
+        this.keys.set(entry.kid, entry);
+    }
+    get(kid) {
+        return this.keys.get(kid);
+    }
+    delete(kid) {
+        return this.keys.delete(kid);
+    }
+    list(filters) {
+        let entries = Array.from(this.keys.values());
+        if (!filters?.includeArchived) {
+            entries = entries.filter((e) => !e.archived);
+        }
+        if (filters?.algorithm) {
+            entries = entries.filter((e) => e.algorithm === filters.algorithm);
+        }
+        if (filters?.use) {
+            entries = entries.filter((e) => e.use === filters.use);
+        }
+        return entries;
+    }
+    rotate(kid) {
+        const old = this.keys.get(kid);
+        if (!old)
+            throw new Error(`Key not found: ${kid}`);
+        old.archived = true;
+        return this.add(old.algorithm, {
+            use: old.use,
+            exp: old.exp,
+        });
+    }
+    toJwks() {
+        const jwks = [];
+        for (const entry of this.keys.values()) {
+            if (entry.archived)
+                continue;
+            let jwk = null;
+            if (entry.algorithm === "ed25519") {
+                jwk = (0, serialize_1.ed25519ToJwk)(entry.publicKey);
+            }
+            else if (entry.algorithm === "x25519") {
+                jwk = (0, serialize_1.x25519ToJwk)(entry.publicKey);
+            }
+            if (jwk) {
+                jwk.kid = entry.kid;
+                if (entry.use)
+                    jwk.use = entry.use;
+                jwks.push(jwk);
+            }
+        }
+        return { keys: jwks };
+    }
+    serialize() {
+        return JSON.stringify(Array.from(this.keys.entries()));
+    }
+    static deserialize(json) {
+        const ring = new Keyring();
+        const entries = JSON.parse(json);
+        for (const [kid, entry] of entries) {
+            ring.keys.set(kid, entry);
+        }
+        return ring;
+    }
+    toEncrypted(key) {
+        const json = this.serialize();
+        const result = secretbox.seal(key, json);
+        return result.sealed;
+    }
+    static fromEncrypted(key, encrypted) {
+        const decrypted = secretbox.open(key, encrypted);
+        const json = Buffer.from(decrypted).toString("utf8");
+        return Keyring.deserialize(json);
+    }
+}
+exports.Keyring = Keyring;
+//# sourceMappingURL=keyring.js.map

package/dist/keys/serialize.d.ts

@@ -0,0 +1,30 @@
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function base64ToBytes(b64: string): Uint8Array;
+export declare function bytesToBase64url(bytes: Uint8Array): string;
+export declare function base64urlToBytes(b64url: string): Uint8Array;
+export type PemLabel = "PUBLIC KEY" | "PRIVATE KEY" | "CERTIFICATE" | "ED25519 PRIVATE KEY" | "ED25519 PUBLIC KEY" | "X25519 PRIVATE KEY" | "X25519 PUBLIC KEY";
+export declare function encodePem(label: PemLabel, der: Uint8Array): string;
+export declare function decodePem(pem: string): {
+    label: string;
+    data: Uint8Array;
+};
+export interface Jwk {
+    kty: string;
+    crv?: string;
+    alg?: string;
+    use?: string;
+    kid?: string;
+    x?: string;
+    d?: string;
+    [key: string]: unknown;
+}
+export declare function ed25519ToJwk(publicKeyHex: string, privateKeyHex?: string): Jwk;
+export declare function x25519ToJwk(publicKeyHex: string, privateKeyHex?: string): Jwk;
+export declare function jwkToHex(jwk: Jwk): {
+    publicKey: string;
+    privateKey?: string;
+};
+export declare function jwkThumbprint(jwk: Jwk): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/keys/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/keys/serialize.ts"],"names":[],"mappings":"AAiBA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAIlD;AAGD,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEpD;AAGD,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEvD;AAGD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAErD;AAGD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAI3D;AAKD,MAAM,MAAM,QAAQ,GAChB,YAAY,GACZ,aAAa,GACb,aAAa,GACb,qBAAqB,GACrB,oBAAoB,GACpB,oBAAoB,GACpB,mBAAmB,CAAC;AAKxB,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAOlE;AAKD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG;IAEtC,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,EAAE,UAAU,CAAC;CAClB,CAkBA;AAKD,MAAM,WAAW,GAAG;IAElB,GAAG,EAAE,MAAM,CAAC;IAEZ,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,CAAC,CAAC,EAAE,MAAM,CAAC;IAEX,CAAC,CAAC,EAAE,MAAM,CAAC;IAEX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAKD,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,GACrB,GAAG,CAYL;AAKD,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,GAAG,CAY7E;AAKD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG;IAElC,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAUA;AAKD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAa9C"}

package/dist/keys/serialize.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBytes = hexToBytes;
+exports.bytesToHex = bytesToHex;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+exports.bytesToBase64url = bytesToBase64url;
+exports.base64urlToBytes = base64urlToBytes;
+exports.encodePem = encodePem;
+exports.decodePem = decodePem;
+exports.ed25519ToJwk = ed25519ToJwk;
+exports.x25519ToJwk = x25519ToJwk;
+exports.jwkToHex = jwkToHex;
+exports.jwkThumbprint = jwkThumbprint;
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+function hexToBytes(hex) {
+    if (!/^[0-9a-fA-F]*$/.test(hex))
+        throw new Error("Invalid hex string");
+    if (hex.length % 2 !== 0)
+        throw new Error("Hex string must have even length");
+    return Buffer.from(hex, "hex");
+}
+function bytesToHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+function bytesToBase64(bytes) {
+    return Buffer.from(bytes).toString("base64");
+}
+function base64ToBytes(b64) {
+    return Buffer.from(b64, "base64");
+}
+function bytesToBase64url(bytes) {
+    return Buffer.from(bytes).toString("base64url");
+}
+function base64urlToBytes(b64url) {
+    const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = (4 - (b64.length % 4)) % 4;
+    return Buffer.from(b64 + "=".repeat(pad), "base64");
+}
+function encodePem(label, der) {
+    const b64 = Buffer.from(der).toString("base64");
+    const lines = [];
+    for (let i = 0; i < b64.length; i += 64) {
+        lines.push(b64.slice(i, i + 64));
+    }
+    return `-----BEGIN ${label}-----\n${lines.join("\n")}\n-----END ${label}-----\n`;
+}
+function decodePem(pem) {
+    const beginMarker = "-----BEGIN ";
+    const endMarker = "-----END ";
+    const beginIdx = pem.indexOf(beginMarker);
+    if (beginIdx === -1)
+        throw new Error("Invalid PEM format");
+    const headerEnd = pem.indexOf("-----", beginIdx + beginMarker.length);
+    if (headerEnd === -1)
+        throw new Error("Invalid PEM format");
+    const label = pem.slice(beginIdx + beginMarker.length, headerEnd).trim();
+    if (!label)
+        throw new Error("Invalid PEM format");
+    const closeTag = `${endMarker}${label}-----`;
+    const endIdx = pem.indexOf(closeTag, headerEnd + 5);
+    if (endIdx === -1)
+        throw new Error("Invalid PEM format");
+    const b64 = pem.slice(headerEnd + 5, endIdx).replace(/\s/g, "");
+    return { label, data: Buffer.from(b64, "base64") };
+}
+function ed25519ToJwk(publicKeyHex, privateKeyHex) {
+    const pub = hexToBytes(publicKeyHex);
+    const jwk = {
+        kty: "OKP",
+        crv: "Ed25519",
+        alg: "EdDSA",
+        x: bytesToBase64url(pub),
+    };
+    if (privateKeyHex) {
+        jwk.d = bytesToBase64url(hexToBytes(privateKeyHex));
+    }
+    return jwk;
+}
+function x25519ToJwk(publicKeyHex, privateKeyHex) {
+    const pub = hexToBytes(publicKeyHex);
+    const jwk = {
+        kty: "OKP",
+        crv: "X25519",
+        alg: "ECDH-ES",
+        x: bytesToBase64url(pub),
+    };
+    if (privateKeyHex) {
+        jwk.d = bytesToBase64url(hexToBytes(privateKeyHex));
+    }
+    return jwk;
+}
+function jwkToHex(jwk) {
+    if (!jwk.x)
+        throw new Error("JWK missing 'x' (public key) field");
+    const pub = base64urlToBytes(jwk.x);
+    const result = {
+        publicKey: bytesToHex(pub),
+    };
+    if (jwk.d) {
+        result.privateKey = bytesToHex(base64urlToBytes(jwk.d));
+    }
+    return result;
+}
+function jwkThumbprint(jwk) {
+    let members;
+    if (jwk.kty === "OKP") {
+        members = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
+    }
+    else if (jwk.kty === "EC") {
+        members = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk["y"] };
+    }
+    else {
+        members = { kty: jwk.kty };
+    }
+    const json = JSON.stringify(members, Object.keys(members).sort());
+    const digest = (0, sha2_js_1.sha256)(Buffer.from(json, "utf8"));
+    return bytesToBase64url(digest);
+}
+//# sourceMappingURL=serialize.js.map

package/dist/lib/decrypt.d.ts

@@ -1,4 +1,7 @@
 import * as types from "../types/types";
-export declare const decrypt: (data: types.dataDecrypt) => Promise<object>;
+export declare const decrypt: (data: types.dataDecrypt) => Promise<{
+    data: string;
+    signatureValid: boolean;
+}>;
 export default decrypt;
 //# sourceMappingURL=decrypt.d.ts.map

package/dist/lib/decrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decrypt.d.ts","sourceRoot":"","sources":["../../src/lib/decrypt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AA4CxC,eAAO,MAAM,OAAO,SAAgB,MAAM,WAAW,KAAG,QAAQ,MAAM,CA8CrE,CAAC;AAmBF,eAAe,OAAO,CAAC"}
+{"version":3,"file":"decrypt.d.ts","sourceRoot":"","sources":["../../src/lib/decrypt.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AA0BxC,eAAO,MAAM,OAAO,GAClB,MAAM,KAAK,CAAC,WAAW,KACtB,OAAO,CAAC;IAET,IAAI,EAAE,MAAM,CAAC;IAEb,cAAc,EAAE,OAAO,CAAC;CACzB,CA8CA,CAAC;AAGF,eAAe,OAAO,CAAC"}

package/dist/lib/decrypt.js

@@ -15,67 +15,59 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decrypt = void 0;
-const fs = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = require("fs");
 const openpgp = __importStar(require("openpgp"));
-const args = process.argv.slice(2);
+const keystore_1 = require("../key/keystore");
 const decrypt = async (data) => {
-    const message = Buffer.from(data.encryptedMessage, "base64").toString("utf-8");
-    const passphrase = data.passphrase;
-    const publicKeyArmored = Buffer.from(data.publicKey.toString(), "base64").toString("utf-8");
-    const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
-    const privateKeyBase64 = (0, fs_1.readFileSync)(path_1.default.resolve(__dirname, "../key/rsa.key"));
-    const privateKeyArmored = Buffer.from(privateKeyBase64.toString(), "base64").toString("utf-8");
-    const privateKey = await openpgp.decryptKey({
-        privateKey: await openpgp.readPrivateKey({ armoredKey: privateKeyArmored }),
-        passphrase,
+    const { message: encryptedMessage, passphrase, publicKey: publicKeyBase64, privateKey: privateKeyBase64, } = data;
+    if (!privateKeyBase64) {
+        throw new Error("Private key is required for decryption");
+    }
+    const message = await openpgp.readMessage({
+        armoredMessage: Buffer.from(encryptedMessage, "base64").toString("latin1"),
     });
+    const publicKeyArmored = Buffer.from(publicKeyBase64, "base64").toString("latin1");
+    const privateKeyArmored = Buffer.from(privateKeyBase64, "base64").toString("latin1");
+    const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+    const privateKey = await (0, keystore_1.unlockPrivateKey)(privateKeyArmored, passphrase);
     const { data: decrypted, signatures } = await openpgp.decrypt({
-        message: await openpgp.readMessage({ armoredMessage: message }),
+        message,
         verificationKeys: publicKey,
         decryptionKeys: privateKey,
     });
-    console.log(decrypted);
-    await signatures[0].verified;
-    console.log("Signature is valid");
-    const decryptedMsg = await fs.createWriteStream(path_1.default.resolve(__dirname, "../data/decrypted.txt"), { encoding: "ascii" });
-    const decryptedString = decrypted.toString();
-    decryptedMsg.write(Buffer.from(decryptedString).toString("base64"));
-    decryptedMsg.on("finish", () => {
-        console.log("✅ Wrote decrypted message data to file");
-    });
-    decryptedMsg.end();
-    return decrypted;
-};
-exports.decrypt = decrypt;
-if (args instanceof Array && args.length) {
-    if (args[0] === "decrypt") {
-        const data = {
-            passphrase: args[2],
-            encryptedMessage: args[4],
-            publicKey: args[6],
-        };
-        (0, exports.decrypt)(data);
+    let signatureValid = false;
+    if (signatures.length > 0) {
+        try {
+            await signatures[0].verified;
+            signatureValid = true;
+        }
+        catch {
+            signatureValid = false;
+        }
     }
-    const data = {
-        passphrase: args[1],
-        encryptedMessage: args[3],
-        publicKey: args[5],
+    return {
+        data: decrypted,
+        signatureValid,
     };
-    (0, exports.decrypt)(data);
-}
+};
+exports.decrypt = decrypt;
 exports.default = exports.decrypt;
 //# sourceMappingURL=decrypt.js.map

package/dist/lib/encrypt.d.ts

@@ -1,4 +1,4 @@
 import * as types from "../types/types";
-export declare const encrypt: (data: types.dataEncrypt) => Promise<object>;
+export declare const encrypt: (data: types.dataEncrypt) => Promise<string>;
 export default encrypt;
 //# sourceMappingURL=encrypt.d.ts.map

package/dist/lib/encrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../src/lib/encrypt.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AAyCxC,eAAO,MAAM,OAAO,SAAgB,MAAM,WAAW,KAAG,QAAQ,MAAM,CAwCrE,CAAC;AAmBF,eAAe,OAAO,CAAC"}
+{"version":3,"file":"encrypt.d.ts","sourceRoot":"","sources":["../../src/lib/encrypt.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AAaxC,eAAO,MAAM,OAAO,GAAU,MAAM,KAAK,CAAC,WAAW,KAAG,OAAO,CAAC,MAAM,CA+BrE,CAAC;AAGF,eAAe,OAAO,CAAC"}