blob: fc889ca6d115b30cb585029f260b39de636b848c [file] [log] [blame]
/**
* @license
* Copyright 2020 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import {Aead} from '../aead';
import {AeadConfig} from '../aead/aead_config';
import {AeadKeyTemplates} from '../aead/aead_key_templates';
import {AesCtrHmacAeadKeyManager} from '../aead/aes_ctr_hmac_aead_key_manager';
import {SecurityException} from '../exception/security_exception';
import * as HybridConfig from '../hybrid/hybrid_config';
import {HybridKeyTemplates} from '../hybrid/hybrid_key_templates';
import {Mac} from '../mac';
import {EncryptThenAuthenticate} from '../subtle/encrypt_then_authenticate';
import {assertExists, assertInstanceof} from '../testing/internal/test_utils';
import * as KeyManager from './key_manager';
import * as PrimitiveSet from './primitive_set';
import {PrimitiveWrapper} from './primitive_wrapper';
import {PbAesCtrHmacAeadKey, PbAesCtrHmacAeadKeyFormat, PbAesCtrKey, PbAesCtrKeyFormat, PbAesCtrParams, PbEciesAeadHkdfPrivateKey, PbEciesAeadHkdfPublicKey, PbHashType, PbHmacKeyFormat, PbHmacParams, PbKeyData, PbKeyTemplate, PbMessage} from './proto';
import * as Registry from './registry';
import {Constructor} from './util';
////////////////////////////////////////////////////////////////////////////////
// tests
////////////////////////////////////////////////////////////////////////////////
describe('registry test', function() {
afterEach(function() {
Registry.reset();
});
/////////////////////////////////////////////////////////////////////////////
// tests for registerPrimitiveWrapper method
it('register primitive wrapper, overwriting with same class', function() {
Registry.registerPrimitiveWrapper(new DummyPrimitiveWrapper1(
new DummyPrimitive1Impl1(), DummyPrimitive1));
Registry.registerPrimitiveWrapper(new DummyPrimitiveWrapper1(
new DummyPrimitive1Impl2(), DummyPrimitive1));
});
it('register primitive wrapper, overwriting with different class',
function() {
class DummyPrimitiveWrapper1Alternative implements
PrimitiveWrapper<DummyPrimitive1> {
wrap(): DummyPrimitive1 {
throw new Error();
}
getPrimitiveType() {
return DummyPrimitive1;
}
}
Registry.registerPrimitiveWrapper(new DummyPrimitiveWrapper1(
new DummyPrimitive1Impl1(), DummyPrimitive1));
try {
Registry.registerPrimitiveWrapper(
new DummyPrimitiveWrapper1Alternative());
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString())
.toBe(
'SecurityException: primitive wrapper for type ' +
DummyPrimitive1 +
' has already been registered and cannot be overwritten');
}
});
/////////////////////////////////////////////////////////////////////////////
// tests for wrap method
it('wrap, should work', function() {
const p1 = new DummyPrimitive1Impl1();
const p2 = new DummyPrimitive2Impl();
Registry.registerPrimitiveWrapper(
new DummyPrimitiveWrapper1(p1, DummyPrimitive1));
Registry.registerPrimitiveWrapper(
new DummyPrimitiveWrapper2(p2, DummyPrimitive2));
expect(Registry.wrap(new PrimitiveSet.PrimitiveSet(DummyPrimitive1)))
.toBe(p1);
expect(Registry.wrap(new PrimitiveSet.PrimitiveSet(DummyPrimitive2)))
.toBe(p2);
});
it('wrap, not registered primitive type', function() {
expect(() => {
Registry.wrap(new PrimitiveSet.PrimitiveSet(DummyPrimitive1));
}).toThrowError('no primitive wrapper found for type ' + DummyPrimitive1);
});
/////////////////////////////////////////////////////////////////////////////
// tests for registerKeyManager method
it('register key manager, overwriting attempt', function() {
const keyType = 'someKeyType';
try {
Registry.registerKeyManager(new DummyKeyManager1(keyType));
Registry.registerKeyManager(new DummyKeyManager2(keyType));
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.keyManagerOverwrittingAttempt(keyType));
return;
}
fail('An exception should be thrown.');
});
// Testing newKeyAllowed behavior -- should hold the most restrictive setting.
it('register key manager, more restrictive new key allowed',
async function() {
const keyType = 'someTypeUrl';
const keyManager1 = new DummyKeyManager1(keyType);
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyType);
// Register the key manager with new_key_allowed and test that it is
// possible to create a new key data.
Registry.registerKeyManager(keyManager1);
await Registry.newKeyData(keyTemplate);
// Restrict the key manager and test that new key data cannot be created.
Registry.registerKeyManager(keyManager1, false);
try {
await Registry.newKeyData(keyTemplate);
} catch (e: any) {
expect(e.toString()).toBe(ExceptionText.newKeyForbidden(keyType));
return;
}
fail('An exception should be thrown.');
});
it('register key manager, less restrictive new key allowed',
async function() {
const keyType = 'someTypeUrl';
const keyManager1 = new DummyKeyManager1(keyType);
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyType);
Registry.registerKeyManager(keyManager1, false);
// Re-registering key manager with less restrictive setting should not be
// possible and the restriction has to be still true (i.e. new key data
// cannot be created).
try {
Registry.registerKeyManager(keyManager1);
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.prohibitedChangeToLessRestricted(
keyManager1.getKeyType()));
}
try {
await Registry.newKeyData(keyTemplate);
} catch (e: any) {
expect(e.toString()).toBe(ExceptionText.newKeyForbidden(keyType));
return;
}
fail('An exception should be thrown.');
});
/////////////////////////////////////////////////////////////////////////////
// tests for getKeyManager method
it('get key manager, should work', function() {
const numberOfKeyManagers = 10;
const keyManagers1 = [];
const keyManagers2 = [];
for (let i = 0; i < numberOfKeyManagers; i++) {
keyManagers1.push(new DummyKeyManager1('someKeyType' + i.toString()));
keyManagers2.push(new DummyKeyManager2('otherKeyType' + i.toString()));
Registry.registerKeyManager(keyManagers1[i]);
Registry.registerKeyManager(keyManagers2[i]);
}
let result;
for (let i = 0; i < numberOfKeyManagers; i++) {
result = Registry.getKeyManager(keyManagers1[i].getKeyType());
expect(result).toEqual(keyManagers1[i]);
result = Registry.getKeyManager(keyManagers2[i].getKeyType());
expect(result).toEqual(keyManagers2[i]);
}
});
it('get key manager, not registered key type', function() {
const keyType = 'some_key_type';
try {
Registry.getKeyManager(keyType);
} catch (e: any) {
expect(e.toString()).toBe(ExceptionText.notRegisteredKeyType(keyType));
return;
}
fail('An exception should be thrown.');
});
/////////////////////////////////////////////////////////////////////////////
// tests for newKeyData method
it('new key data, no manager for given key type', async function() {
const keyManager1 = new DummyKeyManager1('someKeyType');
const differentKeyType = 'otherKeyType';
const keyTemplate = new PbKeyTemplate().setTypeUrl(differentKeyType);
Registry.registerKeyManager(keyManager1);
try {
await Registry.newKeyData(keyTemplate);
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.notRegisteredKeyType(differentKeyType));
return;
}
fail('An exception should be thrown.');
});
it('new key data, new key disallowed', async function() {
const keyManager1 = new DummyKeyManager1('someKeyType');
const keyTemplate =
new PbKeyTemplate().setTypeUrl(keyManager1.getKeyType());
Registry.registerKeyManager(keyManager1, false);
try {
await Registry.newKeyData(keyTemplate);
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.newKeyForbidden(keyManager1.getKeyType()));
return;
}
fail('An exception should be thrown.');
});
it('new key data, new key allowed', async function() {
const keyTypes: string[] = [];
for (let i = 0; i < 10; i++) {
keyTypes.push('someKeyType' + i.toString());
}
const keyTypesLength = keyTypes.length;
for (let i = 0; i < keyTypesLength; i++) {
Registry.registerKeyManager(new DummyKeyManager1(keyTypes[i]), true);
}
for (let i = 0; i < keyTypesLength; i++) {
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyTypes[i]);
const result = await Registry.newKeyData(keyTemplate);
expect(result.getTypeUrl()).toBe(keyTypes[i]);
}
});
it('new key data, new key is allowed automatically', async function() {
const keyTypes: string[] = [];
for (let i = 0; i < 10; i++) {
keyTypes.push('someKeyType' + i.toString());
}
const keyTypesLength = keyTypes.length;
for (let i = 0; i < keyTypesLength; i++) {
Registry.registerKeyManager(new DummyKeyManager1(keyTypes[i]));
}
for (let i = 0; i < keyTypesLength; i++) {
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyTypes[i]);
const result = await Registry.newKeyData(keyTemplate);
expect(result.getTypeUrl()).toBe(keyTypes[i]);
}
});
it('new key data, with aes ctr hmac aead key', async function() {
const manager = new AesCtrHmacAeadKeyManager();
Registry.registerKeyManager(manager);
const keyTemplate = createAesCtrHmacAeadTestKeyTemplate();
const keyData = await Registry.newKeyData(keyTemplate);
// Checks that correct AES CTR HMAC AEAD key was returned.
const keyFormat = PbAesCtrHmacAeadKeyFormat.deserializeBinary(
keyTemplate.getValue_asU8());
const key = PbAesCtrHmacAeadKey.deserializeBinary(keyData.getValue_asU8());
// Check AES CTR key.
expect(keyFormat.getAesCtrKeyFormat()?.getKeySize())
.toBe(key.getAesCtrKey()?.getKeyValue_asU8().length);
expect(keyFormat.getAesCtrKeyFormat()?.getParams())
.toEqual(key.getAesCtrKey()?.getParams());
// Check HMAC key.
expect(keyFormat.getHmacKeyFormat()?.getKeySize())
.toBe(key.getHmacKey()?.getKeyValue_asU8().length);
expect(keyFormat.getHmacKeyFormat()?.getParams())
.toEqual(key.getHmacKey()?.getParams());
});
/////////////////////////////////////////////////////////////////////////////
// tests for newKey method
it('new key, no manager for given key type', async function() {
const notRegisteredKeyType = 'not_registered_key_type';
const keyTemplate = new PbKeyTemplate().setTypeUrl(notRegisteredKeyType);
try {
await Registry.newKey(keyTemplate);
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.notRegisteredKeyType(notRegisteredKeyType));
}
});
it('new key, new key disallowed', async function() {
const keyManager = new DummyKeyManagerForNewKeyTests('someKeyType');
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyManager.getKeyType());
Registry.registerKeyManager(keyManager, /* opt_newKeyAllowed = */ false);
try {
await Registry.newKey(keyTemplate);
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.newKeyForbidden(keyManager.getKeyType()));
}
});
it('new key, should work', async function() {
const keyTypes: string[] = [];
const newKeyMethodResult: Uint8Array[] = [];
const keyTypesLength = 10;
// Add some keys to Registry.
for (let i = 0; i < keyTypesLength; i++) {
keyTypes.push('someKeyType' + i.toString());
newKeyMethodResult.push(new Uint8Array([i + 1]));
Registry.registerKeyManager(
new DummyKeyManagerForNewKeyTests(keyTypes[i], newKeyMethodResult[i]),
/* newKeyAllowed = */ true);
}
// For every keyType verify that it calls new key method of the
// corresponding KeyManager (KeyFactory).
for (let i = 0; i < keyTypesLength; i++) {
const keyTemplate = new PbKeyTemplate().setTypeUrl(keyTypes[i]);
const key =
assertInstanceof(await Registry.newKey(keyTemplate), PbAesCtrKey);
// The new key method of DummyKeyFactory returns an AesCtrKey which
// KeyValue is set to corresponding value in newKeyMethodResult.
expect(key.getKeyValue_asU8()).toBe(newKeyMethodResult[i]);
}
});
it('new key, with aes ctr hmac aead key', async function() {
const manager = new AesCtrHmacAeadKeyManager();
Registry.registerKeyManager(manager);
const keyTemplate = AeadKeyTemplates.aes256CtrHmacSha256();
const key = assertInstanceof(
await Registry.newKey(keyTemplate), PbAesCtrHmacAeadKey);
// Checks that correct AES CTR HMAC AEAD key was returned.
const keyFormat = PbAesCtrHmacAeadKeyFormat.deserializeBinary(
keyTemplate.getValue_asU8());
// Check AES CTR key.
expect(keyFormat.getAesCtrKeyFormat()?.getKeySize())
.toBe(key.getAesCtrKey()?.getKeyValue_asU8().length);
expect(keyFormat.getAesCtrKeyFormat()?.getParams())
.toEqual(key.getAesCtrKey()?.getParams());
// Check HMAC key.
expect(keyFormat.getHmacKeyFormat()?.getKeySize())
.toBe(key.getHmacKey()?.getKeyValue_asU8().length);
expect(keyFormat.getHmacKeyFormat()?.getParams())
.toEqual(key.getHmacKey()?.getParams());
});
/////////////////////////////////////////////////////////////////////////////
// tests for getPrimitive method
it('get primitive, different key types', async function() {
const keyDataType = 'key_data_key_type_url';
const anotherType = 'another_key_type_url';
const keyData = new PbKeyData().setTypeUrl(keyDataType);
try {
await Registry.getPrimitive(Aead, keyData, anotherType);
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.keyTypesAreNotMatching(keyDataType, anotherType));
return;
}
fail('An exception should be thrown.');
});
it('get primitive, without defining key type', async function() {
// Get primitive from key proto without key type.
try {
await Registry.getPrimitive(Aead, new PbHmacParams());
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString()).toBe(ExceptionText.keyTypeNotDefined());
}
});
it('get primitive, missing key manager', async function() {
const keyDataType = 'key_data_key_type_url';
const keyData = new PbKeyData().setTypeUrl(keyDataType);
try {
await Registry.getPrimitive(Aead, keyData);
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.notRegisteredKeyType(keyDataType));
return;
}
fail('An exception should be thrown.');
});
it('get primitive, from aes ctr hmac aead key data', async function() {
const manager = new AesCtrHmacAeadKeyManager();
Registry.registerKeyManager(manager);
const keyTemplate = createAesCtrHmacAeadTestKeyTemplate();
const keyData = await Registry.newKeyData(keyTemplate);
const primitive =
await Registry.getPrimitive(manager.getPrimitiveType(), keyData);
expect(primitive instanceof EncryptThenAuthenticate).toBe(true);
});
it('get primitive, from aes ctr hmac aead key', async function() {
const manager = new AesCtrHmacAeadKeyManager();
Registry.registerKeyManager(manager);
const keyTemplate = createAesCtrHmacAeadTestKeyTemplate();
const keyData = await Registry.newKeyData(keyTemplate);
const key = PbAesCtrHmacAeadKey.deserializeBinary(keyData.getValue_asU8());
const primitive = await Registry.getPrimitive(
manager.getPrimitiveType(), key, keyData.getTypeUrl());
expect(primitive instanceof EncryptThenAuthenticate).toBe(true);
});
it('get primitive, mac from aes ctr hmac aead key', async function() {
const manager = new AesCtrHmacAeadKeyManager();
Registry.registerKeyManager(manager);
const keyTemplate = createAesCtrHmacAeadTestKeyTemplate();
const keyData = await Registry.newKeyData(keyTemplate);
const key = PbAesCtrHmacAeadKey.deserializeBinary(keyData.getValue_asU8());
try {
await Registry.getPrimitive(Mac, key, keyData.getTypeUrl());
} catch (e: any) {
expect(e.toString().includes(ExceptionText.getPrimitiveBadPrimitive()))
.toBe(true);
return;
}
fail('An exception should be thrown.');
});
describe('get public key data', function() {
it('not private key factory', function() {
AeadConfig.register();
const notPrivateTypeUrl = AeadConfig.AES_GCM_TYPE_URL;
try {
Registry.getPublicKeyData(notPrivateTypeUrl, new Uint8Array(8));
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString())
.toBe(ExceptionText.notPrivateKeyFactory(notPrivateTypeUrl));
}
});
it('invalid private key proto serialization', function() {
HybridConfig.register();
const typeUrl = HybridConfig.ECIES_AEAD_HKDF_PRIVATE_KEY_TYPE;
try {
Registry.getPublicKeyData(typeUrl, new Uint8Array(10));
fail('An exception should be thrown.');
} catch (e: any) {
expect(e.toString()).toBe(ExceptionText.couldNotParse(typeUrl));
}
});
it('should work', async function() {
HybridConfig.register();
const privateKeyData = await Registry.newKeyData(
HybridKeyTemplates.eciesP256HkdfHmacSha256Aes128Gcm());
const privateKey = PbEciesAeadHkdfPrivateKey.deserializeBinary(
privateKeyData.getValue_asU8());
const publicKeyData = Registry.getPublicKeyData(
privateKeyData.getTypeUrl(), privateKeyData.getValue_asU8());
expect(HybridConfig.ECIES_AEAD_HKDF_PUBLIC_KEY_TYPE)
.toBe(publicKeyData.getTypeUrl());
expect(PbKeyData.KeyMaterialType.ASYMMETRIC_PUBLIC)
.toBe(publicKeyData.getKeyMaterialType());
const expectedPublicKey = assertExists(privateKey.getPublicKey());
const publicKey = PbEciesAeadHkdfPublicKey.deserializeBinary(
publicKeyData.getValue_asU8());
expect(publicKey).toEqual(expectedPublicKey);
});
});
});
////////////////////////////////////////////////////////////////////////////////
// helper functions and classes for tests
////////////////////////////////////////////////////////////////////////////////
/**
* Class which holds texts for each type of exception.
* @final
*/
class ExceptionText {
static notImplemented(): string {
return 'SecurityException: Not implemented yet.';
}
static newKeyForbidden(keyType: string): string {
return 'SecurityException: New key operation is forbidden for key type: ' +
keyType + '.';
}
static notRegisteredKeyType(keyType: string): string {
return 'SecurityException: Key manager for key type ' + keyType +
' has not been registered.';
}
static nullKeyManager(): string {
return 'SecurityException: Key manager cannot be null.';
}
static undefinedKeyType(): string {
return 'SecurityException: Key type has to be defined.';
}
static keyManagerOverwrittingAttempt(keyType: string): string {
return 'SecurityException: Key manager for key type ' + keyType +
' has already been registered and cannot be overwritten.';
}
static notSupportedKey(givenKeyType: string): string {
return 'SecurityException: The provided key manager does not support ' +
'key type ' + givenKeyType + '.';
}
static prohibitedChangeToLessRestricted(keyType: string): string {
return 'SecurityException: Key manager for key type ' + keyType +
' has already been registered with forbidden new key operation.';
}
static keyTypesAreNotMatching(
keyTypeFromKeyData: string, keyTypeParam: string): string {
return 'SecurityException: Key type is ' + keyTypeParam +
', but it is expected to be ' + keyTypeFromKeyData + ' or undefined.';
}
static keyTypeNotDefined(): string {
return 'SecurityException: Key type has to be specified.';
}
static nullKeysetHandle(): string {
return 'SecurityException: Keyset handle has to be non-null.';
}
static getPrimitiveBadPrimitive(): string {
return 'Requested primitive type which is not supported by this ' +
'key manager.';
}
static notPrivateKeyFactory(typeUrl: string): string {
return 'SecurityException: Key manager for key type ' + typeUrl +
' does not have a private key factory.';
}
static couldNotParse(typeUrl: string): string {
return 'SecurityException: Input cannot be parsed as ' + typeUrl +
' key-proto.';
}
}
/** Creates AES CTR HMAC AEAD key format which can be used in tests */
function createAesCtrHmacAeadTestKeyTemplate(): PbKeyTemplate {
const KEY_SIZE = 16;
const IV_SIZE = 12;
const TAG_SIZE = 16;
const keyFormat = new PbAesCtrHmacAeadKeyFormat().setAesCtrKeyFormat(
new PbAesCtrKeyFormat());
keyFormat.getAesCtrKeyFormat()?.setKeySize(KEY_SIZE);
keyFormat.getAesCtrKeyFormat()?.setParams(new PbAesCtrParams());
keyFormat.getAesCtrKeyFormat()?.getParams()?.setIvSize(IV_SIZE);
// set HMAC key
keyFormat.setHmacKeyFormat(new PbHmacKeyFormat());
keyFormat.getHmacKeyFormat()?.setKeySize(KEY_SIZE);
keyFormat.getHmacKeyFormat()?.setParams(new PbHmacParams());
keyFormat.getHmacKeyFormat()?.getParams()?.setHash(PbHashType.SHA1);
keyFormat.getHmacKeyFormat()?.getParams()?.setTagSize(TAG_SIZE);
let keyTemplate =
new PbKeyTemplate()
.setTypeUrl(
'type.googleapis.com/google.crypto.tink.AesCtrHmacAeadKey')
.setValue(keyFormat.serializeBinary());
return keyTemplate;
}
// Key factory and key manager classes used in tests
/** @final */
class DummyKeyFactory implements KeyManager.KeyFactory {
constructor(
private readonly keyType: string,
private readonly newKeyMethodResult = new Uint8Array(10)) {}
/**
*/
newKey(keyFormat: PbMessage|Uint8Array) {
const key = new PbAesCtrKey().setKeyValue(this.newKeyMethodResult);
return key;
}
/**
*/
newKeyData(serializedKeyFormat: Uint8Array) {
const keyData =
new PbKeyData()
.setTypeUrl(this.keyType)
.setValue(this.newKeyMethodResult)
.setKeyMaterialType(PbKeyData.KeyMaterialType.UNKNOWN_KEYMATERIAL);
return keyData;
}
}
// Primitive abstract types for testing purposes.
abstract class DummyPrimitive1 {
abstract operation1(): number;
}
abstract class DummyPrimitive2 {
abstract operation2(): string;
}
// Primitive implementations for testing purposes.
class DummyPrimitive1Impl1 extends DummyPrimitive1 {
operation1() {
return 1;
}
}
class DummyPrimitive1Impl2 extends DummyPrimitive1 {
operation1() {
return 2;
}
}
class DummyPrimitive2Impl extends DummyPrimitive2 {
operation2() {
return 'dummy';
}
}
const DEFAULT_PRIMITIVE_TYPE = Aead;
/** @final */
class DummyKeyManager1 implements KeyManager.KeyManager<DummyPrimitive1> {
private readonly KEY_FACTORY: KeyManager.KeyFactory;
constructor(
private readonly keyType: string,
private readonly primitive: DummyPrimitive1 = new DummyPrimitive1Impl1(),
private readonly primitiveType = DummyPrimitive1) {
this.KEY_FACTORY = new DummyKeyFactory(keyType);
}
async getPrimitive(
primitiveType: Constructor<DummyKeyManager1>, key: PbKeyData|PbMessage) {
return this.primitive;
}
doesSupport(keyType: string) {
return keyType === this.getKeyType();
}
getKeyType() {
return this.keyType;
}
getPrimitiveType(): Constructor<DummyPrimitive1> {
return this.primitiveType;
}
getVersion(): number {
throw new SecurityException('Not implemented, only for testing purposes.');
}
getKeyFactory() {
return this.KEY_FACTORY;
}
}
/** @final */
class DummyKeyManager2 implements KeyManager.KeyManager<DummyPrimitive2> {
private readonly KEY_FACTORY: KeyManager.KeyFactory;
constructor(
private readonly keyType: string,
private readonly primitive: DummyPrimitive2 = new DummyPrimitive2Impl(),
private readonly primitiveType = DummyPrimitive2) {
this.KEY_FACTORY = new DummyKeyFactory(keyType);
}
async getPrimitive(
primitiveType: Constructor<DummyKeyManager2>, key: PbKeyData|PbMessage) {
return this.primitive;
}
doesSupport(keyType: string) {
return keyType === this.getKeyType();
}
getKeyType() {
return this.keyType;
}
getPrimitiveType() {
return this.primitiveType;
}
getVersion(): number {
throw new SecurityException('Not implemented, only for testing purposes.');
}
getKeyFactory() {
return this.KEY_FACTORY;
}
}
/** @final */
class DummyKeyManagerForNewKeyTests implements KeyManager.KeyManager<string> {
private readonly KEY_FACTORY: KeyManager.KeyFactory;
constructor(
private readonly keyType: string, opt_newKeyMethodResult?: Uint8Array) {
this.KEY_FACTORY = new DummyKeyFactory(keyType, opt_newKeyMethodResult);
}
async getPrimitive(
primitiveType: Constructor<DummyKeyManagerForNewKeyTests>,
key: PbKeyData|PbMessage): Promise<string> {
throw new SecurityException('Not implemented, function is not needed.');
}
doesSupport(keyType: string) {
return keyType === this.getKeyType();
}
getKeyType() {
return this.keyType;
}
getPrimitiveType(): never {
throw new SecurityException('Not implemented, function is not needed.');
}
getVersion(): never {
throw new SecurityException('Not implemented, function is not needed.');
}
getKeyFactory() {
return this.KEY_FACTORY;
}
}
// PrimitiveWrapper classes for testing purposes
/** @final */
class DummyPrimitiveWrapper1 implements PrimitiveWrapper<DummyPrimitive1> {
constructor(
private readonly primitive: DummyPrimitive1,
private readonly primitiveType: Constructor<DummyPrimitive1>) {}
wrap(primitiveSet: PrimitiveSet.PrimitiveSet<DummyPrimitive1>) {
return this.primitive;
}
getPrimitiveType() {
return this.primitiveType;
}
}
/** @final */
class DummyPrimitiveWrapper2 implements PrimitiveWrapper<DummyPrimitive2> {
constructor(
private readonly primitive: DummyPrimitive2,
private readonly primitiveType: Constructor<DummyPrimitive2>) {}
wrap(primitiveSet: PrimitiveSet.PrimitiveSet<DummyPrimitive2>) {
return this.primitive;
}
getPrimitiveType() {
return this.primitiveType;
}
}