200 lines
4.2 KiB
TypeScript
200 lines
4.2 KiB
TypeScript
import * as pgp from 'openpgp';
|
|
import * as crypto from 'crypto';
|
|
|
|
interface Signable {
|
|
digest(): string;
|
|
}
|
|
|
|
type KeyGetter = () => any;
|
|
|
|
type Signature = {
|
|
engine: string
|
|
algo: string
|
|
data: string
|
|
digest: string
|
|
};
|
|
|
|
interface Signer {
|
|
prepare(Signable): boolean;
|
|
|
|
onsign(Signature): void;
|
|
|
|
onverify(bool): void;
|
|
|
|
sign(digest: string): void;
|
|
|
|
verify(digest: string, signature: Signature): void;
|
|
|
|
fingerprint(): string;
|
|
}
|
|
|
|
|
|
interface Authoritative {
|
|
}
|
|
|
|
interface KeyStore {
|
|
getPrivateKey: KeyGetter;
|
|
getFingerprint: () => string;
|
|
getTrustedKeys: () => Array<any>;
|
|
getTrustedActiveKeys: () => Array<any>;
|
|
getEncryptKeys: () => Array<any>;
|
|
}
|
|
|
|
class PGPKeyStore implements KeyStore {
|
|
|
|
fingerprint: string;
|
|
pk: any;
|
|
|
|
pubk = {
|
|
active: [],
|
|
trusted: [],
|
|
encrypt: [],
|
|
};
|
|
loads = 0x00;
|
|
loadsTarget = 0x0f;
|
|
onload: (k: KeyStore) => void;
|
|
|
|
constructor(passphrase: string, pkArmor: string, pubkActiveArmor: string, pubkTrustedArmor: string, pubkEncryptArmor: string,
|
|
onload = (ks: KeyStore) => {
|
|
}) {
|
|
this._readKey(pkArmor, undefined, 1, passphrase);
|
|
this._readKey(pubkActiveArmor, 'active', 2);
|
|
this._readKey(pubkTrustedArmor, 'trusted', 4);
|
|
this._readKey(pubkEncryptArmor, 'encrypt', 8);
|
|
this.onload = onload;
|
|
}
|
|
|
|
private _readKey(a: string, x: any, n: number, pass?: string): void {
|
|
pgp.key.readArmored(a).then((k) => {
|
|
if (pass !== undefined) {
|
|
this.pk = k.keys[0];
|
|
this.pk.decrypt(pass).then(() => {
|
|
this.fingerprint = this.pk.getFingerprint();
|
|
console.log('private key (sign)', this.fingerprint);
|
|
this._registerLoad(n);
|
|
});
|
|
} else {
|
|
this.pubk[x] = k.keys;
|
|
k.keys.forEach((pubk) => {
|
|
console.log('public key (' + x + ')', pubk.getFingerprint());
|
|
});
|
|
this._registerLoad(n);
|
|
}
|
|
});
|
|
}
|
|
|
|
private _registerLoad(b: number): void {
|
|
this.loads |= b;
|
|
if (this.loads == this.loadsTarget) {
|
|
this.onload(this);
|
|
}
|
|
}
|
|
|
|
public getTrustedKeys(): Array<any> {
|
|
return this.pubk.trusted;
|
|
}
|
|
|
|
public getTrustedActiveKeys(): Array<any> {
|
|
return this.pubk.active;
|
|
}
|
|
|
|
public getEncryptKeys(): Array<any> {
|
|
return this.pubk.encrypt;
|
|
}
|
|
|
|
public getPrivateKey(): any {
|
|
return this.pk;
|
|
}
|
|
|
|
public getFingerprint(): string {
|
|
return this.fingerprint;
|
|
}
|
|
}
|
|
|
|
class PGPSigner implements Signer {
|
|
|
|
engine = 'pgp';
|
|
algo = 'sha256';
|
|
dgst: string;
|
|
signature: Signature;
|
|
keyStore: KeyStore;
|
|
onsign: (Signature) => void;
|
|
onverify: (bool) => void;
|
|
|
|
constructor(keyStore: KeyStore) {
|
|
this.keyStore = keyStore;
|
|
this.onsign = (string) => {
|
|
};
|
|
this.onverify = (boolean) => {
|
|
};
|
|
}
|
|
|
|
public fingerprint(): string {
|
|
return this.keyStore.getFingerprint();
|
|
}
|
|
|
|
public prepare(material: Signable): boolean {
|
|
this.dgst = material.digest();
|
|
return true;
|
|
}
|
|
|
|
public verify(digest: string, signature: Signature): void {
|
|
pgp.signature.readArmored(signature.data).then((s) => {
|
|
const opts = {
|
|
message: pgp.cleartext.fromText(digest),
|
|
publicKeys: this.keyStore.getTrustedKeys(),
|
|
signature: s,
|
|
};
|
|
pgp.verify(opts).then((v) => {
|
|
let i = 0;
|
|
for (i = 0; i < v.signatures.length; i++) {
|
|
const s = v.signatures[i];
|
|
if (s.valid) {
|
|
this.onverify(s);
|
|
return;
|
|
}
|
|
}
|
|
console.error('checked ' + i + ' signature(s) but none valid');
|
|
this.onverify(false);
|
|
});
|
|
}).catch((e) => {
|
|
console.error(e);
|
|
this.onverify(false);
|
|
});
|
|
}
|
|
|
|
public sign(digest: string): void {
|
|
const m = pgp.cleartext.fromText(digest);
|
|
const pk = this.keyStore.getPrivateKey();
|
|
const opts = {
|
|
message: m,
|
|
privateKeys: [pk],
|
|
detached: true,
|
|
};
|
|
pgp.sign(opts).then((s) => {
|
|
this.signature = {
|
|
engine: this.engine,
|
|
algo: this.algo,
|
|
data: s.signature,
|
|
// TODO: fix for browser later
|
|
digest: digest,
|
|
};
|
|
this.onsign(this.signature);
|
|
}).catch((e) => {
|
|
console.error(e);
|
|
this.onsign(undefined);
|
|
});
|
|
}
|
|
}
|
|
|
|
export {
|
|
Signature,
|
|
Authoritative,
|
|
Signer,
|
|
KeyGetter,
|
|
Signable,
|
|
KeyStore,
|
|
PGPSigner,
|
|
PGPKeyStore,
|
|
};
|