@nfen/webcrypto-ts/lib/rsa/rsa_pss.js

Enforced Webcrypto wrapper

/**
 * Code related to RSA_PSS
 * @module
 */
import * as proxy from "../proxy.js";
import { Alg as SHA } from "../sha/shared.js";
import { Alg, RsaShared, } from "./shared.js";
const handlers = {
    privHandler: {
        get(target, prop) {
            switch (prop) {
                case "self":
                    return target;
                case "sign":
                    return (saltLength, data) => sign(saltLength, target, data);
                case "exportKey":
                    return (format) => exportKey(format, target);
            }
            return Reflect.get(target, prop);
        },
    },
    pubHandler: {
        get(target, prop) {
            switch (prop) {
                case "self":
                    return target;
                case "verify":
                    return (saltLength, signature, data) => verify(saltLength, target, signature, data);
                case "exportKey":
                    return (format) => exportKey(format, target);
            }
            return Reflect.get(target, prop);
        },
    },
};
/**
 * Generate a new RSA_PSS keypair
 * @example
 * ```ts
 * const keyPair = await RSA_PSS.generateKey();
 * ```
 */
export const generateKey = async (algorithm = {
    hash: SHA.Variant.SHA_512,
    modulusLength: 4096,
    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
}, extractable, keyUsages) => {
    const keyPair = (await RsaShared.generateKey({
        ...algorithm,
        name: Alg.Variant.RSA_PSS,
    }, extractable, keyUsages));
    return proxy.proxifyKeyPair(handlers)(keyPair);
};
/**
 * Generate a new RSA_PSS keypair
 * @alias generateKey
 * @example
 * ```ts
 * const keyPair = await RSA_PSS.generateKeyPair();
 * ```
 */
export const generateKeyPai = generateKey;
/**
 * Import an RSA_PSS public or private key
 * @example
 * ```ts
 * const key = await RSA_PSS.importKey("jwk", pubKey, { hash: "SHA-512" }, true, ['verify']);
 * ```
 */
export const importKey = async (format, key, algorithm, extractable, keyUsages) => {
    const importedKey = await RsaShared.importKey(format, key, { ...algorithm, name: Alg.Variant.RSA_PSS }, extractable, keyUsages);
    if (importedKey.type === "private") {
        return proxy.proxifyKey(handlers.privHandler)(importedKey);
    }
    else {
        return proxy.proxifyKey(handlers.pubHandler)(importedKey);
    }
};
/**
 * Export an RSA_PSS public or private key
 * @example
 * ```ts
 * const pubKeyJwk = await RSA_PSS.importKey("jwk", keyPair.publicKey.self);
 * ```
 * @example
 * ```ts
 * const pubKeyJwk = await keyPair.publicKey.importKey("jwk");
 * ```
 */
export const exportKey = async (format, key) => RsaShared.exportKey(format, key);
/**
 * Sign a given payload
 * @example
 * ```ts
 * const message = new TextEncoder().encode("a message");
 * const signature = await RSA_PSS.sign(128, keyPair.privateKey.self, message);
 * ```
 * @example
 * ```ts
 * const message = new TextEncoder().encode("a message");
 * const signature = await keyPair.privateKey.sign(128, message);
 * ```
 */
export const sign = async (saltLength, key, data) => await RsaShared.sign({
    name: Alg.Variant.RSA_PSS,
    saltLength,
}, key, data);
/**
 * Verify a given signature
 * @example
 * ```ts
 * const message = new TextEncoder().encode("a message");
 * const isVerified = await ECDSA.verify(128, keyPair.publicKey.self, signature, message);
 * ```
 * @example
 * ```ts
 * const message = new TextEncoder().encode("a message");
 * const isVerified = await keyPair.publicKey.verify(128, signature, message);
 * ```
 */
export const verify = async (saltLength, key, signature, data) => await RsaShared.verify({
    name: Alg.Variant.RSA_PSS,
    saltLength,
}, key, signature, data);
//# sourceMappingURL=rsa_pss.js.map