vpn.email.client
Version:
Vpn.Email client IMAP core
213 lines (198 loc) • 7.92 kB
TypeScript
declare module "openpgp" {
interface keys {
decrypt: ( pass: string ) => void
}
interface keyIds {
}
interface verifyOption {
message:string,
publicKeys: key[]
}
interface verifyResult {
data: string;
signatures: any;
}
enum EArmor {
multipart_section,
multipart_last,
signed,
message,
public_key,
private_key
}
interface ESymmetric {
plaintext
idea
tripledes
cast5
blowfish
aes128
aes192
aes256
twofish
}
interface hash {
}
interface ISignature {
cert_generic: string;
}
interface IEnums {
armor: EArmor;
signature:ISignature;
keyFlags:IKeyFlags;
symmetric: ESymmetric;
hash:any;
compression:any
}
interface key {
/**
* Reads an OpenPGP armored text and returns one or multiple key objects
* @param {String} armoredText text to be parsed
* @return {{keys: Array<module:key~Key>, err: (Array<Error>|null)}} result object with key and error arrays
* @static
*/
readArmored: (armoredText: string|string[]) => {
keys: keys[]
decrypt: ( pass: string ) => void;
};
Key:any
}
interface messages {
/**
* Returns the key IDs of the keys to which the session key is encrypted
* @return {Array<module:type/keyid>} array of keyid objects
*/
getEncryptionKeyIds: () => keyIds[];
}
interface message {
/**
* reads an OpenPGP armored message and returns a message object
* @param {String} armoredText text to be parsed
* @return {module:message~Message} new message object
* @static
*/
readArmored: (armoredText: string) => messages;
}
interface DecryptionOption {
message: messages;
privateKey?: keys;
publicKeys?: keys | keys[];
sessionKey?: Object;
password?: string;
format?: string; // as 'utf8' or 'binary'
}
interface EncryptionOption {
data: string | Uint8Array;
publicKeys: keys | keys[]
}
interface decryptResult {
then: (plaintext) => decryptResult;
catch: (callBack: (err: Error ) => void) => void;
}
interface IKeyFlags {
certify_keys:any;
sign_data:any;
}
interface ISignature {
new ():ISignature;
signatureType: string;
hashAlgorithm: number;
publicKeyAlgorithm: number;
keyFlags: any[];
preferredSymmetricAlgorithms: string[]
preferredHashAlgorithms:any[]
preferredCompressionAlgorithms: any[];
sign:any
}
interface IList {
new () : IList;
push: (any) => void;
read: (msg: string) => PackageDetail;
}
interface PackageDetail {
}
interface IPacket {
Signature: ISignature;
List:IList
}
interface generateKeyOption {
userIds: {
name: string;
email: string;
};
passphrase?: string;
numBits?: number; // should be 2048 or 4096
unlocked?: boolean; // If the returned secret part of the generated key is unlocked
}
interface IKeyringPublicKeys {
importKey: (key: string) => void;
getForId: (id: string) =>keys;
}
interface IKeyring {
new (): IKeyring;
clear(): void;
store(): void;
publicKeys: IKeyringPublicKeys;
getKeysForId: (id: string) => keys;
}
interface IConfig {
aead_protect: boolean;
}
interface Iopenpgp {
key: key;
message: message;
packet:IPacket;
enums: IEnums;
Keyring: IKeyring;
config:IConfig;
/**
* Decrypts a message with the user's private key, a session key or a password. Either a private key,
* a session key or a password must be specified.
* @param {Message} message the message object with the encrypted data
* @param {Key} privateKey (optional) private key with decrypted secret key data or session key
* @param {Key|Array<Key>} publicKeys (optional) array of public keys or single key, to verify signatures
* @param {Object} sessionKey (optional) session key in the form: { data:Uint8Array, algorithm:String }
* @param {String} password (optional) single password to decrypt the message
* @param {String} format (optional) return data format either as 'utf8' or 'binary'
* @return {Promise<Object>} decrypted and verified message in the form:
* { data:Uint8Array|String, filename:String, signatures:[{ keyid:String, valid:Boolean }] }
* @static
*/
decrypt: (decryptionOption: DecryptionOption) => decryptResult;
/**
* Encrypts message text/data with public keys, passwords or both at once. At least either public keys or passwords
* must be specified. If private keys are specified, those will be used to sign the message.
* @param {String|Uint8Array} data text/data to be encrypted as JavaScript binary string or Uint8Array
* @param {Key|Array<Key>} publicKeys (optional) array of keys or single key, used to encrypt the message
* @param {Key|Array<Key>} privateKeys (optional) private keys for signing. If omitted message will not be signed
* @param {String|Array<String>} passwords (optional) array of passwords or a single password to encrypt the message
* @param {String} filename (optional) a filename for the literal data packet
* @param {Boolean} armor (optional) if the return value should be ascii armored or the message object
* @return {Promise<String|Message>} encrypted ASCII armored message, or the full Message object if 'armor' is false
* @static
*/
encrypt: (encryptionOption: EncryptionOption) => decryptResult;
/**
* Generates a new OpenPGP key pair. Currently only supports RSA keys. Primary and subkey will be of same type.
* @param {Array<Object>} userIds array of user IDs e.g. [{ name:'Phil Zimmermann', email:'phil@openpgp.org' }]
* @param {String} passphrase (optional) The passphrase used to encrypt the resulting private key
* @param {Number} numBits (optional) number of bits for the key creation. (should be 2048 or 4096)
* @param {Boolean} unlocked (optional) If the returned secret part of the generated key is unlocked
* @return {Promise<Object>} The generated key object in the form:
* { key:Key, privateKeyArmored:String, publicKeyArmored:String }
* @static
*/
generateKey: (generateKeyOption: generateKeyOption) => decryptResult;
/**
* Verifies signatures of cleartext signed message
* @param {Key|Array<Key>} publicKeys array of publicKeys or single key, to verify signatures
* @param {CleartextMessage} message cleartext message object with signatures
* @return {Promise<Object>} cleartext with status of verified signatures in the form of:
* { data:String, signatures: [{ keyid:String, valid:Boolean }] }
* @static
*/
verify: (verifyOption) => verifyResult;
}
let ex: Iopenpgp;
export = ex;
}