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.
225 lines • 25.8 kB
JavaScript
/**
* @license
* Copyright 2020 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());
});
};
/**
* @fileoverview Registry for KeyManagers.
*
* Registry maps supported key types to corresponding KeyManager objects (i.e.
* the KeyManagers which may instantiate the primitive corresponding to the
* given key or generate new key of the given type). Keeping KeyManagers for all
* primitives in a single Registry (rather than having a separate keyManager per
* primitive) enables modular construction of compound primitives from "simple"
* ones (e.g. AES-CTR-HMAC AEAD encryption from IND-CPA encryption and MAC).
*
* Regular users will not usually work with Registry directly, but via primitive
* factories, which query Registry for the specific KeyManagers in the
* background.
*/
import { SecurityException } from '../exception/security_exception';
import { PbKeyData } from './proto';
import { bytesAsU8 } from './proto_shims';
import { isInstanceOf } from './util';
// key managers maps
const typeToManagerMap_ = new Map();
const typeToNewKeyAllowedMap_ = new Map();
// primitive wrappers map
const primitiveTypeToWrapper_ = new Map();
/**
* Register the given manager for the given key type. Manager must be
* non-nullptr. New keys are allowed if not specified.
*/
export function registerKeyManager(manager, opt_newKeyAllowed) {
if (opt_newKeyAllowed === undefined) {
opt_newKeyAllowed = true;
}
if (!manager) {
throw new SecurityException('Key manager cannot be null.');
}
const typeUrl = manager.getKeyType();
if (typeToManagerMap_.has(typeUrl)) {
// Cannot overwrite the existing key manager by a new one.
if (!(typeToManagerMap_.get(typeUrl) instanceof manager.constructor)) {
throw new SecurityException('Key manager for key type ' + typeUrl +
' has already been registered and cannot be overwritten.');
}
// It is forbidden to change new_key_allowed from false to true.
if (!typeToNewKeyAllowedMap_.get(typeUrl) && opt_newKeyAllowed) {
throw new SecurityException('Key manager for key type ' + typeUrl +
' has already been registered with forbidden new key operation.');
}
typeToNewKeyAllowedMap_.set(typeUrl, opt_newKeyAllowed);
}
typeToManagerMap_.set(typeUrl, manager);
typeToNewKeyAllowedMap_.set(typeUrl, opt_newKeyAllowed);
}
/**
* Returns a key manager for the given key type or throws an exception if no
* such manager found.
*
* @param typeUrl -- key type
*
*/
export function getKeyManager(typeUrl) {
const res = typeToManagerMap_.get(typeUrl);
if (!res) {
throw new SecurityException('Key manager for key type ' + typeUrl + ' has not been registered.');
}
return res;
}
/**
* It finds KeyManager according to key type (which is either given by
* PbKeyData or given by opt_typeUrl), than calls the corresponding
* manager's getPrimitive method.
*
* Either key is of type PbKeyData or opt_typeUrl must be provided.
*
* @param key -- key is either a proto of some key
* or key data.
* @param opt_typeUrl -- key type
* @this {typeof Registry}
*
*/
export function getPrimitive(primitiveType, key, opt_typeUrl) {
return __awaiter(this, void 0, void 0, function* () {
if (key instanceof PbKeyData) {
if (opt_typeUrl && key.getTypeUrl() != opt_typeUrl) {
throw new SecurityException('Key type is ' + opt_typeUrl + ', but it is expected to be ' +
key.getTypeUrl() + ' or undefined.');
}
opt_typeUrl = key.getTypeUrl();
}
if (!opt_typeUrl) {
throw new SecurityException('Key type has to be specified.');
}
const manager = getKeyManager(opt_typeUrl);
const primitive = yield manager.getPrimitive(primitiveType, key);
if (!isInstanceOf(primitive, primitiveType)) {
throw new TypeError('Unexpected type');
}
return primitive;
});
}
/**
* Generates a new PbKeyData for the specified keyTemplate. It finds a
* KeyManager given by keyTemplate.typeUrl and calls the newKeyData method of
* that manager.
*
*
*
*/
export function newKeyData(keyTemplate) {
return __awaiter(this, void 0, void 0, function* () {
const manager = getKeyManagerWithNewKeyAllowedCheck_(keyTemplate);
return manager.getKeyFactory().newKeyData(bytesAsU8(keyTemplate.getValue()));
});
}
/**
* Generates a new key for the specified keyTemplate using the
* KeyManager determined by typeUrl field of the keyTemplate.
*
*
*
* @return returns a key proto
*/
export function newKey(keyTemplate) {
return __awaiter(this, void 0, void 0, function* () {
const manager = getKeyManagerWithNewKeyAllowedCheck_(keyTemplate);
return manager.getKeyFactory().newKey(bytesAsU8(keyTemplate.getValue()));
});
}
/**
* Convenience method for extracting the public key data from the private key
* given by serializedPrivateKey.
* It looks up a KeyManager identified by typeUrl, which must hold
* PrivateKeyFactory, and calls getPublicKeyData method of that factory.
*
*/
export function getPublicKeyData(typeUrl, serializedPrivateKey) {
const manager = getKeyManager(typeUrl);
// This solution might cause some problems in the future due to Closure
// compiler optimizations, which may map factory.getPublicKeyData to
// concrete function.
const factory = manager.getKeyFactory();
if (!factory.getPublicKeyData) {
throw new SecurityException('Key manager for key type ' + typeUrl +
' does not have a private key factory.');
}
return factory.getPublicKeyData(serializedPrivateKey);
}
/**
* Resets the registry.
* After reset the registry is empty, i.e. it contains no key managers.
*
* This method is only for testing.
*/
export function reset() {
typeToManagerMap_.clear();
typeToNewKeyAllowedMap_.clear();
primitiveTypeToWrapper_.clear();
}
/**
* It finds a KeyManager given by keyTemplate.typeUrl and returns it if it
* allows creating new keys.
*
*
*/
function getKeyManagerWithNewKeyAllowedCheck_(keyTemplate) {
const keyType = keyTemplate.getTypeUrl();
const manager = getKeyManager(keyType);
if (!typeToNewKeyAllowedMap_.get(keyType)) {
throw new SecurityException('New key operation is forbidden for ' +
'key type: ' + keyType + '.');
}
return manager;
}
/**
* Tries to register a primitive wrapper.
*/
export function registerPrimitiveWrapper(wrapper) {
if (!wrapper) {
throw new SecurityException('primitive wrapper cannot be null');
}
const primitiveType = wrapper.getPrimitiveType();
if (!primitiveType) {
throw new SecurityException('primitive wrapper cannot be undefined');
}
if (primitiveTypeToWrapper_.has(primitiveType)) {
// Cannot overwrite the existing key manager by a new one.
if (!(primitiveTypeToWrapper_.get(primitiveType) instanceof
wrapper.constructor)) {
throw new SecurityException('primitive wrapper for type ' + primitiveType +
' has already been registered and cannot be overwritten');
}
}
primitiveTypeToWrapper_.set(primitiveType, wrapper);
}
/**
* Wraps a PrimitiveSet and returns a single instance.
*/
export function wrap(primitiveSet) {
if (!primitiveSet) {
throw new SecurityException('primitive set cannot be null.');
}
const primitiveType = primitiveSet.getPrimitiveType();
const wrapper = primitiveTypeToWrapper_.get(primitiveType);
if (!wrapper) {
throw new SecurityException('no primitive wrapper found for type ' + primitiveType);
}
const primitive = wrapper.wrap(primitiveSet);
if (!isInstanceOf(primitive, primitiveType)) {
throw new TypeError('Unexpected type');
}
return primitive;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../internal/registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Registry for KeyManagers.\n *\n * Registry maps supported key types to corresponding KeyManager objects (i.e.\n * the KeyManagers which may instantiate the primitive corresponding to the\n * given key or generate new key of the given type). Keeping KeyManagers for all\n * primitives in a single Registry (rather than having a separate keyManager per\n * primitive) enables modular construction of compound primitives from \"simple\"\n * ones (e.g. AES-CTR-HMAC AEAD encryption from IND-CPA encryption and MAC).\n *\n * Regular users will not usually work with Registry directly, but via primitive\n * factories, which query Registry for the specific KeyManagers in the\n * background.\n */\n\nimport {SecurityException} from '../exception/security_exception';\n\nimport * as KeyManager from './key_manager';\nimport * as PrimitiveSet from './primitive_set';\nimport {PrimitiveWrapper} from './primitive_wrapper';\nimport {PbKeyData, PbKeyTemplate, PbMessage} from './proto';\nimport {bytesAsU8} from './proto_shims';\nimport {Constructor, isInstanceOf} from './util';\n\n// key managers maps\nconst typeToManagerMap_ = new Map<string, KeyManager.KeyManager<unknown>>();\n\nconst typeToNewKeyAllowedMap_ = new Map<string, boolean>();\n\n// primitive wrappers map\nconst primitiveTypeToWrapper_ = new Map<unknown, PrimitiveWrapper<unknown>>();\n\n/**\n * Register the given manager for the given key type. Manager must be\n * non-nullptr. New keys are allowed if not specified.\n */\nexport function registerKeyManager(\n    manager: KeyManager.KeyManager<unknown>, opt_newKeyAllowed?: boolean) {\n  if (opt_newKeyAllowed === undefined) {\n    opt_newKeyAllowed = true;\n  }\n  if (!manager) {\n    throw new SecurityException('Key manager cannot be null.');\n  }\n  const typeUrl = manager.getKeyType();\n  if (typeToManagerMap_.has(typeUrl)) {\n    // Cannot overwrite the existing key manager by a new one.\n    if (!(typeToManagerMap_.get(typeUrl) instanceof manager.constructor)) {\n      throw new SecurityException(\n          'Key manager for key type ' + typeUrl +\n          ' has already been registered and cannot be overwritten.');\n    }\n\n    // It is forbidden to change new_key_allowed from false to true.\n    if (!typeToNewKeyAllowedMap_.get(typeUrl) && opt_newKeyAllowed) {\n      throw new SecurityException(\n          'Key manager for key type ' + typeUrl +\n          ' has already been registered with forbidden new key operation.');\n    }\n    typeToNewKeyAllowedMap_.set(typeUrl, opt_newKeyAllowed);\n  }\n  typeToManagerMap_.set(typeUrl, manager);\n  typeToNewKeyAllowedMap_.set(typeUrl, opt_newKeyAllowed);\n}\n\n/**\n * Returns a key manager for the given key type or throws an exception if no\n * such manager found.\n *\n * @param typeUrl -- key type\n *\n */\nexport function getKeyManager(typeUrl: string): KeyManager.KeyManager<unknown> {\n  const res = typeToManagerMap_.get(typeUrl);\n  if (!res) {\n    throw new SecurityException(\n        'Key manager for key type ' + typeUrl + ' has not been registered.');\n  }\n  return res;\n}\n\n/**\n * It finds KeyManager according to key type (which is either given by\n * PbKeyData or given by opt_typeUrl), than calls the corresponding\n * manager's getPrimitive method.\n *\n * Either key is of type PbKeyData or opt_typeUrl must be provided.\n *\n * @param key -- key is either a proto of some key\n *     or key data.\n * @param opt_typeUrl -- key type\n * @this {typeof Registry}\n *\n */\nexport async function getPrimitive<P>(\n    primitiveType: Constructor<P>, key: PbKeyData|PbMessage,\n    opt_typeUrl?: string|null): Promise<P> {\n  if (key instanceof PbKeyData) {\n    if (opt_typeUrl && key.getTypeUrl() != opt_typeUrl) {\n      throw new SecurityException(\n          'Key type is ' + opt_typeUrl + ', but it is expected to be ' +\n          key.getTypeUrl() + ' or undefined.');\n    }\n    opt_typeUrl = key.getTypeUrl();\n  }\n  if (!opt_typeUrl) {\n    throw new SecurityException('Key type has to be specified.');\n  }\n  const manager = getKeyManager(opt_typeUrl);\n  const primitive = await manager.getPrimitive(primitiveType, key);\n  if (!isInstanceOf(primitive, primitiveType)) {\n    throw new TypeError('Unexpected type');\n  }\n  return primitive;\n}\n\n/**\n * Generates a new PbKeyData for the specified keyTemplate. It finds a\n * KeyManager given by keyTemplate.typeUrl and calls the newKeyData method of\n * that manager.\n *\n *\n *\n */\nexport async function newKeyData(keyTemplate: PbKeyTemplate):\n    Promise<PbKeyData> {\n  const manager = getKeyManagerWithNewKeyAllowedCheck_(keyTemplate);\n  return manager.getKeyFactory().newKeyData(bytesAsU8(keyTemplate.getValue()));\n}\n\n/**\n * Generates a new key for the specified keyTemplate using the\n * KeyManager determined by typeUrl field of the keyTemplate.\n *\n *\n *\n * @return returns a key proto\n */\nexport async function newKey(keyTemplate: PbKeyTemplate): Promise<PbMessage> {\n  const manager = getKeyManagerWithNewKeyAllowedCheck_(keyTemplate);\n  return manager.getKeyFactory().newKey(bytesAsU8(keyTemplate.getValue()));\n}\n\n/**\n * Convenience method for extracting the public key data from the private key\n * given by serializedPrivateKey.\n * It looks up a KeyManager identified by typeUrl, which must hold\n * PrivateKeyFactory, and calls getPublicKeyData method of that factory.\n *\n */\nexport function getPublicKeyData(\n    typeUrl: string, serializedPrivateKey: Uint8Array): PbKeyData {\n  const manager = getKeyManager(typeUrl);\n\n  // This solution might cause some problems in the future due to Closure\n  // compiler optimizations, which may map factory.getPublicKeyData to\n  // concrete function.\n  const factory = manager.getKeyFactory();\n  if (!factory.getPublicKeyData) {\n    throw new SecurityException(\n        'Key manager for key type ' + typeUrl +\n        ' does not have a private key factory.');\n  }\n  return factory.getPublicKeyData(serializedPrivateKey);\n}\n\n/**\n * Resets the registry.\n * After reset the registry is empty, i.e. it contains no key managers.\n *\n * This method is only for testing.\n */\nexport function reset() {\n  typeToManagerMap_.clear();\n  typeToNewKeyAllowedMap_.clear();\n  primitiveTypeToWrapper_.clear();\n}\n\n/**\n * It finds a KeyManager given by keyTemplate.typeUrl and returns it if it\n * allows creating new keys.\n *\n *\n */\nfunction getKeyManagerWithNewKeyAllowedCheck_(keyTemplate: PbKeyTemplate):\n    KeyManager.KeyManager<unknown> {\n  const keyType = keyTemplate.getTypeUrl();\n  const manager = getKeyManager(keyType);\n  if (!typeToNewKeyAllowedMap_.get(keyType)) {\n    throw new SecurityException(\n        'New key operation is forbidden for ' +\n        'key type: ' + keyType + '.');\n  }\n  return manager;\n}\n\n/**\n * Tries to register a primitive wrapper.\n */\nexport function registerPrimitiveWrapper<P>(wrapper: PrimitiveWrapper<P>) {\n  if (!wrapper) {\n    throw new SecurityException('primitive wrapper cannot be null');\n  }\n  const primitiveType = wrapper.getPrimitiveType();\n  if (!primitiveType) {\n    throw new SecurityException('primitive wrapper cannot be undefined');\n  }\n  if (primitiveTypeToWrapper_.has(primitiveType)) {\n    // Cannot overwrite the existing key manager by a new one.\n    if (!(primitiveTypeToWrapper_.get(primitiveType) instanceof\n          wrapper.constructor)) {\n      throw new SecurityException(\n          'primitive wrapper for type ' + primitiveType +\n          ' has already been registered and cannot be overwritten');\n    }\n  }\n  primitiveTypeToWrapper_.set(primitiveType, wrapper);\n}\n\n/**\n * Wraps a PrimitiveSet and returns a single instance.\n */\nexport function wrap<P>(primitiveSet: PrimitiveSet.PrimitiveSet<P>): P {\n  if (!primitiveSet) {\n    throw new SecurityException('primitive set cannot be null.');\n  }\n  const primitiveType = primitiveSet.getPrimitiveType();\n  const wrapper = primitiveTypeToWrapper_.get(primitiveType);\n  if (!wrapper) {\n    throw new SecurityException(\n        'no primitive wrapper found for type ' + primitiveType);\n  }\n  const primitive = wrapper.wrap(primitiveSet);\n  if (!isInstanceOf(primitive, primitiveType)) {\n    throw new TypeError('Unexpected type');\n  }\n  return primitive;\n}\n"]}