| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182 |
- import { FlattenedEncrypt } from '../flattened/encrypt.js';
- import { unprotected, assertNotSet } from '../../lib/helpers.js';
- import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
- import { generateCek } from '../../lib/content_encryption.js';
- import { isDisjoint } from '../../lib/type_checks.js';
- import { encryptKeyManagement } from '../../lib/key_management.js';
- import { encode as b64u } from '../../util/base64url.js';
- import { validateCrit } from '../../lib/validate_crit.js';
- import { normalizeKey } from '../../lib/normalize_key.js';
- import { checkKeyType } from '../../lib/check_key_type.js';
- class IndividualRecipient {
- #parent;
- unprotectedHeader;
- keyManagementParameters;
- key;
- options;
- constructor(enc, key, options) {
- this.#parent = enc;
- this.key = key;
- this.options = options;
- }
- setUnprotectedHeader(unprotectedHeader) {
- assertNotSet(this.unprotectedHeader, 'setUnprotectedHeader');
- this.unprotectedHeader = unprotectedHeader;
- return this;
- }
- setKeyManagementParameters(parameters) {
- assertNotSet(this.keyManagementParameters, 'setKeyManagementParameters');
- this.keyManagementParameters = parameters;
- return this;
- }
- addRecipient(...args) {
- return this.#parent.addRecipient(...args);
- }
- encrypt(...args) {
- return this.#parent.encrypt(...args);
- }
- done() {
- return this.#parent;
- }
- }
- export class GeneralEncrypt {
- #plaintext;
- #recipients = [];
- #protectedHeader;
- #unprotectedHeader;
- #aad;
- constructor(plaintext) {
- this.#plaintext = plaintext;
- }
- addRecipient(key, options) {
- const recipient = new IndividualRecipient(this, key, { crit: options?.crit });
- this.#recipients.push(recipient);
- return recipient;
- }
- setProtectedHeader(protectedHeader) {
- assertNotSet(this.#protectedHeader, 'setProtectedHeader');
- this.#protectedHeader = protectedHeader;
- return this;
- }
- setSharedUnprotectedHeader(sharedUnprotectedHeader) {
- assertNotSet(this.#unprotectedHeader, 'setSharedUnprotectedHeader');
- this.#unprotectedHeader = sharedUnprotectedHeader;
- return this;
- }
- setAdditionalAuthenticatedData(aad) {
- this.#aad = aad;
- return this;
- }
- async encrypt() {
- if (!this.#recipients.length) {
- throw new JWEInvalid('at least one recipient must be added');
- }
- if (this.#recipients.length === 1) {
- const [recipient] = this.#recipients;
- const flattened = await new FlattenedEncrypt(this.#plaintext)
- .setAdditionalAuthenticatedData(this.#aad)
- .setProtectedHeader(this.#protectedHeader)
- .setSharedUnprotectedHeader(this.#unprotectedHeader)
- .setUnprotectedHeader(recipient.unprotectedHeader)
- .encrypt(recipient.key, { ...recipient.options });
- const jwe = {
- ciphertext: flattened.ciphertext,
- iv: flattened.iv,
- recipients: [{}],
- tag: flattened.tag,
- };
- if (flattened.aad)
- jwe.aad = flattened.aad;
- if (flattened.protected)
- jwe.protected = flattened.protected;
- if (flattened.unprotected)
- jwe.unprotected = flattened.unprotected;
- if (flattened.encrypted_key)
- jwe.recipients[0].encrypted_key = flattened.encrypted_key;
- if (flattened.header)
- jwe.recipients[0].header = flattened.header;
- return jwe;
- }
- let enc;
- for (let i = 0; i < this.#recipients.length; i++) {
- const recipient = this.#recipients[i];
- if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader, recipient.unprotectedHeader)) {
- throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
- }
- const joseHeader = {
- ...this.#protectedHeader,
- ...this.#unprotectedHeader,
- ...recipient.unprotectedHeader,
- };
- const { alg } = joseHeader;
- if (typeof alg !== 'string' || !alg) {
- throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
- }
- if (alg === 'dir' || alg === 'ECDH-ES') {
- throw new JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
- }
- if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
- throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
- }
- if (!enc) {
- enc = joseHeader.enc;
- }
- else if (enc !== joseHeader.enc) {
- throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
- }
- validateCrit(JWEInvalid, new Map(), recipient.options.crit, this.#protectedHeader, joseHeader);
- if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
- throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
- }
- if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
- throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
- }
- }
- const cek = generateCek(enc);
- const jwe = {
- ciphertext: '',
- recipients: [],
- };
- for (let i = 0; i < this.#recipients.length; i++) {
- const recipient = this.#recipients[i];
- const target = {};
- jwe.recipients.push(target);
- if (i === 0) {
- const flattened = await new FlattenedEncrypt(this.#plaintext)
- .setAdditionalAuthenticatedData(this.#aad)
- .setContentEncryptionKey(cek)
- .setProtectedHeader(this.#protectedHeader)
- .setSharedUnprotectedHeader(this.#unprotectedHeader)
- .setUnprotectedHeader(recipient.unprotectedHeader)
- .setKeyManagementParameters(recipient.keyManagementParameters)
- .encrypt(recipient.key, {
- ...recipient.options,
- [unprotected]: true,
- });
- jwe.ciphertext = flattened.ciphertext;
- jwe.iv = flattened.iv;
- jwe.tag = flattened.tag;
- if (flattened.aad)
- jwe.aad = flattened.aad;
- if (flattened.protected)
- jwe.protected = flattened.protected;
- if (flattened.unprotected)
- jwe.unprotected = flattened.unprotected;
- target.encrypted_key = flattened.encrypted_key;
- if (flattened.header)
- target.header = flattened.header;
- continue;
- }
- const alg = recipient.unprotectedHeader?.alg ||
- this.#protectedHeader?.alg ||
- this.#unprotectedHeader?.alg;
- checkKeyType(alg === 'dir' ? enc : alg, recipient.key, 'encrypt');
- const k = await normalizeKey(recipient.key, alg);
- const { encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, cek, recipient.keyManagementParameters);
- target.encrypted_key = b64u(encryptedKey);
- if (recipient.unprotectedHeader || parameters)
- target.header = { ...recipient.unprotectedHeader, ...parameters };
- }
- return jwe;
- }
- }
|