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.
120 lines • 15.7 kB
JavaScript
/**
* @license
* Copyright 2020 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import { SecurityException } from '../exception/security_exception';
import * as Bytes from '../subtle/bytes';
import * as EllipticCurves from '../subtle/elliptic_curves';
import { PbEllipticCurveType, PbHashType, PbKeyStatusType, PbOutputPrefixType, PbPointFormat } from './proto';
/** Like the `instanceof` operator, but works with `Constructor`. */
export function isInstanceOf(value, ctor) {
return value instanceof ctor;
}
/**
* Validates the given key and throws SecurityException if it is invalid.
*
*/
export function validateKey(key) {
if (!key) {
throw new SecurityException('Key should be non null.');
}
if (!key.getKeyData()) {
throw new SecurityException('Key data are missing for key ' + key.getKeyId() + '.');
}
if (key.getOutputPrefixType() === PbOutputPrefixType.UNKNOWN_PREFIX) {
throw new SecurityException('Key ' + key.getKeyId() + ' has unknown output prefix type.');
}
if (key.getStatus() === PbKeyStatusType.UNKNOWN_STATUS) {
throw new SecurityException('Key ' + key.getKeyId() + ' has unknown status.');
}
}
/**
* Validates the given keyset and throws SecurityException if it is invalid.
*
*/
export function validateKeyset(keyset) {
if (!keyset || !keyset.getKeyList() || keyset.getKeyList().length < 1) {
throw new SecurityException('Keyset should be non null and must contain at least one key.');
}
let hasPrimary = false;
const numberOfKeys = keyset.getKeyList().length;
for (let i = 0; i < numberOfKeys; i++) {
const key = keyset.getKeyList()[i];
validateKey(key);
if (keyset.getPrimaryKeyId() === key.getKeyId() &&
key.getStatus() === PbKeyStatusType.ENABLED) {
if (hasPrimary) {
throw new SecurityException('Primary key has to be unique.');
}
hasPrimary = true;
}
}
if (!hasPrimary) {
throw new SecurityException('Primary key has to be in the keyset and ' +
'has to be enabled.');
}
}
// Functions which are useful for implementation of
// private and public EC keys.
/**
* Either prolong or shrinks the array representing number in BigEndian encoding
* to have the specified size. As webcrypto API assumes that x, y and d values
* has exactly the supposed number of bytes, whereas corresponding x, y and
* keyValue values in proto might either have some leading zeros or the leading
* zeros might be missing.
*
*/
export function bigEndianNumberToCorrectLength(bigEndianNumber, sizeInBytes) {
const numberLen = bigEndianNumber.length;
if (numberLen < sizeInBytes) {
const zeros = new Uint8Array(sizeInBytes - numberLen);
return Bytes.concat(zeros, bigEndianNumber);
}
if (numberLen > sizeInBytes) {
for (let i = 0; i < numberLen - sizeInBytes; i++) {
if (bigEndianNumber[i] != 0) {
throw new SecurityException('Number needs more bytes to be represented.');
}
}
return bigEndianNumber.slice(numberLen - sizeInBytes, numberLen);
}
return bigEndianNumber;
}
export function curveTypeProtoToSubtle(curveTypeProto) {
switch (curveTypeProto) {
case PbEllipticCurveType.NIST_P256:
return EllipticCurves.CurveType.P256;
case PbEllipticCurveType.NIST_P384:
return EllipticCurves.CurveType.P384;
case PbEllipticCurveType.NIST_P521:
return EllipticCurves.CurveType.P521;
default:
throw new SecurityException('Unknown curve type.');
}
}
export function hashTypeProtoToString(hashTypeProto) {
switch (hashTypeProto) {
case PbHashType.SHA1:
return 'SHA-1';
case PbHashType.SHA256:
return 'SHA-256';
case PbHashType.SHA512:
return 'SHA-512';
default:
throw new SecurityException('Unknown hash type.');
}
}
export function pointFormatProtoToSubtle(pointFormatProto) {
switch (pointFormatProto) {
case PbPointFormat.UNCOMPRESSED:
return EllipticCurves.PointFormatType.UNCOMPRESSED;
case PbPointFormat.COMPRESSED:
return EllipticCurves.PointFormatType.COMPRESSED;
case PbPointFormat.DO_NOT_USE_CRUNCHY_UNCOMPRESSED:
return EllipticCurves.PointFormatType.DO_NOT_USE_CRUNCHY_UNCOMPRESSED;
default:
throw new SecurityException('Unknown point format.');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../internal/util.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 {SecurityException} from '../exception/security_exception';\nimport * as Bytes from '../subtle/bytes';\nimport * as EllipticCurves from '../subtle/elliptic_curves';\n\nimport {PbEllipticCurveType, PbHashType, PbKeyset, PbKeysetKey, PbKeyStatusType, PbOutputPrefixType, PbPointFormat} from './proto';\n\n/**\n * A type representing the constructor function for a given class. Unlike\n * TypeScript's built-in `new` types, this works with abstract classes. It is\n * used to describe the relationship between a primitive type object and its\n * instances.\n */\nexport type Constructor<T> = Function&{prototype: T};\n\n/** Like the `instanceof` operator, but works with `Constructor`. */\nexport function isInstanceOf<T>(\n    value: unknown, ctor: Constructor<T>): value is T {\n  return value instanceof ctor;\n}\n\n/**\n * Validates the given key and throws SecurityException if it is invalid.\n *\n */\nexport function validateKey(key: PbKeysetKey) {\n  if (!key) {\n    throw new SecurityException('Key should be non null.');\n  }\n  if (!key.getKeyData()) {\n    throw new SecurityException(\n        'Key data are missing for key ' + key.getKeyId() + '.');\n  }\n  if (key.getOutputPrefixType() === PbOutputPrefixType.UNKNOWN_PREFIX) {\n    throw new SecurityException(\n        'Key ' + key.getKeyId() + ' has unknown output prefix type.');\n  }\n  if (key.getStatus() === PbKeyStatusType.UNKNOWN_STATUS) {\n    throw new SecurityException(\n        'Key ' + key.getKeyId() + ' has unknown status.');\n  }\n}\n\n/**\n * Validates the given keyset and throws SecurityException if it is invalid.\n *\n */\nexport function validateKeyset(keyset: PbKeyset) {\n  if (!keyset || !keyset.getKeyList() || keyset.getKeyList().length < 1) {\n    throw new SecurityException(\n        'Keyset should be non null and must contain at least one key.');\n  }\n  let hasPrimary = false;\n  const numberOfKeys = keyset.getKeyList().length;\n  for (let i = 0; i < numberOfKeys; i++) {\n    const key = keyset.getKeyList()[i];\n    validateKey(key);\n    if (keyset.getPrimaryKeyId() === key.getKeyId() &&\n        key.getStatus() === PbKeyStatusType.ENABLED) {\n      if (hasPrimary) {\n        throw new SecurityException('Primary key has to be unique.');\n      }\n      hasPrimary = true;\n    }\n  }\n  if (!hasPrimary) {\n    throw new SecurityException(\n        'Primary key has to be in the keyset and ' +\n        'has to be enabled.');\n  }\n}\n\n// Functions which are useful for implementation of\n// private and public EC keys.\n\n/**\n * Either prolong or shrinks the array representing number in BigEndian encoding\n * to have the specified size. As webcrypto API assumes that x, y and d values\n * has exactly the supposed number of bytes, whereas corresponding x, y and\n * keyValue values in proto might either have some leading zeros or the leading\n * zeros might be missing.\n *\n */\nexport function bigEndianNumberToCorrectLength(\n    bigEndianNumber: Uint8Array, sizeInBytes: number): Uint8Array {\n  const numberLen = bigEndianNumber.length;\n  if (numberLen < sizeInBytes) {\n    const zeros = new Uint8Array(sizeInBytes - numberLen);\n    return Bytes.concat(zeros, bigEndianNumber);\n  }\n  if (numberLen > sizeInBytes) {\n    for (let i = 0; i < numberLen - sizeInBytes; i++) {\n      if (bigEndianNumber[i] != 0) {\n        throw new SecurityException(\n            'Number needs more bytes to be represented.');\n      }\n    }\n    return bigEndianNumber.slice(numberLen - sizeInBytes, numberLen);\n  }\n  return bigEndianNumber;\n}\n\nexport function curveTypeProtoToSubtle(curveTypeProto: PbEllipticCurveType):\n    EllipticCurves.CurveType {\n  switch (curveTypeProto) {\n    case PbEllipticCurveType.NIST_P256:\n      return EllipticCurves.CurveType.P256;\n    case PbEllipticCurveType.NIST_P384:\n      return EllipticCurves.CurveType.P384;\n    case PbEllipticCurveType.NIST_P521:\n      return EllipticCurves.CurveType.P521;\n    default:\n      throw new SecurityException('Unknown curve type.');\n  }\n}\n\nexport function hashTypeProtoToString(hashTypeProto: PbHashType): string {\n  switch (hashTypeProto) {\n    case PbHashType.SHA1:\n      return 'SHA-1';\n    case PbHashType.SHA256:\n      return 'SHA-256';\n    case PbHashType.SHA512:\n      return 'SHA-512';\n    default:\n      throw new SecurityException('Unknown hash type.');\n  }\n}\n\nexport function pointFormatProtoToSubtle(pointFormatProto: PbPointFormat):\n    EllipticCurves.PointFormatType {\n  switch (pointFormatProto) {\n    case PbPointFormat.UNCOMPRESSED:\n      return EllipticCurves.PointFormatType.UNCOMPRESSED;\n    case PbPointFormat.COMPRESSED:\n      return EllipticCurves.PointFormatType.COMPRESSED;\n    case PbPointFormat.DO_NOT_USE_CRUNCHY_UNCOMPRESSED:\n      return EllipticCurves.PointFormatType.DO_NOT_USE_CRUNCHY_UNCOMPRESSED;\n    default:\n      throw new SecurityException('Unknown point format.');\n  }\n}\n"]}