tink-crypto
Version:
A multi-language, cross-platform library that provides cryptographic APIs that are secure, easy to use correctly, and hard(er) to misuse.
125 lines • 13.5 kB
JavaScript
/**
* @license
* Copyright 2022 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 { InvalidArgumentsException } from '../../exception/invalid_arguments_exception';
import { SecurityException } from '../../exception/security_exception';
import * as bytes from '../../subtle/bytes';
/**
* The only supported IV size.
*
*/
export const IV_SIZE_IN_BYTES = 12;
/**
* The only supported tag size.
*
*/
const TAG_SIZE_IN_BYTES = 16;
/**
* Insecure version of `subtle/aes_gcm.ts` that allows the caller to set
* the IV.
*
* @final
*/
export class InsecureIvAesGcm {
constructor({ key, prependIv }) {
this.key = key;
this.prependIv = prependIv;
}
encrypt(iv, plaintext, associatedData) {
return __awaiter(this, void 0, void 0, function* () {
if (iv.length !== IV_SIZE_IN_BYTES) {
throw new SecurityException(`IV must be ${IV_SIZE_IN_BYTES} bytes`);
}
const alg = {
'name': 'AES-GCM',
'iv': iv,
'tagLength': TAG_SIZE_IN_BYTES * 8
};
if (associatedData) {
alg.additionalData = associatedData;
}
const ciphertext = yield self.crypto.subtle.encrypt(alg, this.key, plaintext);
return (this.prependIv ? bytes.concat(iv, new Uint8Array(ciphertext)) :
new Uint8Array(ciphertext));
});
}
decrypt(iv, ciphertext, associatedData) {
return __awaiter(this, void 0, void 0, function* () {
const expectedLength = this.prependIv ?
IV_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES :
TAG_SIZE_IN_BYTES;
if (ciphertext.length < expectedLength) {
throw new SecurityException('ciphertext too short');
}
if (iv.length !== IV_SIZE_IN_BYTES) {
throw new SecurityException(`IV must be ${IV_SIZE_IN_BYTES} bytes`);
}
const alg = {
'name': 'AES-GCM',
'iv': iv,
'tagLength': TAG_SIZE_IN_BYTES * 8
};
if (associatedData) {
alg.additionalData = associatedData;
}
const ciphertextWithoutIv = this.prependIv ?
new Uint8Array(ciphertext.subarray(IV_SIZE_IN_BYTES)) :
ciphertext;
try {
return new Uint8Array(yield self.crypto.subtle.decrypt(alg, this.key, ciphertextWithoutIv));
// Preserving old behavior when moving to
// https://www.typescriptlang.org/tsconfig#useUnknownInCatchVariables
// tslint:disable-next-line:no-any
}
catch (e) {
throw new SecurityException(e.toString());
}
});
}
}
/**
* Returns an instantiated `InsecureIvAesGcm` given a raw byte array `key`
* and `prependIv` flag.
*/
export function insecureIvAesGcmFromRawKey({ key, prependIv }) {
return __awaiter(this, void 0, void 0, function* () {
validateAesKeySize(key.length);
const webCryptoKey = yield self.crypto.subtle.importKey(
/* format */
'raw', key,
/* keyData */
{ 'name': 'AES-GCM', 'length': key.length },
/* algo */
false,
/* extractable*/
['encrypt', 'decrypt']);
/* usage */
return new InsecureIvAesGcm({ key: webCryptoKey, prependIv });
});
}
/**
* Validates AES key sizes (only 128-bit and 256-bit keys are supported).
*
* @param n the key size in bytes
* @throws {!InvalidArgumentsException}
*
* Copied from `javascript/subtle/validators`
* TODO(b/201071402#comment8): Delete once circular dependency is resolved
*/
function validateAesKeySize(n) {
if (![16, 32].includes(n)) {
throw new InvalidArgumentsException('unsupported AES key size: ${n}');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"insecure_iv_aes_gcm.js","sourceRoot":"","sources":["../../../../../aead/internal/insecure_iv_aes_gcm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2022 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {InvalidArgumentsException} from '../../exception/invalid_arguments_exception';\nimport {SecurityException} from '../../exception/security_exception';\n\nimport * as bytes from '../../subtle/bytes';\n\n/**\n * The only supported IV size.\n *\n */\nexport const IV_SIZE_IN_BYTES: number = 12;\n\n/**\n * The only supported tag size.\n *\n */\nconst TAG_SIZE_IN_BYTES: number = 16;\n\n/**\n * Insecure version of `subtle/aes_gcm.ts` that allows the caller to set\n * the IV.\n *\n * @final\n */\nexport class InsecureIvAesGcm {\n  private readonly key: CryptoKey;\n  private readonly prependIv: boolean;\n  constructor({key, prependIv}:\n                  {readonly key: CryptoKey, readonly prependIv: boolean}) {\n    this.key = key;\n    this.prependIv = prependIv;\n  }\n\n  async encrypt(\n      iv: Uint8Array, plaintext: Uint8Array,\n      associatedData?: Uint8Array): Promise<Uint8Array> {\n    if (iv.length !== IV_SIZE_IN_BYTES) {\n      throw new SecurityException(`IV must be ${IV_SIZE_IN_BYTES} bytes`);\n    }\n\n    const alg: AesGcmParams = {\n      'name': 'AES-GCM',\n      'iv': iv,\n      'tagLength': TAG_SIZE_IN_BYTES * 8\n    };\n    if (associatedData) {\n      alg.additionalData = associatedData;\n    }\n    const ciphertext =\n        await self.crypto.subtle.encrypt(alg, this.key, plaintext);\n\n    return (\n        this.prependIv ? bytes.concat(iv, new Uint8Array(ciphertext)) :\n                         new Uint8Array(ciphertext));\n  }\n\n  async decrypt(\n      iv: Uint8Array, ciphertext: Uint8Array,\n      associatedData?: Uint8Array): Promise<Uint8Array> {\n    const expectedLength = this.prependIv ?\n        IV_SIZE_IN_BYTES + TAG_SIZE_IN_BYTES :\n        TAG_SIZE_IN_BYTES;\n\n    if (ciphertext.length < expectedLength) {\n      throw new SecurityException('ciphertext too short');\n    }\n\n    if (iv.length !== IV_SIZE_IN_BYTES) {\n      throw new SecurityException(`IV must be ${IV_SIZE_IN_BYTES} bytes`);\n    }\n\n    const alg: AesGcmParams = {\n      'name': 'AES-GCM',\n      'iv': iv,\n      'tagLength': TAG_SIZE_IN_BYTES * 8\n    };\n    if (associatedData) {\n      alg.additionalData = associatedData;\n    }\n    const ciphertextWithoutIv = this.prependIv ?\n        new Uint8Array(ciphertext.subarray(IV_SIZE_IN_BYTES)) :\n        ciphertext;\n\n    try {\n      return new Uint8Array(\n          await self.crypto.subtle.decrypt(alg, this.key, ciphertextWithoutIv));\n      // Preserving old behavior when moving to\n      // https://www.typescriptlang.org/tsconfig#useUnknownInCatchVariables\n      // tslint:disable-next-line:no-any\n    } catch (e: any) {\n      throw new SecurityException(e.toString());\n    }\n  }\n}\n\n/**\n * Returns an instantiated `InsecureIvAesGcm` given a raw byte array `key`\n * and `prependIv` flag.\n */\nexport async function insecureIvAesGcmFromRawKey(\n    {key, prependIv}: {key: Uint8Array, prependIv: boolean}):\n    Promise<InsecureIvAesGcm> {\n  validateAesKeySize(key.length);\n  const webCryptoKey = await self.crypto.subtle.importKey(\n      /* format */\n      'raw', key,\n      /* keyData */\n      {'name': 'AES-GCM', 'length': key.length},\n      /* algo */\n      false,\n      /* extractable*/\n      ['encrypt', 'decrypt']);\n\n  /* usage */\n  return new InsecureIvAesGcm({key: webCryptoKey, prependIv});\n}\n\n/**\n * Validates AES key sizes (only 128-bit and 256-bit keys are supported).\n *\n * @param n the key size in bytes\n * @throws {!InvalidArgumentsException}\n *\n * Copied from `javascript/subtle/validators`\n * TODO(b/201071402#comment8): Delete once circular dependency is resolved\n */\nfunction validateAesKeySize(n: number) {\n  if (![16, 32].includes(n)) {\n    throw new InvalidArgumentsException('unsupported AES key size: ${n}');\n  }\n}\n"]}