normalize_key.js 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. import { isJWK } from './type_checks.js';
  2. import { decode } from '../util/base64url.js';
  3. import { jwkToKey } from './jwk_to_key.js';
  4. import { isCryptoKey, isKeyObject } from './is_key_like.js';
  5. const unusableForAlg = 'given KeyObject instance cannot be used for this algorithm';
  6. let cache;
  7. const handleJWK = async (key, jwk, alg, freeze = false) => {
  8. cache ||= new WeakMap();
  9. let cached = cache.get(key);
  10. if (cached?.[alg]) {
  11. return cached[alg];
  12. }
  13. const cryptoKey = await jwkToKey({ ...jwk, alg });
  14. if (freeze)
  15. Object.freeze(key);
  16. if (!cached) {
  17. cache.set(key, { [alg]: cryptoKey });
  18. }
  19. else {
  20. cached[alg] = cryptoKey;
  21. }
  22. return cryptoKey;
  23. };
  24. const handleKeyObject = (keyObject, alg) => {
  25. cache ||= new WeakMap();
  26. let cached = cache.get(keyObject);
  27. if (cached?.[alg]) {
  28. return cached[alg];
  29. }
  30. const isPublic = keyObject.type === 'public';
  31. const extractable = isPublic ? true : false;
  32. let cryptoKey;
  33. if (keyObject.asymmetricKeyType === 'x25519') {
  34. switch (alg) {
  35. case 'ECDH-ES':
  36. case 'ECDH-ES+A128KW':
  37. case 'ECDH-ES+A192KW':
  38. case 'ECDH-ES+A256KW':
  39. break;
  40. default:
  41. throw new TypeError(unusableForAlg);
  42. }
  43. cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ['deriveBits']);
  44. }
  45. if (keyObject.asymmetricKeyType === 'ed25519') {
  46. if (alg !== 'EdDSA' && alg !== 'Ed25519') {
  47. throw new TypeError(unusableForAlg);
  48. }
  49. cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
  50. isPublic ? 'verify' : 'sign',
  51. ]);
  52. }
  53. switch (keyObject.asymmetricKeyType) {
  54. case 'ml-dsa-44':
  55. case 'ml-dsa-65':
  56. case 'ml-dsa-87': {
  57. if (alg !== keyObject.asymmetricKeyType.toUpperCase()) {
  58. throw new TypeError(unusableForAlg);
  59. }
  60. cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
  61. isPublic ? 'verify' : 'sign',
  62. ]);
  63. }
  64. }
  65. if (keyObject.asymmetricKeyType === 'rsa') {
  66. let hash;
  67. switch (alg) {
  68. case 'RSA-OAEP':
  69. hash = 'SHA-1';
  70. break;
  71. case 'RS256':
  72. case 'PS256':
  73. case 'RSA-OAEP-256':
  74. hash = 'SHA-256';
  75. break;
  76. case 'RS384':
  77. case 'PS384':
  78. case 'RSA-OAEP-384':
  79. hash = 'SHA-384';
  80. break;
  81. case 'RS512':
  82. case 'PS512':
  83. case 'RSA-OAEP-512':
  84. hash = 'SHA-512';
  85. break;
  86. default:
  87. throw new TypeError(unusableForAlg);
  88. }
  89. if (alg.startsWith('RSA-OAEP')) {
  90. return keyObject.toCryptoKey({
  91. name: 'RSA-OAEP',
  92. hash,
  93. }, extractable, isPublic ? ['encrypt'] : ['decrypt']);
  94. }
  95. cryptoKey = keyObject.toCryptoKey({
  96. name: alg.startsWith('PS') ? 'RSA-PSS' : 'RSASSA-PKCS1-v1_5',
  97. hash,
  98. }, extractable, [isPublic ? 'verify' : 'sign']);
  99. }
  100. if (keyObject.asymmetricKeyType === 'ec') {
  101. const nist = new Map([
  102. ['prime256v1', 'P-256'],
  103. ['secp384r1', 'P-384'],
  104. ['secp521r1', 'P-521'],
  105. ]);
  106. const namedCurve = nist.get(keyObject.asymmetricKeyDetails?.namedCurve);
  107. if (!namedCurve) {
  108. throw new TypeError(unusableForAlg);
  109. }
  110. const expectedCurve = { ES256: 'P-256', ES384: 'P-384', ES512: 'P-521' };
  111. if (expectedCurve[alg] && namedCurve === expectedCurve[alg]) {
  112. cryptoKey = keyObject.toCryptoKey({
  113. name: 'ECDSA',
  114. namedCurve,
  115. }, extractable, [isPublic ? 'verify' : 'sign']);
  116. }
  117. if (alg.startsWith('ECDH-ES')) {
  118. cryptoKey = keyObject.toCryptoKey({
  119. name: 'ECDH',
  120. namedCurve,
  121. }, extractable, isPublic ? [] : ['deriveBits']);
  122. }
  123. }
  124. if (!cryptoKey) {
  125. throw new TypeError(unusableForAlg);
  126. }
  127. if (!cached) {
  128. cache.set(keyObject, { [alg]: cryptoKey });
  129. }
  130. else {
  131. cached[alg] = cryptoKey;
  132. }
  133. return cryptoKey;
  134. };
  135. export async function normalizeKey(key, alg) {
  136. if (key instanceof Uint8Array) {
  137. return key;
  138. }
  139. if (isCryptoKey(key)) {
  140. return key;
  141. }
  142. if (isKeyObject(key)) {
  143. if (key.type === 'secret') {
  144. return key.export();
  145. }
  146. if ('toCryptoKey' in key && typeof key.toCryptoKey === 'function') {
  147. try {
  148. return handleKeyObject(key, alg);
  149. }
  150. catch (err) {
  151. if (err instanceof TypeError) {
  152. throw err;
  153. }
  154. }
  155. }
  156. let jwk = key.export({ format: 'jwk' });
  157. return handleJWK(key, jwk, alg);
  158. }
  159. if (isJWK(key)) {
  160. if (key.k) {
  161. return decode(key.k);
  162. }
  163. return handleJWK(key, key, alg, true);
  164. }
  165. throw new Error('unreachable');
  166. }