encrypt.js 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167
  1. import { encode as b64u } from '../../util/base64url.js';
  2. import { unprotected, assertNotSet } from '../../lib/helpers.js';
  3. import { encrypt } from '../../lib/content_encryption.js';
  4. import { encryptKeyManagement } from '../../lib/key_management.js';
  5. import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
  6. import { isDisjoint } from '../../lib/type_checks.js';
  7. import { concat, encode } from '../../lib/buffer_utils.js';
  8. import { validateCrit } from '../../lib/validate_crit.js';
  9. import { normalizeKey } from '../../lib/normalize_key.js';
  10. import { checkKeyType } from '../../lib/check_key_type.js';
  11. import { compress } from '../../lib/deflate.js';
  12. export class FlattenedEncrypt {
  13. #plaintext;
  14. #protectedHeader;
  15. #sharedUnprotectedHeader;
  16. #unprotectedHeader;
  17. #aad;
  18. #cek;
  19. #iv;
  20. #keyManagementParameters;
  21. constructor(plaintext) {
  22. if (!(plaintext instanceof Uint8Array)) {
  23. throw new TypeError('plaintext must be an instance of Uint8Array');
  24. }
  25. this.#plaintext = plaintext;
  26. }
  27. setKeyManagementParameters(parameters) {
  28. assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
  29. this.#keyManagementParameters = parameters;
  30. return this;
  31. }
  32. setProtectedHeader(protectedHeader) {
  33. assertNotSet(this.#protectedHeader, 'setProtectedHeader');
  34. this.#protectedHeader = protectedHeader;
  35. return this;
  36. }
  37. setSharedUnprotectedHeader(sharedUnprotectedHeader) {
  38. assertNotSet(this.#sharedUnprotectedHeader, 'setSharedUnprotectedHeader');
  39. this.#sharedUnprotectedHeader = sharedUnprotectedHeader;
  40. return this;
  41. }
  42. setUnprotectedHeader(unprotectedHeader) {
  43. assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
  44. this.#unprotectedHeader = unprotectedHeader;
  45. return this;
  46. }
  47. setAdditionalAuthenticatedData(aad) {
  48. this.#aad = aad;
  49. return this;
  50. }
  51. setContentEncryptionKey(cek) {
  52. assertNotSet(this.#cek, 'setContentEncryptionKey');
  53. this.#cek = cek;
  54. return this;
  55. }
  56. setInitializationVector(iv) {
  57. assertNotSet(this.#iv, 'setInitializationVector');
  58. this.#iv = iv;
  59. return this;
  60. }
  61. async encrypt(key, options) {
  62. if (!this.#protectedHeader && !this.#unprotectedHeader && !this.#sharedUnprotectedHeader) {
  63. throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
  64. }
  65. if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader, this.#sharedUnprotectedHeader)) {
  66. throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
  67. }
  68. const joseHeader = {
  69. ...this.#protectedHeader,
  70. ...this.#unprotectedHeader,
  71. ...this.#sharedUnprotectedHeader,
  72. };
  73. validateCrit(JWEInvalid, new Map(), options?.crit, this.#protectedHeader, joseHeader);
  74. if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
  75. throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
  76. }
  77. if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
  78. throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
  79. }
  80. const { alg, enc } = joseHeader;
  81. if (typeof alg !== 'string' || !alg) {
  82. throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
  83. }
  84. if (typeof enc !== 'string' || !enc) {
  85. throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
  86. }
  87. let encryptedKey;
  88. if (this.#cek && (alg === 'dir' || alg === 'ECDH-ES')) {
  89. throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
  90. }
  91. checkKeyType(alg === 'dir' ? enc : alg, key, 'encrypt');
  92. let cek;
  93. {
  94. let parameters;
  95. const k = await normalizeKey(key, alg);
  96. ({ cek, encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, this.#cek, this.#keyManagementParameters));
  97. if (parameters) {
  98. if (options && unprotected in options) {
  99. if (!this.#unprotectedHeader) {
  100. this.setUnprotectedHeader(parameters);
  101. }
  102. else {
  103. this.#unprotectedHeader = { ...this.#unprotectedHeader, ...parameters };
  104. }
  105. }
  106. else if (!this.#protectedHeader) {
  107. this.setProtectedHeader(parameters);
  108. }
  109. else {
  110. this.#protectedHeader = { ...this.#protectedHeader, ...parameters };
  111. }
  112. }
  113. }
  114. let additionalData;
  115. let protectedHeaderS;
  116. let protectedHeaderB;
  117. let aadMember;
  118. if (this.#protectedHeader) {
  119. protectedHeaderS = b64u(JSON.stringify(this.#protectedHeader));
  120. protectedHeaderB = encode(protectedHeaderS);
  121. }
  122. else {
  123. protectedHeaderS = '';
  124. protectedHeaderB = new Uint8Array();
  125. }
  126. if (this.#aad) {
  127. aadMember = b64u(this.#aad);
  128. const aadMemberBytes = encode(aadMember);
  129. additionalData = concat(protectedHeaderB, encode('.'), aadMemberBytes);
  130. }
  131. else {
  132. additionalData = protectedHeaderB;
  133. }
  134. let plaintext = this.#plaintext;
  135. if (joseHeader.zip === 'DEF') {
  136. plaintext = await compress(plaintext).catch((cause) => {
  137. throw new JWEInvalid('Failed to compress plaintext', { cause });
  138. });
  139. }
  140. const { ciphertext, tag, iv } = await encrypt(enc, plaintext, cek, this.#iv, additionalData);
  141. const jwe = {
  142. ciphertext: b64u(ciphertext),
  143. };
  144. if (iv) {
  145. jwe.iv = b64u(iv);
  146. }
  147. if (tag) {
  148. jwe.tag = b64u(tag);
  149. }
  150. if (encryptedKey) {
  151. jwe.encrypted_key = b64u(encryptedKey);
  152. }
  153. if (aadMember) {
  154. jwe.aad = aadMember;
  155. }
  156. if (this.#protectedHeader) {
  157. jwe.protected = protectedHeaderS;
  158. }
  159. if (this.#sharedUnprotectedHeader) {
  160. jwe.unprotected = this.#sharedUnprotectedHeader;
  161. }
  162. if (this.#unprotectedHeader) {
  163. jwe.header = this.#unprotectedHeader;
  164. }
  165. return jwe;
  166. }
  167. }