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.
221 lines • 27.8 kB
JavaScript
/**
* @license
* Copyright 2023 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 { PbHpkeKeyFormat, PbHpkePrivateKey, PbHpkePublicKey, PbKeyData } from '../../../internal/proto';
import * as bytes from '../../../subtle/bytes';
import * as ellipticCurves from '../../../subtle/elliptic_curves';
import { HybridDecrypt } from '../hybrid_decrypt';
import { HpkeDecrypt } from './hpke_decrypt';
import { HpkePublicKeyManager } from './hpke_public_key_manager';
import * as hpkeUtil from './hpke_util';
import * as hpkeValidators from './hpke_validators';
const VERSION = 0;
/**
* A container for methods that generate new HPKE key pairs.
* These methods are separate from the KeyManager as their functionality is
* independent of the primitive of the corresponding KeyManager.
* @final
*/
class HpkePrivateKeyFactory {
/**
* Generates a new random HPKE key according to 'keyFormat'.
*
* @param keyFormat is either a KeyFormat
* proto or a serialized KeyFormat proto
* @return the new generated HPKE private key
*/
newKey(keyFormat) {
return __awaiter(this, void 0, void 0, function* () {
if (!keyFormat) {
throw new SecurityException('Key format must be non-null.');
}
const keyFormatProto = HpkePrivateKeyFactory.getKeyFormatProto(keyFormat);
hpkeValidators.validateKeyFormat(keyFormatProto);
const params = keyFormatProto.getParams();
if (!params) {
throw new SecurityException('Params not set');
}
const curveType = hpkeUtil.nistHpkeKemToCurve(params.getKem());
const curveName = ellipticCurves.curveToString(curveType);
const keyPair = yield ellipticCurves.generateKeyPair('ECDH', curveName);
const jsonPrivateKey = yield ellipticCurves.exportCryptoKey(keyPair.privateKey);
const publicKeyBytes = yield hpkeUtil.getByteArrayFromPublicKey(keyPair.publicKey);
const publicKeyProto = (new PbHpkePublicKey())
.setVersion(HpkePublicKeyManager.VERSION)
.setParams(params)
.setPublicKey(publicKeyBytes);
const { d } = jsonPrivateKey;
if (d === undefined) {
throw new SecurityException('d must be set');
}
return (new PbHpkePrivateKey())
.setVersion(VERSION)
.setPublicKey(publicKeyProto)
.setPrivateKey(bytes.fromBase64(d, true));
});
}
/**
* Generates a new random HPKE key based on the "serialized_key_format" and
* returns it as a KeyData proto.
*/
newKeyData(serializedKeyFormat) {
return __awaiter(this, void 0, void 0, function* () {
const key = yield this.newKey(serializedKeyFormat);
const keyData = (new PbKeyData())
.setTypeUrl(HpkePrivateKeyManager.KEY_TYPE)
.setValue(key.serializeBinary())
.setKeyMaterialType(PbKeyData.KeyMaterialType.ASYMMETRIC_PRIVATE);
return keyData;
});
}
/**
* Returns an HPKE public key data extracted from the given serialized HPKE
* private key.
*/
getPublicKeyData(serializedPrivateKey) {
const privateKey = deserializePrivateKey(serializedPrivateKey);
const publicKey = privateKey.getPublicKey();
if (!publicKey) {
throw new SecurityException('Public key not set');
}
const publicKeyData = (new PbKeyData())
.setValue(publicKey.serializeBinary())
.setTypeUrl(HpkePublicKeyManager.KEY_TYPE)
.setKeyMaterialType(PbKeyData.KeyMaterialType.ASYMMETRIC_PUBLIC);
return publicKeyData;
}
/**
* The input keyFormat is either deserialized (in case that the input is
* Uint8Array) or checked to be an HpkeKeyFormat-proto (otherwise).
*/
static getKeyFormatProto(keyFormat) {
if (keyFormat instanceof Uint8Array) {
return HpkePrivateKeyFactory.deserializeKeyFormat(keyFormat);
}
else if (keyFormat instanceof PbHpkeKeyFormat) {
return keyFormat;
}
else {
throw new SecurityException('Expected ' + HpkePrivateKeyManager.KEY_TYPE + ' key format proto.');
}
}
static deserializeKeyFormat(keyFormat) {
let keyFormatProto;
try {
keyFormatProto = PbHpkeKeyFormat.deserializeBinary(keyFormat);
}
catch (e) {
throw new SecurityException('Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +
' key format proto.');
}
/**
* Throws the same generic error to avoid discrepancies between different
* versions.
*/
if (!keyFormatProto.getParams()) {
throw new SecurityException('Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +
' key format proto.');
}
return keyFormatProto;
}
}
/**
* Key manager that generates new {@link HpkePrivateKey} keys and produces new
* instances of {@link HpkeDecrypt} primitives.
*
* @final
*/
export class HpkePrivateKeyManager {
constructor() {
this.keyFactory = new HpkePrivateKeyFactory();
}
/**
* Constructs an instance of the 'HybridDecrypt' primitive for a given HPKE
* key.
*/
getPrimitive(primitiveType, key) {
return __awaiter(this, void 0, void 0, function* () {
if (primitiveType !== this.getPrimitiveType()) {
throw new SecurityException('Requested primitive type which is not ' +
'supported by this key manager.');
}
const keyProto = HpkePrivateKeyManager.getKeyProto(key);
hpkeValidators.validatePrivateKey(keyProto, VERSION, HpkePublicKeyManager.VERSION);
return HpkeDecrypt.createHpkeDecrypt(keyProto);
});
}
/** Returns true if this KeyManager supports 'HpkePrivateKey' key type. */
doesSupport(keyType) {
return keyType === this.getKeyType();
}
/** Returns the URL which identifies the keys managed by this KeyManager. */
getKeyType() {
return HpkePrivateKeyManager.KEY_TYPE;
}
/**
* Returns the type of primitive which can be generated by this KeyManager,
* i.e. 'HybridDecrypt'
*/
getPrimitiveType() {
return HpkePrivateKeyManager.SUPPORTED_PRIMITIVE;
}
getVersion() {
return VERSION;
}
getKeyFactory() {
return this.keyFactory;
}
static getKeyProto(keyMaterial) {
if (keyMaterial instanceof PbKeyData) {
return HpkePrivateKeyManager.getKeyProtoFromKeyData(keyMaterial);
}
if (keyMaterial instanceof PbHpkePrivateKey) {
return keyMaterial;
}
throw new SecurityException('Key type is not supported. This key ' +
'manager supports ' + HpkePrivateKeyManager.KEY_TYPE + '.');
}
static getKeyProtoFromKeyData(keyData) {
if (keyData.getTypeUrl() !== HpkePrivateKeyManager.KEY_TYPE) {
throw new SecurityException('Key type ' + keyData.getTypeUrl() +
' is not supported. This key manager supports ' +
HpkePrivateKeyManager.KEY_TYPE + '.');
}
return deserializePrivateKey(keyData.getValue());
}
}
HpkePrivateKeyManager.SUPPORTED_PRIMITIVE = HybridDecrypt;
HpkePrivateKeyManager.KEY_TYPE = 'type.googleapis.com/google.crypto.tink.HpkePrivateKey';
/** Returns an HPKE private key instance for the given key serialization */
function deserializePrivateKey(serializedPrivateKey) {
let key;
try {
key = PbHpkePrivateKey.deserializeBinary(serializedPrivateKey);
}
catch (e) {
throw new SecurityException('Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +
' key-proto.');
}
/**
* Throws the same generic error to avoid discrepancies between different
* versions.
*/
if (!key.getPublicKey() || !key.getPrivateKey()) {
throw new SecurityException('Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +
' key-proto.');
}
return key;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hpke_private_key_manager.js","sourceRoot":"","sources":["../../../../../../hybrid/internal/hpke/hpke_private_key_manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2023 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {SecurityException} from '../../../exception/security_exception';\nimport * as keyManager from '../../../internal/key_manager';\nimport {PbHpkeKeyFormat, PbHpkeParams, PbHpkePrivateKey, PbHpkePublicKey, PbKeyData, PbMessage} from '../../../internal/proto';\nimport {ProtoBytes} from '../../../internal/proto_shims';\nimport * as util from '../../../internal/util';\nimport * as bytes from '../../../subtle/bytes';\nimport * as ellipticCurves from '../../../subtle/elliptic_curves';\nimport {HybridDecrypt} from '../hybrid_decrypt';\n\nimport {HpkeDecrypt} from './hpke_decrypt';\nimport {HpkePublicKeyManager} from './hpke_public_key_manager';\nimport * as hpkeUtil from './hpke_util';\nimport * as hpkeValidators from './hpke_validators';\n\nconst VERSION = 0;\n\n/**\n * A container for methods that generate new HPKE key pairs.\n * These methods are separate from the KeyManager as their functionality is\n * independent of the primitive of the corresponding KeyManager.\n * @final\n */\nclass HpkePrivateKeyFactory implements keyManager.PrivateKeyFactory {\n  /**\n   * Generates a new random HPKE key according to 'keyFormat'.\n   *\n   * @param keyFormat is either a KeyFormat\n   *     proto or a serialized KeyFormat proto\n   * @return the new generated HPKE private key\n   */\n  async newKey(keyFormat: PbMessage|Uint8Array): Promise<PbHpkePrivateKey> {\n    if (!keyFormat) {\n      throw new SecurityException('Key format must be non-null.');\n    }\n    const keyFormatProto: PbHpkeKeyFormat =\n        HpkePrivateKeyFactory.getKeyFormatProto(keyFormat);\n    hpkeValidators.validateKeyFormat(keyFormatProto);\n    const params: PbHpkeParams|undefined = keyFormatProto.getParams();\n    if (!params) {\n      throw new SecurityException('Params not set');\n    }\n    const curveType: ellipticCurves.CurveType.P256|\n        ellipticCurves.CurveType.P521 =\n        hpkeUtil.nistHpkeKemToCurve(params.getKem());\n    const curveName = ellipticCurves.curveToString(curveType);\n    const keyPair: CryptoKeyPair =\n        await ellipticCurves.generateKeyPair('ECDH', curveName);\n    const jsonPrivateKey =\n        await ellipticCurves.exportCryptoKey(keyPair.privateKey);\n\n    const publicKeyBytes =\n        await hpkeUtil.getByteArrayFromPublicKey(keyPair.publicKey);\n\n    const publicKeyProto = (new PbHpkePublicKey())\n                               .setVersion(HpkePublicKeyManager.VERSION)\n                               .setParams(params)\n                               .setPublicKey(publicKeyBytes);\n\n    const {d} = jsonPrivateKey;\n    if (d === undefined) {\n      throw new SecurityException('d must be set');\n    }\n    return (new PbHpkePrivateKey())\n        .setVersion(VERSION)\n        .setPublicKey(publicKeyProto)\n        .setPrivateKey(bytes.fromBase64(d, true));\n  }\n\n  /**\n   * Generates a new random HPKE key based on the \"serialized_key_format\" and\n   * returns it as a KeyData proto.\n   */\n  async newKeyData(serializedKeyFormat: PbMessage|\n                   Uint8Array): Promise<PbKeyData> {\n    const key: PbHpkePrivateKey = await this.newKey(serializedKeyFormat);\n    const keyData =\n        (new PbKeyData())\n            .setTypeUrl(HpkePrivateKeyManager.KEY_TYPE)\n            .setValue(key.serializeBinary())\n            .setKeyMaterialType(PbKeyData.KeyMaterialType.ASYMMETRIC_PRIVATE);\n    return keyData;\n  }\n\n  /**\n   * Returns an HPKE public key data extracted from the given serialized HPKE\n   * private key.\n   */\n  getPublicKeyData(serializedPrivateKey: Uint8Array): PbKeyData {\n    const privateKey: PbHpkePrivateKey =\n        deserializePrivateKey(serializedPrivateKey);\n    const publicKey: PbHpkePublicKey|undefined = privateKey.getPublicKey();\n    if (!publicKey) {\n      throw new SecurityException('Public key not set');\n    }\n    const publicKeyData =\n        (new PbKeyData())\n            .setValue(publicKey.serializeBinary())\n            .setTypeUrl(HpkePublicKeyManager.KEY_TYPE)\n            .setKeyMaterialType(PbKeyData.KeyMaterialType.ASYMMETRIC_PUBLIC);\n    return publicKeyData;\n  }\n\n  /**\n   * The input keyFormat is either deserialized (in case that the input is\n   * Uint8Array) or checked to be an HpkeKeyFormat-proto (otherwise).\n   */\n  private static getKeyFormatProto(keyFormat: PbMessage|\n                                   Uint8Array): PbHpkeKeyFormat {\n    if (keyFormat instanceof Uint8Array) {\n      return HpkePrivateKeyFactory.deserializeKeyFormat(keyFormat);\n    } else if (keyFormat instanceof PbHpkeKeyFormat) {\n      return keyFormat;\n    } else {\n      throw new SecurityException(\n          'Expected ' + HpkePrivateKeyManager.KEY_TYPE + ' key format proto.');\n    }\n  }\n\n  private static deserializeKeyFormat(keyFormat: Uint8Array): PbHpkeKeyFormat {\n    let keyFormatProto: PbHpkeKeyFormat;\n    try {\n      keyFormatProto = PbHpkeKeyFormat.deserializeBinary(keyFormat);\n    } catch (e) {\n      throw new SecurityException(\n          'Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +\n          ' key format proto.');\n    }\n    /**\n     * Throws the same generic error to avoid discrepancies between different\n     * versions.\n     */\n    if (!keyFormatProto.getParams()) {\n      throw new SecurityException(\n          'Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +\n          ' key format proto.');\n    }\n    return keyFormatProto;\n  }\n}\n\n/**\n * Key manager that generates new {@link HpkePrivateKey} keys and produces new\n * instances of {@link HpkeDecrypt} primitives.\n *\n * @final\n */\nexport class HpkePrivateKeyManager implements\n    keyManager.KeyManager<HybridDecrypt> {\n  private static readonly SUPPORTED_PRIMITIVE = HybridDecrypt;\n  static KEY_TYPE = 'type.googleapis.com/google.crypto.tink.HpkePrivateKey';\n  keyFactory = new HpkePrivateKeyFactory();\n  /**\n   * Constructs an instance of the 'HybridDecrypt' primitive for a given HPKE\n   * key.\n   */\n  async getPrimitive(\n      primitiveType: util.Constructor<HybridDecrypt>,\n      key: PbKeyData|PbMessage): Promise<HybridDecrypt> {\n    if (primitiveType !== this.getPrimitiveType()) {\n      throw new SecurityException(\n          'Requested primitive type which is not ' +\n          'supported by this key manager.');\n    }\n    const keyProto: PbHpkePrivateKey = HpkePrivateKeyManager.getKeyProto(key);\n    hpkeValidators.validatePrivateKey(\n        keyProto, VERSION, HpkePublicKeyManager.VERSION);\n    return HpkeDecrypt.createHpkeDecrypt(keyProto);\n  }\n\n  /** Returns true if this KeyManager supports 'HpkePrivateKey' key type. */\n  doesSupport(keyType: string) {\n    return keyType === this.getKeyType();\n  }\n  /** Returns the URL which identifies the keys managed by this KeyManager. */\n  getKeyType() {\n    return HpkePrivateKeyManager.KEY_TYPE;\n  }\n  /**\n   * Returns the type of primitive which can be generated by this KeyManager,\n   * i.e. 'HybridDecrypt'\n   */\n  getPrimitiveType() {\n    return HpkePrivateKeyManager.SUPPORTED_PRIMITIVE;\n  }\n\n  getVersion() {\n    return VERSION;\n  }\n\n  getKeyFactory() {\n    return this.keyFactory;\n  }\n\n  private static getKeyProto(keyMaterial: PbKeyData|\n                             PbMessage): PbHpkePrivateKey {\n    if (keyMaterial instanceof PbKeyData) {\n      return HpkePrivateKeyManager.getKeyProtoFromKeyData(keyMaterial);\n    }\n    if (keyMaterial instanceof PbHpkePrivateKey) {\n      return keyMaterial;\n    }\n    throw new SecurityException(\n        'Key type is not supported. This key ' +\n        'manager supports ' + HpkePrivateKeyManager.KEY_TYPE + '.');\n  }\n\n  private static getKeyProtoFromKeyData(keyData: PbKeyData): PbHpkePrivateKey {\n    if (keyData.getTypeUrl() !== HpkePrivateKeyManager.KEY_TYPE) {\n      throw new SecurityException(\n          'Key type ' + keyData.getTypeUrl() +\n          ' is not supported. This key manager supports ' +\n          HpkePrivateKeyManager.KEY_TYPE + '.');\n    }\n    return deserializePrivateKey(keyData.getValue());\n  }\n}\n\n/** Returns an HPKE private key instance for the given key serialization */\nfunction deserializePrivateKey(serializedPrivateKey: ProtoBytes):\n    PbHpkePrivateKey {\n  let key: PbHpkePrivateKey;\n  try {\n    key = PbHpkePrivateKey.deserializeBinary(serializedPrivateKey);\n  } catch (e) {\n    throw new SecurityException(\n        'Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +\n        ' key-proto.');\n  }\n  /**\n   * Throws the same generic error to avoid discrepancies between different\n   * versions.\n   */\n  if (!key.getPublicKey() || !key.getPrivateKey()) {\n    throw new SecurityException(\n        'Input cannot be parsed as ' + HpkePrivateKeyManager.KEY_TYPE +\n        ' key-proto.');\n  }\n  return key;\n}\n"]}