@mojsoski/server-crypto/dist/lib/opt/node-crypto.js

Asymmetric key-exchange cryptography library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NodeCrypto = void 0;
const base64_utils_1 = require("../base64-utils");
const AES_ALGO = "aes-256-gcm";
function cryptoFrom(module) {
    return {
        async stringifyPrivateKey(key) {
            return (0, base64_utils_1.toBase64URL)(key.export({ format: "der", type: "pkcs8" }).toString("base64"));
        },
        async stringifyPublicKey(key) {
            return (0, base64_utils_1.toBase64URL)(key.export({ type: "spki", format: "der" }).toString("base64"));
        },
        async jwkPublicKey(key) {
            return key.export({ format: "jwk" });
        },
        async parsePrivateKey(base64url) {
            return module.createPrivateKey({
                key: Buffer.from((0, base64_utils_1.normalizeBase64)(base64url), "base64"),
                format: "der",
                type: "pkcs8",
            });
        },
        async parsePublicKey(base64url) {
            return module.createPublicKey({
                key: Buffer.from((0, base64_utils_1.normalizeBase64)(base64url), "base64"),
                format: "der",
                type: "spki",
            });
        },
        async randomBytes(amount) {
            return module.randomBytes(amount);
        },
        async publicEncrypt(data, publicKey) {
            return module.publicEncrypt({
                key: publicKey,
                padding: module.constants.RSA_PKCS1_OAEP_PADDING,
                oaepHash: "sha256",
            }, data);
        },
        async privateDecrypt(data, privateKey) {
            return module.privateDecrypt({
                key: privateKey,
                padding: module.constants.RSA_PKCS1_OAEP_PADDING,
                oaepHash: "sha256",
            }, data);
        },
        async encrypt(buffer, key, iv) {
            const cipher = module.createCipheriv(AES_ALGO, key, iv);
            const encrypted = Buffer.concat([cipher.update(buffer), cipher.final()]);
            const authTag = cipher.getAuthTag();
            return { authTag, content: encrypted };
        },
        async decrypt(buffer, authTag, key, iv) {
            const decipher = module.createDecipheriv(AES_ALGO, key, iv);
            decipher.setAuthTag(authTag);
            return Buffer.concat([decipher.update(buffer), decipher.final()]);
        },
    };
}
function jwtFrom(module) {
    return {
        async verifyRS256(jwt, publicKey) {
            return module.verify(jwt, publicKey, {
                algorithms: ["RS256"],
            });
        },
        async signRS256(obj, privateKey, expiresIn) {
            return module.sign(obj, privateKey, {
                algorithm: "RS256",
                expiresIn: expiresIn,
            });
        },
    };
}
class NodeCrypto {
    constructor(crypto, jsonwebtoken) {
        this.crypto = cryptoFrom(crypto);
        this.jwt = jwtFrom(jsonwebtoken);
    }
    jwt;
    crypto;
}
exports.NodeCrypto = NodeCrypto;
//# sourceMappingURL=node-crypto.js.map