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.
238 lines • 26.9 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());
});
};
import { InvalidArgumentsException } from '../exception/invalid_arguments_exception';
import { SecurityException } from '../exception/security_exception';
import * as Random from '../subtle/random';
import * as PrimitiveSet from './primitive_set';
import { PbKeyData, PbKeyMaterialType, PbKeyset, PbKeysetKey, PbKeyStatusType } from './proto';
import { bytesAsU8 } from './proto_shims';
import * as Registry from './registry';
import * as Util from './util';
/**
* Keyset handle provide abstracted access to Keysets, to limit the exposure of
* actual protocol buffers that hold sensitive key material.
*
* @final
*/
export class KeysetHandle {
constructor(keyset) {
Util.validateKeyset(keyset);
this.keyset_ = keyset;
}
/**
* Returns a primitive that uses key material from this keyset handle. If
* opt_customKeyManager is defined then the provided key manager is used to
* instantiate primitives. Otherwise key manager from Registry is used.
*/
getPrimitive(primitiveType, opt_customKeyManager) {
return __awaiter(this, void 0, void 0, function* () {
if (!primitiveType) {
throw new InvalidArgumentsException('primitive type must be non-null');
}
const primitiveSet = yield this.getPrimitiveSet(primitiveType, opt_customKeyManager);
return Registry.wrap(primitiveSet);
});
}
/**
* Creates a set of primitives corresponding to the keys with status Enabled
* in the given keysetHandle, assuming all the correspoding key managers are
* present (keys with status different from Enabled are skipped). If provided
* uses customKeyManager instead of registered key managers for keys supported
* by the customKeyManager.
*
* Visible for testing.
*/
getPrimitiveSet(primitiveType, opt_customKeyManager) {
return __awaiter(this, void 0, void 0, function* () {
const primitiveSet = new PrimitiveSet.PrimitiveSet(primitiveType);
const keys = this.keyset_.getKeyList();
const keysLength = keys.length;
for (let i = 0; i < keysLength; i++) {
const key = keys[i];
if (key.getStatus() === PbKeyStatusType.ENABLED) {
const keyData = key.getKeyData();
if (!keyData) {
throw new SecurityException('Key data has to be non null.');
}
let primitive;
if (opt_customKeyManager &&
opt_customKeyManager.getKeyType() === keyData.getTypeUrl()) {
primitive =
yield opt_customKeyManager.getPrimitive(primitiveType, keyData);
}
else {
primitive = yield Registry.getPrimitive(primitiveType, keyData);
}
const entry = primitiveSet.addPrimitive(primitive, key);
if (key.getKeyId() === this.keyset_.getPrimaryKeyId()) {
primitiveSet.setPrimary(entry);
}
}
}
return primitiveSet;
});
}
/**
* Encrypts the underlying keyset with the provided masterKeyAead wnd writes
* the resulting encryptedKeyset to the given writer which must be non-null.
*
*
*/
write(writer, masterKeyAead) {
return __awaiter(this, void 0, void 0, function* () {
// TODO implement
throw new SecurityException('KeysetHandle -- write: Not implemented yet.');
});
}
/**
* Writes this keyset using `writer` if and only if the keyset doesn't contain
* any secret key material.
*
* This can be used to persist public keysets or envelope encryption keysets.
* Use `CleartextKeysetHandle` to persist keysets containing secret key
* material.
*/
writeNoSecret(writer) {
assertNoSecretKeyMaterial(this.keyset_);
return writer.encodeBinary(this.keyset_);
}
/**
* Returns the keyset held by this KeysetHandle.
*
*/
getKeyset() {
return this.keyset_;
}
/**
* If the managed keyset contains private keys, returns a `KeysetHandle` of
* the public keys.
*/
getPublicKeysetHandle() {
const publicKeyset = new PbKeyset();
for (const key of this.keyset_.getKeyList()) {
publicKeyset.addKey(key.clone().setKeyData(createPublicKeyData(nonNull('Key data', key.getKeyData()))));
}
publicKeyset.setPrimaryKeyId(this.keyset_.getPrimaryKeyId());
return new KeysetHandle(publicKeyset);
}
}
function nonNull(desc, value) {
if (value == null) {
throw new SecurityException(`${desc} has to be non null.`);
}
return value;
}
function createPublicKeyData(privateKeyData) {
if (privateKeyData.getKeyMaterialType() !==
PbKeyData.KeyMaterialType.ASYMMETRIC_PRIVATE) {
throw new SecurityException('The keyset contains a non-private key');
}
return Registry.getPublicKeyData(privateKeyData.getTypeUrl(), bytesAsU8(privateKeyData.getValue()));
}
/**
* Validates that `keyset` doesn't contain any secret key material.
*
* @throws SecurityException if `keyset` contains secret key material.
*/
function assertNoSecretKeyMaterial(keyset) {
for (const key of keyset.getKeyList()) {
const keyData = nonNull('Key data', key.getKeyData());
if (isSecretKeyMaterialType(keyData.getKeyMaterialType())) {
throw new SecurityException('Keyset contains secret key material.');
}
}
}
/** Returns true if the key material type is secret. */
function isSecretKeyMaterialType(type) {
return type === PbKeyMaterialType.UNKNOWN_KEYMATERIAL ||
type === PbKeyMaterialType.SYMMETRIC ||
type === PbKeyMaterialType.ASYMMETRIC_PRIVATE;
}
/**
* Creates a KeysetHandle from an encrypted keyset obtained via reader, using
* masterKeyAead to decrypt the keyset.
*
*
*/
export function read(reader, masterKeyAead) {
return __awaiter(this, void 0, void 0, function* () {
// TODO implement
throw new SecurityException('KeysetHandle -- read: Not implemented yet.');
});
}
/**
* Returns a new KeysetHandle that contains a single new key generated
* according to keyTemplate.
*
*
*/
export function generateNew(keyTemplate) {
return __awaiter(this, void 0, void 0, function* () {
// TODO(thaidn): move this to a key manager.
const keyset = yield generateNewKeyset_(keyTemplate);
return new KeysetHandle(keyset);
});
}
/**
* Generates a new Keyset that contains a single new key generated
* according to keyTemplate.
*
*/
function generateNewKeyset_(keyTemplate) {
return __awaiter(this, void 0, void 0, function* () {
const key = (new PbKeysetKey())
.setStatus(PbKeyStatusType.ENABLED)
.setOutputPrefixType(keyTemplate.getOutputPrefixType());
const keyId = generateNewKeyId_();
key.setKeyId(keyId);
const keyData = yield Registry.newKeyData(keyTemplate);
key.setKeyData(keyData);
const keyset = new PbKeyset();
keyset.addKey(key);
keyset.setPrimaryKeyId(keyId);
return keyset;
});
}
/**
* Generates a new random key ID.
*
* @return The key ID.
*/
function generateNewKeyId_() {
const bytes = Random.randBytes(4);
let value = 0;
for (let i = 0; i < bytes.length; i++) {
value += (bytes[i] & 255) << i * 8;
}
// Make sure the key ID is a positive integer smaller than 2^32.
return Math.abs(value) % Math.pow(2, 32);
}
/**
* Creates a KeysetHandle from a keyset, obtained via reader, which
* must contain no secret key material.
*
* This can be used to load public keysets or envelope encryption keysets.
* Users that need to load cleartext keysets can use CleartextKeysetHandle.
*
*/
export function readNoSecret(reader) {
if (reader === null) {
throw new SecurityException('Reader has to be non-null.');
}
const keyset = reader.read();
assertNoSecretKeyMaterial(keyset);
return new KeysetHandle(keyset);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyset_handle.js","sourceRoot":"","sources":["../../../../internal/keyset_handle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {Aead} from '../aead/internal/aead';\nimport {InvalidArgumentsException} from '../exception/invalid_arguments_exception';\nimport {SecurityException} from '../exception/security_exception';\nimport * as Random from '../subtle/random';\n\nimport * as KeyManager from './key_manager';\nimport {KeysetReader} from './keyset_reader';\nimport {KeysetWriter} from './keyset_writer';\nimport * as PrimitiveSet from './primitive_set';\nimport {PbKeyData, PbKeyMaterialType, PbKeyset, PbKeysetKey, PbKeyStatusType, PbKeyTemplate} from './proto';\nimport {bytesAsU8} from './proto_shims';\nimport * as Registry from './registry';\nimport * as Util from './util';\n\n/**\n * Keyset handle provide abstracted access to Keysets, to limit the exposure of\n * actual protocol buffers that hold sensitive key material.\n *\n * @final\n */\nexport class KeysetHandle {\n  private readonly keyset_: PbKeyset;\n\n  constructor(keyset: PbKeyset) {\n    Util.validateKeyset(keyset);\n    this.keyset_ = keyset;\n  }\n\n  /**\n   * Returns a primitive that uses key material from this keyset handle. If\n   * opt_customKeyManager is defined then the provided key manager is used to\n   * instantiate primitives. Otherwise key manager from Registry is used.\n   */\n  async getPrimitive<P>(\n      primitiveType: Util.Constructor<P>,\n      opt_customKeyManager?: KeyManager.KeyManager<P>|null): Promise<P> {\n    if (!primitiveType) {\n      throw new InvalidArgumentsException('primitive type must be non-null');\n    }\n    const primitiveSet =\n        await this.getPrimitiveSet(primitiveType, opt_customKeyManager);\n    return Registry.wrap(primitiveSet);\n  }\n\n  /**\n   * Creates a set of primitives corresponding to the keys with status Enabled\n   * in the given keysetHandle, assuming all the correspoding key managers are\n   * present (keys with status different from Enabled are skipped). If provided\n   * uses customKeyManager instead of registered key managers for keys supported\n   * by the customKeyManager.\n   *\n   * Visible for testing.\n   */\n  async getPrimitiveSet<P>(\n      primitiveType: Util.Constructor<P>,\n      opt_customKeyManager?: KeyManager.KeyManager<P>|\n      null): Promise<PrimitiveSet.PrimitiveSet<P>> {\n    const primitiveSet = new PrimitiveSet.PrimitiveSet<P>(primitiveType);\n    const keys = this.keyset_.getKeyList();\n    const keysLength = keys.length;\n    for (let i = 0; i < keysLength; i++) {\n      const key = keys[i];\n      if (key.getStatus() === PbKeyStatusType.ENABLED) {\n        const keyData = key.getKeyData();\n        if (!keyData) {\n          throw new SecurityException('Key data has to be non null.');\n        }\n        let primitive;\n        if (opt_customKeyManager &&\n            opt_customKeyManager.getKeyType() === keyData.getTypeUrl()) {\n          primitive =\n              await opt_customKeyManager.getPrimitive(primitiveType, keyData);\n        } else {\n          primitive = await Registry.getPrimitive<P>(primitiveType, keyData);\n        }\n        const entry = primitiveSet.addPrimitive(primitive, key);\n        if (key.getKeyId() === this.keyset_.getPrimaryKeyId()) {\n          primitiveSet.setPrimary(entry);\n        }\n      }\n    }\n    return primitiveSet;\n  }\n\n  /**\n   * Encrypts the underlying keyset with the provided masterKeyAead wnd writes\n   * the resulting encryptedKeyset to the given writer which must be non-null.\n   *\n   *\n   */\n  async write(writer: KeysetWriter, masterKeyAead: Aead) {\n    // TODO implement\n    throw new SecurityException('KeysetHandle -- write: Not implemented yet.');\n  }\n\n  /**\n   * Writes this keyset using `writer` if and only if the keyset doesn't contain\n   * any secret key material.\n   *\n   * This can be used to persist public keysets or envelope encryption keysets.\n   * Use `CleartextKeysetHandle` to persist keysets containing secret key\n   * material.\n   */\n  writeNoSecret(writer: KeysetWriter): Uint8Array {\n    assertNoSecretKeyMaterial(this.keyset_);\n    return writer.encodeBinary(this.keyset_);\n  }\n\n  /**\n   * Returns the keyset held by this KeysetHandle.\n   *\n   */\n  getKeyset(): PbKeyset {\n    return this.keyset_;\n  }\n\n  /**\n   * If the managed keyset contains private keys, returns a `KeysetHandle` of\n   * the public keys.\n   */\n  getPublicKeysetHandle(): KeysetHandle {\n    const publicKeyset = new PbKeyset();\n    for (const key of this.keyset_.getKeyList()) {\n      publicKeyset.addKey(key.clone().setKeyData(createPublicKeyData(\n          nonNull('Key data', key.getKeyData()))));\n    }\n    publicKeyset.setPrimaryKeyId(this.keyset_.getPrimaryKeyId());\n    return new KeysetHandle(publicKeyset);\n  }\n}\n\nfunction nonNull<T>(desc: string, value: T|null|undefined): T {\n  if (value == null) {\n    throw new SecurityException(`${desc} has to be non null.`);\n  }\n  return value;\n}\n\nfunction createPublicKeyData(privateKeyData: PbKeyData): PbKeyData {\n  if (privateKeyData.getKeyMaterialType() !==\n      PbKeyData.KeyMaterialType.ASYMMETRIC_PRIVATE) {\n    throw new SecurityException('The keyset contains a non-private key');\n  }\n  return Registry.getPublicKeyData(\n      privateKeyData.getTypeUrl(), bytesAsU8(privateKeyData.getValue()));\n}\n\n/**\n * Validates that `keyset` doesn't contain any secret key material.\n *\n * @throws SecurityException if `keyset` contains secret key material.\n */\nfunction assertNoSecretKeyMaterial(keyset: PbKeyset) {\n  for (const key of keyset.getKeyList()) {\n    const keyData = nonNull('Key data', key.getKeyData());\n    if (isSecretKeyMaterialType(keyData.getKeyMaterialType())) {\n      throw new SecurityException('Keyset contains secret key material.');\n    }\n  }\n}\n\n/** Returns true if the key material type is secret. */\nfunction isSecretKeyMaterialType(type: PbKeyMaterialType) {\n  return type === PbKeyMaterialType.UNKNOWN_KEYMATERIAL ||\n      type === PbKeyMaterialType.SYMMETRIC ||\n      type === PbKeyMaterialType.ASYMMETRIC_PRIVATE;\n}\n\n/**\n * Creates a KeysetHandle from an encrypted keyset obtained via reader, using\n * masterKeyAead to decrypt the keyset.\n *\n *\n */\nexport async function read(\n    reader: KeysetReader, masterKeyAead: Aead): Promise<KeysetHandle> {\n  // TODO implement\n  throw new SecurityException('KeysetHandle -- read: Not implemented yet.');\n}\n\n/**\n * Returns a new KeysetHandle that contains a single new key generated\n * according to keyTemplate.\n *\n *\n */\nexport async function generateNew(keyTemplate: PbKeyTemplate):\n    Promise<KeysetHandle> {\n  // TODO(thaidn): move this to a key manager.\n  const keyset = await generateNewKeyset_(keyTemplate);\n  return new KeysetHandle(keyset);\n}\n\n/**\n * Generates a new Keyset that contains a single new key generated\n * according to keyTemplate.\n *\n */\nasync function generateNewKeyset_(keyTemplate: PbKeyTemplate):\n    Promise<PbKeyset> {\n  const key = (new PbKeysetKey())\n                  .setStatus(PbKeyStatusType.ENABLED)\n                  .setOutputPrefixType(keyTemplate.getOutputPrefixType());\n  const keyId = generateNewKeyId_();\n  key.setKeyId(keyId);\n  const keyData = await Registry.newKeyData(keyTemplate);\n  key.setKeyData(keyData);\n  const keyset = new PbKeyset();\n  keyset.addKey(key);\n  keyset.setPrimaryKeyId(keyId);\n  return keyset;\n}\n\n/**\n * Generates a new random key ID.\n *\n * @return The key ID.\n */\nfunction generateNewKeyId_(): number {\n  const bytes = Random.randBytes(4);\n  let value = 0;\n  for (let i = 0; i < bytes.length; i++) {\n    value += (bytes[i] & 255) << i * 8;\n  }\n\n  // Make sure the key ID is a positive integer smaller than 2^32.\n  return Math.abs(value) % 2 ** 32;\n}\n\n/**\n * Creates a KeysetHandle from a keyset, obtained via reader, which\n * must contain no secret key material.\n *\n * This can be used to load public keysets or envelope encryption keysets.\n * Users that need to load cleartext keysets can use CleartextKeysetHandle.\n *\n */\nexport function readNoSecret(reader: KeysetReader): KeysetHandle {\n  if (reader === null) {\n    throw new SecurityException('Reader has to be non-null.');\n  }\n  const keyset = reader.read();\n  assertNoSecretKeyMaterial(keyset);\n  return new KeysetHandle(keyset);\n}\n"]}