test/specs/generic/consensus/base/primitive/KeyPair.spec.js
describe('KeyPair', () => {
const catcher = {catcher: () => 0};
it('can serialize and unserialize', () => {
const pair1 = KeyPair.generate();
const pair2 = KeyPair.unserialize(pair1.serialize());
expect(pair1.privateKey).toEqual(pair2.privateKey);
expect(pair1.publicKey).toEqual(pair2.publicKey);
expect(pair1.isLocked).toEqual(pair2.isLocked);
});
it('can encrypt and decrypt after locked serialization', (done) => {
(async () => {
const key = new Uint8Array([1, 2, 3, 4]);
const pair1 = KeyPair.generate();
const privateKeyBak = PrivateKey.unserialize(pair1.privateKey.serialize());
await pair1.lock(key);
expect(pair1.isLocked).toBeTruthy();
const pair2 = KeyPair.unserialize(pair1.serialize());
expect(pair2.isLocked).toBeTruthy();
await pair2.unlock(key);
expect(pair2.isLocked).toBeFalsy();
expect(privateKeyBak).toEqual(pair2.privateKey);
})().then(done, done.fail);
});
it('can lock, unlock and relock', (done) => {
(async () => {
const key = new Uint8Array([1, 2, 3, 4]);
const pair = KeyPair.generate();
const privateKeyBak = PrivateKey.unserialize(pair.privateKey.serialize());
await pair.lock(key);
expect(pair.isLocked).toBeTruthy();
expect(() => pair.privateKey).toThrow();
expect(pair._unlockedPrivateKey).toBeFalsy();
expect(pair._internalPrivateKey.serialize()).not.toEqual(privateKeyBak);
await pair.unlock(key);
expect(pair.isLocked).toBeFalsy();
const privateKeyTmp = pair.privateKey;
expect(privateKeyTmp).toEqual(privateKeyBak);
pair.relock();
expect(pair.isLocked).toBeTruthy();
expect(() => pair.privateKey).toThrow();
expect(pair._unlockedPrivateKey).toBeFalsy();
expect(privateKeyTmp).not.toEqual(privateKeyBak);
expect(pair._internalPrivateKey.serialize()).not.toEqual(privateKeyBak);
})().then(done, done.fail);
});
it('errors when trying to unlock with wrong key', (done) => {
spyOn(catcher, 'catcher');
(async () => {
const key = new Uint8Array([1, 2, 3, 4]);
const key2 = new Uint8Array([1, 2, 3, 3]);
const pair1 = KeyPair.generate();
await pair1.lock(key);
await pair1.unlock(key2).catch(catcher.catcher);
expect(catcher.catcher).toHaveBeenCalled();
expect(pair1.isLocked).toBeTruthy();
await pair1.unlock(key);
expect(pair1.isLocked).toBeFalsy();
})().then(done, done.fail);
});
it('can lock under different keys', (done) => {
(async () => {
const key1 = new Uint8Array([1, 2, 3, 4]);
const key2 = new Uint8Array([4, 3, 2, 1]);
const pair = KeyPair.generate();
const privateKeyBak = PrivateKey.unserialize(pair.privateKey.serialize());
await pair.lock(key1);
expect(pair.isLocked).toBeTruthy();
expect(() => pair.privateKey).toThrow();
expect(pair._unlockedPrivateKey).toBeFalsy();
expect(pair._internalPrivateKey).not.toEqual(privateKeyBak);
await pair.unlock(key1);
expect(pair.isLocked).toBeFalsy();
let privateKeyTmp = pair.privateKey;
expect(privateKeyTmp).toEqual(privateKeyBak);
await pair.lock(key2);
expect(pair.isLocked).toBeTruthy();
expect(() => pair.privateKey).toThrow();
expect(pair._unlockedPrivateKey).toBeFalsy();
expect(privateKeyTmp).not.toEqual(privateKeyBak);
expect(pair._internalPrivateKey).not.toEqual(privateKeyBak);
await pair.unlock(key2);
expect(pair.isLocked).toBeFalsy();
privateKeyTmp = pair.privateKey;
expect(privateKeyTmp).toEqual(privateKeyBak);
})().then(done, done.fail);
});
it('can create keys of proposed size', () => {
const keyPair = KeyPair.generate();
expect(keyPair.publicKey.serialize().byteLength).toEqual(PublicKey.SIZE);
expect(keyPair.privateKey.serialize().byteLength).toEqual(PrivateKey.SIZE);
});
it('can derive a functional key pair from private key', () => {
const keyPair = KeyPair.generate();
const data = new Uint8Array([1, 2, 3]);
const keyPair2 = KeyPair.derive(keyPair.privateKey);
const sign = Signature.create(keyPair.privateKey, keyPair.publicKey, data);
const verify = sign.verify(keyPair.publicKey, data);
expect(verify).toBe(true, 'can verify original with original key');
const verify2 = sign.verify(keyPair2.publicKey, data);
expect(verify2).toBe(true, 'can verify original with derived key');
const sign2 = Signature.create(keyPair2.privateKey, keyPair2.publicKey, data);
const verify3 = sign2.verify(keyPair.publicKey, data);
expect(verify3).toBe(true, 'can verify derived with original key');
const verify4 = sign2.verify(keyPair2.publicKey, data);
expect(verify4).toBe(true, 'can verify derived with derived key');
});
it('can export and import an encrypted key pair', (done) => {
(async () => {
const keyPair = KeyPair.generate();
const encKey = BufferUtils.fromAscii('secret');
const exported = await keyPair.exportEncrypted(encKey);
const imported = await KeyPair.fromEncrypted(exported, encKey);
expect(imported.publicKey.equals(keyPair.publicKey));
expect(imported.privateKey.equals(keyPair.privateKey));
})().then(done, done.fail);
});
});