From 1718ae01babc0515067844b8255abc7985c4d7de Mon Sep 17 00:00:00 2001 From: Spencer Ofwiti Date: Tue, 16 Feb 2021 16:18:41 +0300 Subject: [PATCH] Refactor MutableKeyStore interface. --- README.md | 8 +- src/app/_helpers/pgp-key-store.ts | 133 +++++++++++++----------------- src/app/_services/auth.service.ts | 10 ++- 3 files changed, 72 insertions(+), 79 deletions(-) diff --git a/README.md b/README.md index fcdf170..89bcdcb 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,6 @@ -# CicStaffClient +# CICADA + +Angular web client for managing users and transactions in the CIC network. This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.2.0. @@ -10,6 +12,10 @@ Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app w Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`. +## Lazy-loading feature modules + +Run `ng generate module module-name --route module-name --module app.module` to generate a new module on route `/module-name` in the app module. + ## Build Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build. diff --git a/src/app/_helpers/pgp-key-store.ts b/src/app/_helpers/pgp-key-store.ts index 4f74275..14d2534 100644 --- a/src/app/_helpers/pgp-key-store.ts +++ b/src/app/_helpers/pgp-key-store.ts @@ -2,62 +2,44 @@ const openpgp = require('openpgp'); const keyring = new openpgp.Keyring(); interface MutableKeyStore{ - getFingerPrint: () => string; + loadKeyring: () => Promise; + importKeyPair: (publicKey: any, privateKey: any) => Promise; + importPublicKey: (publicKey: any) => Promise; + importPrivateKey: (privateKey: any) => Promise; + getPublicKeys: () => Array; getTrustedKeys: () => Array; - getTrustedActiveKeys: () => Array; - addPublicKey: (publicKey) => void; - revokeKey: (publicKey) => void; + getPrivateKeys: () => Array; + getPrivateKey: () => any; + isValidKey: (key: any) => boolean; + getFingerPrint: () => string; + getKeyId: (key: any) => string; + getKeysForId: (keyId: string) => Array; + getPublicKeyForId: (keyId: string) => any; + getPrivateKeyForId: (keyId: string) => any; + getPublicKeyForSubkeyId: (subkeyId: string) => any; + getPublicKeysForAddress: (address: string) => Array; + removeKeysForId: (keyId: string) => Array; + removePublicKeysForId: (keyId: string) => any; + clearKeysInKeyring: () => void; + // revokeKey: (publicKey) => void; } class MutablePgpKeyStore implements MutableKeyStore{ fingerprint: string; - pubk = { - active: [], - trusted: [], - encrypt: [], - }; - getPublicKey(publicKey: any): any { - return openpgp.readArmoredKey(publicKey); - } - - async loadPublicKeys(armoredKeys: any): Promise { - return await openpgp.readArmoredKey(armoredKeys); - } - - addPublicKey(publicKey): void { - this.pubk.active.push(publicKey); - } - - revokeKey(publicKey): void { - this.pubk.active.splice(this.pubk.active.indexOf(publicKey), 1); - this.pubk.trusted.splice(this.pubk.trusted.indexOf(publicKey), 1); - } - - getTrustedKeys(): Array { - return this.pubk.trusted; - } - - getFingerPrint(): string { - return this.fingerprint; - } - - getTrustedActiveKeys(): Array { - return this.pubk.active; - } + // revokeKey(publicKey): void { + // this.pubk.active.splice(this.pubk.active.indexOf(publicKey), 1); + // this.pubk.trusted.splice(this.pubk.trusted.indexOf(publicKey), 1); + // } async loadKeyring(): Promise { await keyring.load(); // clear any keys already in the keychain - keyring.clear(); + // keyring.clear(); await keyring.store(); } - async importKeyPair(publicKey, privateKey): Promise { - await keyring.load(); - // clear any keys already in the keychain - keyring.clear(); - await keyring.store(); + async importKeyPair(publicKey: any, privateKey: any): Promise { await keyring.publicKeys.importKey(publicKey); await keyring.privateKeys.importKey(privateKey); } @@ -66,67 +48,70 @@ class MutablePgpKeyStore implements MutableKeyStore{ await keyring.publicKeys.importKey(publicKey); } - getPublicKeys(): any { + async importPrivateKey(privateKey: any): Promise { + await keyring.privateKeys.importKey(privateKey); + this.fingerprint = keyring.privateKeys.keys[0].keyPacket.fingerprint; + } + + getPublicKeys(): Array { return keyring.publicKeys.keys; } - getKeysForId(keyId): any { - return keyring.getKeysForId(keyId); + getTrustedKeys(): Array { + return keyring.publicKeys.keys; } - getKeysForFingerprint(keyFingerprint): any { - return keyring.getKeysForId(keyFingerprint); + getPrivateKeys(): Array { + return keyring.privateKeys.keys; } - getPublicKeysForSubkeyFingerprint(subkeyFingerprint): any { - return keyring.publicKeys.getForId(subkeyFingerprint, true); + getPrivateKey(): any { + return keyring.privateKeys.keys[0]; } - getPublicKeysForId(keyId): any { - return keyring.publicKeys.getForId(keyId); + isValidKey(key): boolean { + return typeof key === openpgp.Key; } - getPrivateKeysForId(keyId): any { - return keyring.privateKeys.getForId(keyId); + getFingerPrint(): string { + return this.fingerprint; } - getKeyId(key): any { + getKeyId(key: any): string { return key.getKeyId().toHex(); } - isValidKey(key): any { - return typeof key === openpgp.key.Key; + getKeysForId(keyId: string): Array { + return keyring.getKeysForId(keyId); } - getPublicKeysForAddress(address): any { + getPublicKeyForId(keyId): any { + return keyring.publicKeys.getForId(keyId); + } + + getPrivateKeyForId(keyId): any { + return keyring.privateKeys.getForId(keyId); + } + + getPublicKeyForSubkeyId(subkeyId): any { + return keyring.publicKeys.getForId(subkeyId, true); + } + + getPublicKeysForAddress(address): Array { return keyring.publicKeys.getForAddress(address); } - removeKeysForId(keyId): void { - keyring.removeKeysForId(keyId); + removeKeysForId(keyId): Array { + return keyring.removeKeysForId(keyId); } removePublicKeysForId(keyId): any { return keyring.publicKeys.removeForId(keyId); } - async storeKeysInLocalstorage(): Promise { - await keyring.load(); - keyring.clear(); - await keyring.store(); - } - clearKeysInKeyring(): void { keyring.clear(); } - - createCustomizedLocalstorage(customPrefix): any { - return new openpgp.Keyring.localstore(customPrefix); - } - - async addKeyToLocalstorage(localstore, key): Promise { - await localstore.storePublic([key]); - } } export { diff --git a/src/app/_services/auth.service.ts b/src/app/_services/auth.service.ts index 57d45a3..8373611 100644 --- a/src/app/_services/auth.service.ts +++ b/src/app/_services/auth.service.ts @@ -1,10 +1,9 @@ import { Injectable } from '@angular/core'; -import {MutablePgpKeyStore, UnsafeKeyStore} from '@app/_helpers'; +import {MutableKeyStore, MutablePgpKeyStore, UnsafeKeyStore} from '@app/_helpers'; import { hobaParseChallengeHeader } from '@src/assets/js/hoba.js'; import { signChallenge } from '@src/assets/js/hoba-pgp.js'; import {environment} from '@src/environments/environment'; import {HttpClient} from '@angular/common/http'; -import {first} from 'rxjs/operators'; const openpgp = require('openpgp'); const origin = 'http://localhost:4444'; @@ -17,7 +16,7 @@ export class AuthService { sessionToken: any; sessionLoginCount = 0; privateKey: any; - mutableKeyStore: MutablePgpKeyStore = new MutablePgpKeyStore(); + mutableKeyStore: MutableKeyStore = new MutablePgpKeyStore(); constructor( private http: HttpClient @@ -126,6 +125,7 @@ export class AuthService { try { await pgpKeyStore.set(privateKeyArmored); localStorage.setItem(btoa('CICADA_PRIVATE_KEY'), privateKeyArmored); + await this.mutableKeyStore.importPrivateKey(privateKeyArmored); } catch (e) { console.error('failed setting key', e); return false; @@ -144,9 +144,11 @@ export class AuthService { const armoredPublicKeys = res; await this.mutableKeyStore.loadKeyring(); await this.mutableKeyStore.importPublicKey(armoredPublicKeys); - console.log(this.mutableKeyStore.getPublicKeys()); }, error => { console.error('There was an error!', error); }); + if (this.privateKey !== undefined) { + await this.mutableKeyStore.importPrivateKey(this.privateKey); + } } }