tink-crypto/esm2015/subtle/ecies_aead_hkdf_hybrid_encrypt.js

A multi-language, cross-platform library that provides cryptographic APIs that are secure, easy to use correctly, and hard(er) to misuse.

/**
 * @license
 * Copyright 2020 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { SecurityException } from '../exception/security_exception';
import { HybridEncrypt } from '../hybrid/internal/hybrid_encrypt';
import * as Bytes from './bytes';
import * as sender from './ecies_hkdf_kem_sender';
/**
 * Implementation of ECIES AEAD HKDF hybrid encryption.
 *
 * @final
 */
export class EciesAeadHkdfHybridEncrypt extends HybridEncrypt {
    /**
     * @param hkdfHash the name of the HMAC algorithm, accepted names
     *     are: SHA-1, SHA-256 and SHA-512.
     */
    constructor(kemSender, hkdfHash, pointFormat, demHelper, opt_hkdfSalt) {
        super();
        // TODO(thaidn): do we actually need these null checks?
        if (!kemSender) {
            throw new SecurityException('KEM sender has to be non-null.');
        }
        if (!hkdfHash) {
            throw new SecurityException('HMAC algorithm has to be non-null.');
        }
        if (!pointFormat) {
            throw new SecurityException('Point format has to be non-null.');
        }
        if (!demHelper) {
            throw new SecurityException('DEM helper has to be non-null.');
        }
        this.kemSender_ = kemSender;
        this.hkdfHash_ = hkdfHash;
        this.pointFormat_ = pointFormat;
        this.demHelper_ = demHelper;
        this.hkdfSalt = opt_hkdfSalt;
    }
    /**
     * Encrypts plaintext using opt_contextInfo as info parameter of the
     * underlying HKDF.
     *
     */
    encrypt(plaintext, associatedData = new Uint8Array(0)) {
        return __awaiter(this, void 0, void 0, function* () {
            const keySizeInBytes = this.demHelper_.getDemKeySizeInBytes();
            const kemKey = yield this.kemSender_.encapsulate(keySizeInBytes, this.pointFormat_, this.hkdfHash_, associatedData, this.hkdfSalt);
            const aead = yield this.demHelper_.getAead(kemKey['key']);
            const ciphertextBody = yield aead.encrypt(plaintext);
            const header = kemKey['token'];
            return Bytes.concat(header, ciphertextBody);
        });
    }
}
/**
 * @param hkdfHash the name of the HMAC algorithm, accepted names
 *     are: SHA-1, SHA-256 and SHA-512.
 */
export function fromJsonWebKey(recipientPublicKey, hkdfHash, pointFormat, demHelper, opt_hkdfSalt) {
    return __awaiter(this, void 0, void 0, function* () {
        if (!recipientPublicKey) {
            throw new SecurityException('Recipient public key has to be non-null.');
        }
        if (!hkdfHash) {
            throw new SecurityException('HMAC algorithm has to be non-null.');
        }
        if (!pointFormat) {
            throw new SecurityException('Point format has to be non-null.');
        }
        if (!demHelper) {
            throw new SecurityException('DEM helper has to be non-null.');
        }
        const kemSender = yield sender.fromJsonWebKey(recipientPublicKey);
        return new EciesAeadHkdfHybridEncrypt(kemSender, hkdfHash, pointFormat, demHelper, opt_hkdfSalt);
    });
}
//# sourceMappingURL=data:application/json;base64,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