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.
148 lines • 18.7 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 { SecurityException } from '../../../exception/security_exception';
import * as bytes from '../../../subtle/bytes';
import * as hpkeUtil from './hpke_util';
/**
* Hybrid Public Key Encryption (HPKE) context for either a sender or a
* recipient.
*
* @see https://www.rfc-editor.org/rfc/rfc9180.html#name-creating-the-encryption-con
*/
export class HpkeContext {
constructor(encapsulatedKey, key, baseNonce, aead) {
this.encapsulatedKey = encapsulatedKey;
this.key = key;
this.baseNonce = baseNonce;
this.aead = aead;
this.sequenceNumber = BigInt(0);
/**
* Indicates that the message limit is reached, calculated as per
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-11.
*/
this.maxSequenceNumber =
(BigInt(1) << BigInt(8 * this.aead.getNonceLength())) - BigInt(1);
}
/**
* Performs AEAD encryption of `plaintext` with `associatedData`
* according to `ContextS.Seal()` as defined in
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-8.
*/
seal(plaintext, associatedData) {
return __awaiter(this, void 0, void 0, function* () {
const nonce = this.computeNonceAndIncrementSequenceNumber();
return yield this.aead.seal({ key: this.key, nonce, plaintext, associatedData });
});
}
/**
* Performs AEAD decryption of `ciphertext` with `associatedData`
* according to `ContextR.Open()` as defined in
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-10.
*/
open(ciphertext, associatedData) {
return __awaiter(this, void 0, void 0, function* () {
const nonce = this.computeNonceAndIncrementSequenceNumber();
return this.aead.open({ key: this.key, nonce, ciphertext, associatedData });
});
}
/**
* Computes nonce according to `ComputeNonce` as defined in
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-11.
* for seal/open and increments the sequence number.
*/
computeNonceAndIncrementSequenceNumber() {
const seqBytes = hpkeUtil.bigIntToByteArray(this.aead.getNonceLength(), this.sequenceNumber);
const nonce = bytes.xor(this.baseNonce, seqBytes);
if (this.sequenceNumber >= this.maxSequenceNumber) {
throw new SecurityException('message limit reached');
}
this.sequenceNumber += (BigInt(1));
return nonce;
}
getKey() {
return this.key;
}
getBaseNonce() {
return this.baseNonce;
}
getEncapsulatedKey() {
return this.encapsulatedKey;
}
}
/** Helper function factored out to facilitate unit testing. */
export function createContext(encapsulatedKey, sharedSecret, kem, kdf, aead, info) {
return __awaiter(this, void 0, void 0, function* () {
const suiteId = hpkeUtil.hpkeSuiteId({ kemId: kem.getKemId(), kdfId: kdf.getKdfId(), aeadId: aead.getAeadId() });
/**
* The IKM values below are empty because we only support base mode
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1.9.
*/
const pskIdHash = yield kdf.labeledExtract({
ikm: new Uint8Array(0),
ikmLabel: 'psk_id_hash',
suiteId,
});
const infoHash = yield kdf.labeledExtract({
ikm: info,
ikmLabel: 'info_hash',
suiteId,
});
const keyScheduleContext = bytes.concat(hpkeUtil.BASE_MODE, pskIdHash, infoHash);
const secret = yield kdf.labeledExtract({
ikm: new Uint8Array(0),
ikmLabel: 'secret',
suiteId,
salt: sharedSecret
});
const key = yield kdf.labeledExpand({
prk: secret,
info: keyScheduleContext,
infoLabel: 'key',
suiteId,
length: aead.getKeyLength()
});
const baseNonce = yield kdf.labeledExpand({
prk: secret,
info: keyScheduleContext,
infoLabel: 'base_nonce',
suiteId,
length: aead.getNonceLength()
});
return new HpkeContext(encapsulatedKey, key, baseNonce, aead);
});
}
/**
* Creates HPKE sender context according to `KeySchedule` as defined in
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1-9.
*/
export function createSenderContext(recipientPublicKey, kem, kdf, aead, info) {
return __awaiter(this, void 0, void 0, function* () {
const encapOutput = yield kem.encapsulate(recipientPublicKey);
const encapsulatedKey = encapOutput.encapsulatedKey;
const sharedSecret = encapOutput.sharedSecret;
return yield createContext(encapsulatedKey, sharedSecret, kem, kdf, aead, info);
});
}
/**
* Creates HPKE recipient context according to `KeySchedule` as defined in
* @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1-9.
*/
export function createRecipientContext(encapsulatedKey, recipientPrivateKey, kem, kdf, aead, info) {
return __awaiter(this, void 0, void 0, function* () {
const sharedSecret = yield kem.decapsulate(encapsulatedKey, recipientPrivateKey);
return yield createContext(encapsulatedKey, sharedSecret, kem, kdf, aead, info);
});
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hpke_context.js","sourceRoot":"","sources":["../../../../../../hybrid/internal/hpke/hpke_context.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 {SecurityException} from '../../../exception/security_exception';\nimport * as bytes from '../../../subtle/bytes';\n\nimport {HpkeAead} from './hpke_aead';\nimport {HpkeKdf} from './hpke_kdf';\nimport {HpkeKem} from './hpke_kem';\nimport {HpkeKemEncapOutput} from './hpke_kem_encap_output';\nimport * as hpkeUtil from './hpke_util';\nimport {NistCurvesHpkeKemPrivateKey} from './nist_curves_hpke_kem_private_key';\n\n/**\n * Hybrid Public Key Encryption (HPKE) context for either a sender or a\n * recipient.\n *\n * @see https://www.rfc-editor.org/rfc/rfc9180.html#name-creating-the-encryption-con\n */\nexport class HpkeContext {\n  private sequenceNumber: bigint;\n  private readonly maxSequenceNumber: bigint;\n\n  constructor(\n      private readonly encapsulatedKey: Uint8Array,\n      private readonly key: Uint8Array, private readonly baseNonce: Uint8Array,\n      private readonly aead: HpkeAead) {\n    this.sequenceNumber = BigInt(0);\n\n    /**\n     * Indicates that the message limit is reached, calculated as per\n     * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-11.\n     */\n    this.maxSequenceNumber =\n        (BigInt(1) << BigInt(8 * this.aead.getNonceLength())) - BigInt(1);\n  }\n\n  /**\n   * Performs AEAD encryption of `plaintext` with `associatedData`\n   * according to `ContextS.Seal()` as defined in\n   * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-8.\n   */\n  async seal(plaintext: Uint8Array, associatedData: Uint8Array):\n      Promise<Uint8Array> {\n    const nonce: Uint8Array = this.computeNonceAndIncrementSequenceNumber();\n    return await this.aead.seal(\n        {key: this.key, nonce, plaintext, associatedData});\n  }\n\n  /**\n   * Performs AEAD decryption of `ciphertext` with `associatedData`\n   * according to `ContextR.Open()` as defined in\n   * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-10.\n   */\n  async open(ciphertext: Uint8Array, associatedData: Uint8Array):\n      Promise<Uint8Array> {\n    const nonce: Uint8Array = this.computeNonceAndIncrementSequenceNumber();\n    return this.aead.open({key: this.key, nonce, ciphertext, associatedData});\n  }\n\n  /**\n   * Computes nonce according to `ComputeNonce` as defined in\n   * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.2-11.\n   * for seal/open and increments the sequence number.\n   */\n  private computeNonceAndIncrementSequenceNumber(): Uint8Array {\n    const seqBytes: Uint8Array = hpkeUtil.bigIntToByteArray(\n        this.aead.getNonceLength(), this.sequenceNumber);\n    const nonce: Uint8Array = bytes.xor(this.baseNonce, seqBytes);\n\n    if (this.sequenceNumber >= this.maxSequenceNumber) {\n      throw new SecurityException('message limit reached');\n    }\n    this.sequenceNumber += (BigInt(1));\n\n    return nonce;\n  }\n\n  getKey(): Uint8Array {\n    return this.key;\n  }\n\n  getBaseNonce(): Uint8Array {\n    return this.baseNonce;\n  }\n\n  getEncapsulatedKey(): Uint8Array {\n    return this.encapsulatedKey;\n  }\n}\n\n/** Helper function factored out to facilitate unit testing. */\nexport async function createContext(\n    encapsulatedKey: Uint8Array, sharedSecret: Uint8Array, kem: HpkeKem,\n    kdf: HpkeKdf, aead: HpkeAead, info: Uint8Array): Promise<HpkeContext> {\n  const suiteId = hpkeUtil.hpkeSuiteId(\n      {kemId: kem.getKemId(), kdfId: kdf.getKdfId(), aeadId: aead.getAeadId()});\n\n  /**\n   * The IKM values below are empty because we only support base mode\n   * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1.9.\n   */\n  const pskIdHash = await kdf.labeledExtract({\n    ikm: new Uint8Array(0),  // empty IKM\n    ikmLabel: 'psk_id_hash',\n    suiteId,\n  });\n\n  const infoHash = await kdf.labeledExtract({\n    ikm: info,\n    ikmLabel: 'info_hash',\n    suiteId,\n  });\n\n  const keyScheduleContext =\n      bytes.concat(hpkeUtil.BASE_MODE, pskIdHash, infoHash);\n  const secret = await kdf.labeledExtract({\n    ikm: new Uint8Array(0),  // empty IKM\n    ikmLabel: 'secret',\n    suiteId,\n    salt: sharedSecret\n  });\n\n  const key = await kdf.labeledExpand({\n    prk: secret,\n    info: keyScheduleContext,\n    infoLabel: 'key',\n    suiteId,\n    length: aead.getKeyLength()\n  });\n  const baseNonce = await kdf.labeledExpand({\n    prk: secret,\n    info: keyScheduleContext,\n    infoLabel: 'base_nonce',\n    suiteId,\n    length: aead.getNonceLength()\n  });\n\n  return new HpkeContext(encapsulatedKey, key, baseNonce, aead);\n}\n\n/**\n * Creates HPKE sender context according to `KeySchedule` as defined in\n * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1-9.\n */\nexport async function createSenderContext(\n    recipientPublicKey: Uint8Array, kem: HpkeKem, kdf: HpkeKdf, aead: HpkeAead,\n    info: Uint8Array): Promise<HpkeContext> {\n  const encapOutput: HpkeKemEncapOutput =\n      await kem.encapsulate(recipientPublicKey);\n  const encapsulatedKey: Uint8Array = encapOutput.encapsulatedKey;\n  const sharedSecret: Uint8Array = encapOutput.sharedSecret;\n  return await createContext(\n      encapsulatedKey, sharedSecret, kem, kdf, aead, info);\n}\n\n/**\n * Creates HPKE recipient context according to `KeySchedule` as defined in\n * @see https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1-9.\n */\nexport async function createRecipientContext(\n    encapsulatedKey: Uint8Array,\n    recipientPrivateKey: NistCurvesHpkeKemPrivateKey, kem: HpkeKem,\n    kdf: HpkeKdf, aead: HpkeAead, info: Uint8Array): Promise<HpkeContext> {\n  const sharedSecret: Uint8Array =\n      await kem.decapsulate(encapsulatedKey, recipientPrivateKey);\n  return await createContext(\n      encapsulatedKey, sharedSecret, kem, kdf, aead, info);\n}\n"]}