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.
117 lines • 13.7 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 { PbHpkePublicKey, PbKeyData } from '../../../internal/proto';
import { HybridEncrypt } from '../hybrid_encrypt';
import { HpkeEncrypt } from './hpke_encrypt';
import * as hpkeValidators from './hpke_validators';
/**
* This class corresponds to the 'HpkePrivateKeyFactory', but it does not
* support key generation. The 'HpkePrivateKeyFactor'y' should be use to
* generate new HPKE key pairs.
* @final
*/
class HpkePublicKeyFactory {
newKey(keyFormat) {
throw new SecurityException('This operation is not supported for public keys. ' +
'Use HpkePrivateKeyManager to generate new keys.');
}
newKeyData(serializedKeyFormat) {
throw new SecurityException('This operation is not supported for public keys. ' +
'Use HpkePrivateKeyManager to generate new keys.');
}
}
/**
* Key manager that produces new instances of {@link HpkeEncrypt} primitives.
* @final
*/
export class HpkePublicKeyManager {
constructor() {
this.keyFactory = new HpkePublicKeyFactory();
}
/**
* Constructs an instance of the 'HybridEncrypt' primitive for a given HPKE
* public 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 = HpkePublicKeyManager.getKeyProto(key);
hpkeValidators.validatePublicKey(keyProto, this.getVersion());
return HpkeEncrypt.createHpkeEncrypt(keyProto);
});
}
/** Returns true if this KeyManager supports 'HpkePublicKey' key type. */
doesSupport(keyType) {
return keyType === this.getKeyType();
}
/** Returns the URL which identifies the keys managed by this KeyManager. */
getKeyType() {
return HpkePublicKeyManager.KEY_TYPE;
}
/**
* Returns the type of primitive which can be generated by this KeyManager,
* i.e. 'HybridEncrypt'
*/
getPrimitiveType() {
return HpkePublicKeyManager.SUPPORTED_PRIMITIVE;
}
getVersion() {
return HpkePublicKeyManager.VERSION;
}
getKeyFactory() {
return this.keyFactory;
}
static getKeyProto(keyMaterial) {
if (keyMaterial instanceof PbKeyData) {
return HpkePublicKeyManager.getKeyProtoFromKeyData(keyMaterial);
}
if (keyMaterial instanceof PbHpkePublicKey) {
return keyMaterial;
}
throw new SecurityException('Key type is not supported. This key manager supports ' +
HpkePublicKeyManager.KEY_TYPE + '.');
}
static getKeyProtoFromKeyData(keyData) {
if (keyData.getTypeUrl() !== HpkePublicKeyManager.KEY_TYPE) {
throw new SecurityException('Key type ' + keyData.getTypeUrl() + ' is not supported. This key ' +
'manager supports ' + HpkePublicKeyManager.KEY_TYPE + '.');
}
let key;
try {
key = PbHpkePublicKey.deserializeBinary(keyData.getValue());
}
catch (e) {
throw new SecurityException('Input cannot be parsed as ' + HpkePublicKeyManager.KEY_TYPE +
' key-proto.');
}
/**
* Throws the same generic error to avoid discrepancies between different
* versions.
*/
if (!key.getParams() || !key.getPublicKey()) {
throw new SecurityException('Input cannot be parsed as ' + HpkePublicKeyManager.KEY_TYPE +
' key-proto.');
}
return key;
}
}
HpkePublicKeyManager.KEY_TYPE = 'type.googleapis.com/google.crypto.tink.HpkePublicKey';
HpkePublicKeyManager.SUPPORTED_PRIMITIVE = HybridEncrypt;
HpkePublicKeyManager.VERSION = 0;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hpke_public_key_manager.js","sourceRoot":"","sources":["../../../../../../hybrid/internal/hpke/hpke_public_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 {PbHpkePublicKey, PbKeyData, PbMessage} from '../../../internal/proto';\nimport * as util from '../../../internal/util';\nimport {HybridEncrypt} from '../hybrid_encrypt';\n\nimport {HpkeEncrypt} from './hpke_encrypt';\nimport * as hpkeValidators from './hpke_validators';\n\n/**\n * This class corresponds to the 'HpkePrivateKeyFactory', but it does not\n * support key generation. The 'HpkePrivateKeyFactor'y' should be use to\n * generate new HPKE key pairs.\n * @final\n */\nclass HpkePublicKeyFactory implements keyManager.KeyFactory {\n  newKey(keyFormat: PbMessage|Uint8Array): never {\n    throw new SecurityException(\n        'This operation is not supported for public keys. ' +\n        'Use HpkePrivateKeyManager to generate new keys.');\n  }\n\n  newKeyData(serializedKeyFormat: Uint8Array): never {\n    throw new SecurityException(\n        'This operation is not supported for public keys. ' +\n        'Use HpkePrivateKeyManager to generate new keys.');\n  }\n}\n\n/**\n * Key manager that produces new instances of {@link HpkeEncrypt} primitives.\n * @final\n */\nexport class HpkePublicKeyManager implements\n    keyManager.KeyManager<HybridEncrypt> {\n  static KEY_TYPE = 'type.googleapis.com/google.crypto.tink.HpkePublicKey';\n  private static readonly SUPPORTED_PRIMITIVE = HybridEncrypt;\n  static VERSION = 0;\n  keyFactory = new HpkePublicKeyFactory();\n  /**\n   * Constructs an instance of the 'HybridEncrypt' primitive for a given HPKE\n   * public key.\n   */\n  async getPrimitive(\n      primitiveType: util.Constructor<HybridEncrypt>,\n      key: PbKeyData|PbMessage) {\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: PbHpkePublicKey = HpkePublicKeyManager.getKeyProto(key);\n    hpkeValidators.validatePublicKey(keyProto, this.getVersion());\n    return HpkeEncrypt.createHpkeEncrypt(keyProto);\n  }\n  /** Returns true if this KeyManager supports 'HpkePublicKey' 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 HpkePublicKeyManager.KEY_TYPE;\n  }\n  /**\n   * Returns the type of primitive which can be generated by this KeyManager,\n   * i.e. 'HybridEncrypt'\n   */\n  getPrimitiveType() {\n    return HpkePublicKeyManager.SUPPORTED_PRIMITIVE;\n  }\n\n  getVersion() {\n    return HpkePublicKeyManager.VERSION;\n  }\n\n  getKeyFactory() {\n    return this.keyFactory;\n  }\n\n  private static getKeyProto(keyMaterial: PbKeyData|\n                             PbMessage): PbHpkePublicKey {\n    if (keyMaterial instanceof PbKeyData) {\n      return HpkePublicKeyManager.getKeyProtoFromKeyData(keyMaterial);\n    }\n    if (keyMaterial instanceof PbHpkePublicKey) {\n      return keyMaterial;\n    }\n    throw new SecurityException(\n        'Key type is not supported. This key manager supports ' +\n        HpkePublicKeyManager.KEY_TYPE + '.');\n  }\n\n  private static getKeyProtoFromKeyData(keyData: PbKeyData): PbHpkePublicKey {\n    if (keyData.getTypeUrl() !== HpkePublicKeyManager.KEY_TYPE) {\n      throw new SecurityException(\n          'Key type ' + keyData.getTypeUrl() + ' is not supported. This key ' +\n          'manager supports ' + HpkePublicKeyManager.KEY_TYPE + '.');\n    }\n    let key: PbHpkePublicKey;\n    try {\n      key = PbHpkePublicKey.deserializeBinary(keyData.getValue());\n    } catch (e) {\n      throw new SecurityException(\n          'Input cannot be parsed as ' + HpkePublicKeyManager.KEY_TYPE +\n          ' key-proto.');\n    }\n    /**\n     * Throws the same generic error to avoid discrepancies between different\n     * versions.\n     */\n    if (!key.getParams() || !key.getPublicKey()) {\n      throw new SecurityException(\n          'Input cannot be parsed as ' + HpkePublicKeyManager.KEY_TYPE +\n          ' key-proto.');\n    }\n    return key;\n  }\n}\n"]}