@nfen/webcrypto-ts/lib/aes/aes_cbc.js

Enforced Webcrypto wrapper

/**
 * Code related to AES_CBC mode
 * @module
 */
import * as proxy from "../proxy.js";
import { AesShared, Alg, } from "./shared.js";
/** @hidden */
export const handler = {
    get(target, prop) {
        switch (prop) {
            case "self":
                return target;
            case "encrypt":
                return (algorithm, data) => encrypt(algorithm, target, data);
            case "decrypt":
                return (algorithm, data) => decrypt(algorithm, target, data);
            case "wrapKey":
                return (format, key, wrapAlgorithm) => wrapKey(format, key, target, wrapAlgorithm);
            case "unwrapKey":
                return (format, wrappedKey, wrappedKeyAlgorithm, unwrappingKeyAlgorithm, extractable, keyUsages) => unwrapKey(format, wrappedKey, wrappedKeyAlgorithm, target, unwrappingKeyAlgorithm, extractable, keyUsages);
            case "exportKey":
                return (format) => exportKey(format, target);
        }
        return Reflect.get(target, prop);
    },
};
/**
 * Generate a new AES_CBC key
 * @example
 * ```ts
 * const key = await AES_CBC.generateKey();
 * ```
 */
export async function generateKey(algorithm = {
    length: 256,
}, extractable = true, keyUsages) {
    const key = await AesShared.generateKey({
        ...algorithm,
        name: Alg.Mode.AES_CBC,
    }, extractable, keyUsages);
    return proxy.proxifyKey(handler)(key);
}
/**
 * Import an AES_CBC key
 * @example
 * ```ts
 * const jwk = await AES_CBC.importKey("jwk", jwk, {
 *     length: 256,
 * });
 * ```
 */
export async function importKey(format, key, algorithm, extractable, keyUsages) {
    const importedKey = (await AesShared.importKey(format, key, {
        ...algorithm,
        name: Alg.Mode.AES_CBC,
    }, extractable, keyUsages));
    return proxy.proxifyKey(handler)(importedKey);
}
/**
 * Export an AES_CBC key
 * @example
 * ```ts
 * const key = await AES_CBC.generateKey();
 * const jwk = await AES_CBC.exportKey("jwk", key.self);
 * ```
 * @example
 * ```ts
 * const key = await AES_CBC.generateKey();
 * const jwk = await key.exportKey("jwk");
 * ```
 */
export const exportKey = async (format, key) => AesShared.exportKey(format, key);
/**
 * Encrypt payload with an AES_CBC key
 * @example
 * ```ts
 * const key = await AES_CBC.generateKey();
 * const iv = await IV.generate();
 * const ciphertextBytes = await AES_CBC.encrypt(
 *     { iv },
 *    key.self,
 *    new TextEncoder().encode('message')
 * );
 * ```
 * @example
 * ```ts
 * const key = await AES_CBC.generateKey();
 * const iv = await IV.generate();
 * const ciphertextBytes = await key.encrypt(
 *     { iv },
 *    new TextEncoder().encode('message')
 * );
 * ```
 */
export async function encrypt(algorithm, key, data) {
    return await AesShared.encrypt({
        ...algorithm,
        name: Alg.Mode.AES_CBC,
    }, key, data);
}
/**
 * Decrypt data with an AES_CBC key
 * @example
 * ```ts
 * const plaintextBytes = await AES_CBC.decrypt(
 *    { iv },
 *    key.self,
 *    ciphertextBytes
 * );
 * ```
 * @example
 * ```ts
 * const plaintextBytes = await key.decrypt(
 *    { iv },
 *    ciphertextBytes
 * );
 * ```
 */
export async function decrypt(algorithm, key, data) {
    return await AesShared.decrypt({
        ...algorithm,
        name: Alg.Mode.AES_CBC,
    }, key, data);
}
/**
 * Wrap another key with an AES_CBC key
 * @example
 * ```ts
 * const kek = await AES_CBC.generateKey({ length: 256 }, true, [
 *    "wrapKey",
 *    "unwrapKey",
 * ]);
 * const dek: AesCbcCryptoKey = await AES_CBC.generateKey({
 *    length: 256,
 * });
 * const iv = await IV.generate();
 * const wrappedKey = await AES_CBC.wrapKey("raw", dek, kek, {
 *     iv,
 * });
 * ```
 * ```ts
 * const kek = await AES_CBC.generateKey({ length: 256 }, true, [
 *    "wrapKey",
 *    "unwrapKey",
 * ]);
 * const dek: AesCbcCryptoKey = await AES_CBC.generateKey({
 *    length: 256,
 * });
 * const iv = await IV.generate();
 * const wrappedKey = await kek.wrapKey("raw", dek.self, {
 *     iv,
 * });
 * ```
 */
export async function wrapKey(format, key, wrappingkey, wrapAlgorithm) {
    return await AesShared.wrapKey(format, key, wrappingkey, {
        ...wrapAlgorithm,
        name: Alg.Mode.AES_CBC,
    });
}
/**
 * Unwrap a wrapped key using the key encryption key
 * @example
 * ```ts
 * const wrappedKey = await AES_CBC.wrapKey("raw", dek.self, kek.self, {
 *     iv,
 * });
 * const unwrappedKey = await AES_CBC.unwrapKey(
 *    "raw",
 *    wrappedKey,
 *    { name: Alg.Mode.AES_CBC },
 *    kek.self,
 *    { iv }
 * );
 * ```
 * @example
 * ```ts
 * const wrappedKey = await AES_CBC.wrapKey("raw", dek.self, kek.self, {
 *     iv,
 * });
 * const unwrappedKey = await kek.unwrapKey(
 *    "raw",
 *    wrappedKey,
 *    { name: Alg.Mode.AES_CBC },
 *    { iv }
 * );
 * ```
 */
export async function unwrapKey(format, wrappedKey, wrappedKeyAlgorithm, unwrappingKey, unwrappingKeyAlgorithm, extractable = true, keyUsages) {
    return await AesShared.unwrapKey(format, wrappedKey, wrappedKeyAlgorithm, unwrappingKey, {
        ...unwrappingKeyAlgorithm,
        name: Alg.Mode.AES_CBC,
    }, extractable, keyUsages);
}
//# sourceMappingURL=aes_cbc.js.map