suzanne.soy/fork-openpgpjs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix documentation of top-level function parameters

Browse Source
This commit is contained in:
Daniel Huigens 2021-02-27 23:37:41 +01:00
parent a50cb9c6b7
commit e2eadd09e4
17 changed files with 214 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/cleartext.js
View File

@ -57,11 +57,11 @@ export class CleartextMessage {
/**
* Sign the cleartext message
* @param {Array<Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature
* @param {Signature} [signature] - any existing detached signature
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) The creation time of the signature that should be created
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - The creation time of the signature that should be created
* @param {Array} [userIds] - user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<CleartextMessage>} new cleartext message with signed content
* @async
*/
@ -72,11 +72,11 @@ export class CleartextMessage {
/**
* Sign the cleartext message
* @param {Array<Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature
* @param {Signature} [signature] - any existing detached signature
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) The creation time of the signature that should be created
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - The creation time of the signature that should be created
* @param {Array} [userIds] - user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Signature>} new detached signature of message content
* @async
*/
@ -155,8 +155,9 @@ export class CleartextMessage {
/**
* Reads an OpenPGP cleartext signed message and returns a CleartextMessage object
* @param {String | ReadableStream<String>} cleartextMessage text to be parsed
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {String | ReadableStream<String>} options.cleartextMessage - text to be parsed
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {CleartextMessage} new cleartext message object
* @async
* @static

34
src/encoding/armor.js
View File

@ -23,7 +23,7 @@ import defaultConfig from '../config';
/**
* Finds out which Ascii Armoring type is used. Throws error if unknown type.
* @param {String} text [String] ascii armored text
* @param {String} text - ascii armored text
* @returns {Integer} 0 = MESSAGE PART n of m
* 1 = MESSAGE PART n
* 2 = SIGNED MESSAGE
@ -88,7 +88,7 @@ function getType(text) {
* packet block.
* @author Alex
* @version 2011-12-16
* @param {String} customComment (optional) additional comment to add to the armored string
* @param {String} [customComment] - additional comment to add to the armored string
* @returns {String} The header information
* @private
*/
@ -158,7 +158,7 @@ const isLittleEndian = (function() {
/**
* Internal function to calculate a CRC-24 checksum over a given string (data)
* @param {String | ReadableStream<String>} data Data to create a CRC-24 checksum for
* @param {String | ReadableStream<String>} input Data to create a CRC-24 checksum for
* @returns {Uint8Array | ReadableStream<Uint8Array>} The CRC-24 checksum
* @private
*/
@ -220,9 +220,9 @@ function splitChecksum(text) {
}
/**
* DeArmor an OpenPGP armored message; verify the checksum and return
* Dearmor an OpenPGP armored message; verify the checksum and return
* the encoded bytes
* @param {String} text OpenPGP armored message
* @param {String} input OpenPGP armored message
* @returns {Promise<Object>} An object with attribute "text" containing the message text,
* an attribute "data" containing a stream of bytes and "type" for the ASCII armor type
* @async
@ -346,38 +346,38 @@ export function unarmor(input, config = defaultConfig) {
/**
* Armor an OpenPGP binary packet block
* @param {Integer} messagetype type of the message
* @param body
* @param {Integer} partindex
* @param {Integer} parttotal
* @param {String} customComment (optional) additional comment to add to the armored string
* @param {module:enums.armor} messageType type of the message
* @param {Uint8Array | ReadableStream<Uint8Array>} body the message body to armor
* @param {Integer} [partIndex]
* @param {Integer} [partTotal]
* @param {String} [customComment] - additional comment to add to the armored string
* @returns {String | ReadableStream<String>} Armored text
* @static
*/
export function armor(messagetype, body, partindex, parttotal, customComment, config = defaultConfig) {
export function armor(messageType, body, partIndex, partTotal, customComment, config = defaultConfig) {
let text;
let hash;
if (messagetype === enums.armor.signed) {
if (messageType === enums.armor.signed) {
text = body.text;
hash = body.hash;
body = body.data;
}
const bodyClone = stream.passiveClone(body);
const result = [];
switch (messagetype) {
switch (messageType) {
case enums.armor.multipartSection:
result.push("-----BEGIN PGP MESSAGE, PART " + partindex + "/" + parttotal + "-----\n");
result.push("-----BEGIN PGP MESSAGE, PART " + partIndex + "/" + partTotal + "-----\n");
result.push(addheader(customComment, config));
result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone));
result.push("-----END PGP MESSAGE, PART " + partindex + "/" + parttotal + "-----\n");
result.push("-----END PGP MESSAGE, PART " + partIndex + "/" + partTotal + "-----\n");
break;
case enums.armor.multipartLast:
result.push("-----BEGIN PGP MESSAGE, PART " + partindex + "-----\n");
result.push("-----BEGIN PGP MESSAGE, PART " + partIndex + "-----\n");
result.push(addheader(customComment, config));
result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone));
result.push("-----END PGP MESSAGE, PART " + partindex + "-----\n");
result.push("-----END PGP MESSAGE, PART " + partIndex + "-----\n");
break;
case enums.armor.signed:
result.push("\n-----BEGIN PGP SIGNED MESSAGE-----\n");

14
src/key/factory.js
View File

@ -244,9 +244,10 @@ async function wrapKeyObject(secretKeyPacket, secretSubkeyPackets, options, conf
/**
* Reads an (optionally armored) OpenPGP key and returns a key object
* @param {String} armoredKey armored key to be parsed
* @param {Uint8Array} binaryKey binary key to be parsed
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {String | ReadableStream<String>} [options.armoredKey] - armored key to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} [options.binaryKey] - binary key to be parsed
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Key>} key object
* @async
* @static
@ -273,9 +274,10 @@ export async function readKey({ armoredKey, binaryKey, config }) {
/**
* Reads an (optionally armored) OpenPGP key block and returns a list of key objects
* @param {String | ReadableStream<String>} armoredKeys armored keys to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binaryKeys binary keys to be parsed
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {String | ReadableStream<String>} [options.armoredKeys] - armored keys to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} [options.binaryKeys] - binary keys to be parsed
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Array<Key>>} key objects
* @async
* @static

10
src/key/helper.js
View File

@ -203,11 +203,11 @@ export async function getPreferredAlgo(type, keys, date = new Date(), userIds =
* @param {Object} dataToSign Contains packets to be signed
* @param {SecretKeyPacket|
* SecretSubkeyPacket} signingKeyPacket secret key packet for signing
* @param {Object} signatureProperties (optional) properties to write on the signature packet before signing
* @param {Date} date (optional) override the creationtime of the signature
* @param {Object} userId (optional) user ID
* @param {Object} detached (optional) whether to create a detached signature packet
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} [signatureProperties] - properties to write on the signature packet before signing
* @param {Date} [date] - override the creationtime of the signature
* @param {Object} [userId] - user ID
* @param {Object} [detached] - whether to create a detached signature packet
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} config full configuration
* @returns {Promise<SignaturePacket>} signature packet
*/

2
src/key/key.js
View File

@ -881,7 +881,7 @@ class Key {
* @param {Number} options.keyExpirationTime (optional) Number of seconds from the key creation time after which the key expires
* @param {Date} options.date (optional) Override the creation date of the key and the key signatures
* @param {Boolean} options.sign (optional) Indicates whether the subkey should sign rather than encrypt. Defaults to false
* @param {Object} options.config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options.config (optional) custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Key>}
* @async
*/

4
src/keyring/keyring.js
View File

@ -71,7 +71,7 @@ class KeyArray {
/**
* Imports a key from an ascii armored message
* @param {String} armored message to read the keys/key from
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @async
*/
async importKey(armored, config = defaultConfig) {
@ -118,7 +118,7 @@ class Keyring {
/**
* Initialization routine for the keyring.
* @param {keyring/localstore} [storeHandler] class implementing loadPublic(), loadPrivate(), storePublic(), and storePrivate() methods
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(storeHandler, config = defaultConfig) {
this.storeHandler = storeHandler || new LocalStore(undefined, config);

8
src/keyring/localstore.js
View File

@ -32,7 +32,7 @@ import defaultConfig from '../config';
class LocalStore {
/**
* @param {String} prefix prefix for itemnames in localstore
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(prefix, config = defaultConfig) {
prefix = prefix || 'openpgp-';
@ -56,7 +56,7 @@ class LocalStore {
/**
* Load the private keys from HTML5 local storage.
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Array<Key>} array of keys retrieved from localstore
* @async
*/
@ -68,7 +68,7 @@ class LocalStore {
* Saves the current state of the public keys to HTML5 local storage.
* The key array gets stringified using JSON
* @param {Array<Key>} keys array of keys to save in localstore
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @async
*/
async storePublic(keys, config = defaultConfig) {
@ -79,7 +79,7 @@ class LocalStore {
* Saves the current state of the private keys to HTML5 local storage.
* The key array gets stringified using JSON
* @param {Array<Key>} keys array of keys to save in localstore
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @async
*/
async storePrivate(keys, config = defaultConfig) {

97
src/message.js
View File

@ -88,11 +88,11 @@ export class Message {
/**
* Decrypt the message. Either a private key, a session key, or a password must be specified.
* @param {Array<Key>} privateKeys (optional) private keys with decrypted secret data
* @param {Array<String>} passwords (optional) passwords used to decrypt
* @param {Array<Object>} sessionKeys (optional) session keys in the form: { data:Uint8Array, algorithm:String, [aeadAlgorithm:String] }
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Array<Key>} [privateKeys] - private keys with decrypted secret data
* @param {Array<String>} [passwords] - passwords used to decrypt
* @param {Array<Object>} [sessionKeys] - session keys in the form: { data:Uint8Array, algorithm:String, [aeadAlgorithm:String] }
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Message>} new message with decrypted content
* @async
*/
@ -140,9 +140,9 @@ export class Message {
/**
* Decrypt encrypted session keys either with private keys or passwords.
* @param {Array<Key>} privateKeys (optional) private keys with decrypted secret data
* @param {Array<String>} passwords (optional) passwords used to decrypt
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Array<Key>} [privateKeys] - private keys with decrypted secret data
* @param {Array<String>} [passwords] - passwords used to decrypt
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Array<{ data: Uint8Array,
algorithm: String }>>} array of object with potential sessionKey, algorithm pairs
* @async
@ -275,10 +275,10 @@ export class Message {
/**
* Generate a new session key object, taking the algorithm preferences of the passed public keys into account, if any.
* @param {Array<Key>} keys (optional) public key(s) to select algorithm preferences for
* @param {Date} date (optional) date to select algorithm preferences at
* @param {Array<Object>} userIds (optional) user IDs to select algorithm preferences for
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Array<Key>} [keys] - public key(s) to select algorithm preferences for
* @param {Date} [date] - date to select algorithm preferences at
* @param {Array<Object>} [userIds] - user IDs to select algorithm preferences for
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<{ data: Uint8Array, algorithm: String }>} object with session key data and algorithm
* @async
*/
@ -293,15 +293,15 @@ export class Message {
/**
* Encrypt the message either with public keys, passwords, or both at once.
* @param {Array<Key>} keys (optional) public key(s) for message encryption
* @param {Array<String>} passwords (optional) password(s) for message encryption
* @param {Object} sessionKey (optional) session key in the form: { data:Uint8Array, algorithm:String, [aeadAlgorithm:String] }
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} encryptionKeyIds (optional) array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} date (optional) override the creation date of the literal package
* @param {Array<Object>} userIds (optional) user IDs to encrypt for, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Array<Key>} [keys] - public key(s) for message encryption
* @param {Array<String>} [passwords] - password(s) for message encryption
* @param {Object} [sessionKey] - session key in the form: { data:Uint8Array, algorithm:String, [aeadAlgorithm:String] }
* @param {Boolean} [wildcard] - use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} [encryptionKeyIds] - array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} [date] - override the creation date of the literal package
* @param {Array<Object>} [userIds] - user IDs to encrypt for, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Message>} new message with encrypted content
* @async
*/
@ -344,14 +344,14 @@ export class Message {
* Encrypt a session key either with public keys, passwords, or both at once.
* @param {Uint8Array} sessionKey session key for encryption
* @param {String} algorithm session key algorithm
* @param {String} aeadAlgorithm (optional) aead algorithm, e.g. 'eax' or 'ocb'
* @param {Array<Key>} publicKeys (optional) public key(s) for message encryption
* @param {Array<String>} passwords (optional) for message encryption
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} encryptionKeyIds (optional) array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} date (optional) override the date
* @param {Array} userIds (optional) user IDs to encrypt for, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {String} [aeadAlgorithm] - aead algorithm, e.g. 'eax' or 'ocb'
* @param {Array<Key>} [publicKeys] - public key(s) for message encryption
* @param {Array<String>} [passwords] - for message encryption
* @param {Boolean} [wildcard] - use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} [encryptionKeyIds] - array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} [date] - override the date
* @param {Array} [userIds] - user IDs to encrypt for, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Message>} new message with encrypted content
* @async
*/
@ -414,12 +414,12 @@ export class Message {
/**
* Sign the message (the literal data packet of the message)
* @param {Array<Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature to add to the message
* @param {Signature} [signature] - any existing detached signature to add to the message
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) override the creation time of the signature
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - override the creation time of the signature
* @param {Array} [userIds] - user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Message>} new message with signed content
* @async
*/
@ -500,12 +500,12 @@ export class Message {
/**
* Create a detached signature for the message (the literal data packet of the message)
* @param {Array<Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature
* @param {Signature} [signature] - any existing detached signature
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) override the creation time of the signature
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - override the creation time of the signature
* @param {Array} [userIds] - user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Signature>} new detached signature of message content
* @async
*/
@ -688,13 +688,13 @@ export class Message {
* Create signature packets for the message
* @param {LiteralDataPacket} literalDataPacket the literal data packet to sign
* @param {Array<Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature to append
* @param {Signature} [signature] - any existing detached signature to append
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) override the creationtime of the signature
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} detached (optional) whether to create detached signature packets
* @param {Boolean} streaming (optional) whether to process data as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - override the creationtime of the signature
* @param {Array} [userIds] - user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} [detached] - whether to create detached signature packets
* @param {Boolean} [streaming] - whether to process data as a stream
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<PacketList>} list of signature packets
* @async
* @private
@ -811,9 +811,10 @@ export async function createVerificationObjects(signatureList, literalDataList,
/**
* Reads an (optionally armored) OpenPGP message and returns a Message object
* @param {String | ReadableStream<String>} armoredMessage armored message to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binaryMessage binary to be parsed
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {String | ReadableStream<String>} [options.armoredMessage] - armored message to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} [options.binaryMessage] - binary to be parsed
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Message>} new message object
* @async
* @static

192
src/openpgp.js
View File

@ -39,18 +39,19 @@ if (globalThis.ReadableStream) {
/**
* Generates a new OpenPGP key pair. Supports RSA and ECC keys. By default, primary and subkeys will be of same type.
* @param {ecc|rsa} type (optional) The primary key algorithm type: ECC (default) or RSA
* @param {Object|Array<Object>} userIds User IDs as objects: { name:'Jo Doe', email:'info@jo.com' }
* @param {String} passphrase (optional) The passphrase used to encrypt the resulting private key
* @param {Number} rsaBits (optional) Number of bits for RSA keys, defaults to 4096
* @param {String} curve (optional) Elliptic curve for ECC keys:
* @param {Object} options
* @param {'ecc'|'rsa'} [options.type='ecc'] - The primary key algorithm type: ECC (default) or RSA
* @param {Object|Array<Object>} options.userIds - User IDs as objects: `{ name:'Jo Doe', email:'info@jo.com' }`
* @param {String} [options.passphrase] - The passphrase used to encrypt the resulting private key
* @param {Number} [options.rsaBits=4096] - Number of bits for RSA keys
* @param {String} [options.curve='curve25519'] - Elliptic curve for ECC keys:
* curve25519 (default), p256, p384, p521, secp256k1,
* brainpoolP256r1, brainpoolP384r1, or brainpoolP512r1
* @param {Date} date (optional) Override the creation date of the key and the key signatures
* @param {Number} keyExpirationTime (optional) Number of seconds from the key creation time after which the key expires
* @param {Array<Object>} subkeys (optional) Options for each subkey, default to main key options. e.g. [{sign: true, passphrase: '123'}]
* @param {Date} [options.date=current date] - Override the creation date of the key and the key signatures
* @param {Number} [options.keyExpirationTime=0 (never expires)] - Number of seconds from the key creation time after which the key expires
* @param {Array<Object>} [options.subkeys=a single encryption subkey] - Options for each subkey, default to main key options. e.g. [{sign: true, passphrase: '123'}]
* sign parameter defaults to false, and indicates whether the subkey should sign rather than encrypt
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object>} The generated key object in the form:
* { key:Key, privateKeyArmored:String, publicKeyArmored:String, revocationCertificate:String }
* @async
@ -81,11 +82,12 @@ export function generateKey({ userIds = [], passphrase = "", type = "ecc", rsaBi
/**
* Reformats signature packets for a key and rewraps key object.
* @param {Key} privateKey Private key to reformat
* @param {Object|Array<Object>} userIds User IDs as objects: { name:'Jo Doe', email:'info@jo.com' }
* @param {String} passphrase (optional) The passphrase used to encrypt the resulting private key
* @param {Number} keyExpirationTime (optional) Number of seconds from the key creation time after which the key expires
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key} options.privateKey - Private key to reformat
* @param {Object|Array<Object>} options.userIds - User IDs as objects: `{ name:'Jo Doe', email:'info@jo.com' }`
* @param {String} [options.passphrase="" (not protected)] - The passphrase used to encrypt the resulting private key
* @param {Number} [options.keyExpirationTime=0 (never expires)] - Number of seconds from the key creation time after which the key expires
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object>} The generated key object in the form:
* { key:Key, privateKeyArmored:String, publicKeyArmored:String, revocationCertificate:String }
* @async
@ -114,15 +116,16 @@ export function reformatKey({ privateKey, userIds = [], passphrase = "", keyExpi
/**
* Revokes a key. Requires either a private key or a revocation certificate.
* If a revocation certificate is passed, the reasonForRevocation parameters will be ignored.
* @param {Key} key (optional) public or private key to revoke
* @param {String} revocationCertificate (optional) revocation certificate to revoke the key with
* @param {Object} reasonForRevocation (optional) object indicating the reason for revocation
* @param {module:enums.reasonForRevocation} reasonForRevocation.flag (optional) flag indicating the reason for revocation
* @param {String} reasonForRevocation.string (optional) string explaining the reason for revocation
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key} options.key - public or private key to revoke
* @param {String} [options.revocationCertificate] - revocation certificate to revoke the key with
* @param {Object} [options.reasonForRevocation] - object indicating the reason for revocation
* @param {module:enums.reasonForRevocation} [options.reasonForRevocation.flag=[noReason]{@link module:enums.reasonForRevocation}] - flag indicating the reason for revocation
* @param {String} [options.reasonForRevocation.string=""] - string explaining the reason for revocation
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object>} The revoked key object in the form:
* { privateKey:Key, privateKeyArmored:String, publicKey:Key, publicKeyArmored:String }
* (if private key is passed) or { publicKey:Key, publicKeyArmored:String } (otherwise)
* `{ privateKey:Key, privateKeyArmored:String, publicKey:Key, publicKeyArmored:String }`
* (if private key is passed) or `{ publicKey:Key, publicKeyArmored:String }` (otherwise)
* @async
* @static
*/
@ -154,9 +157,10 @@ export function revokeKey({ key, revocationCertificate, reasonForRevocation, con
/**
* Unlock a private key with the given passphrase.
* This method does not change the original key.
* @param {Key} privateKey the private key to decrypt
* @param {String|Array<String>} passphrase the user's passphrase(s)
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key} options.privateKey - the private key to decrypt
* @param {String|Array<String>} options.passphrase - the user's passphrase(s)
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Key>} the unlocked key object
* @async
*/
@ -182,9 +186,10 @@ export async function decryptKey({ privateKey, passphrase, config }) {
/**
* Lock a private key with the given passphrase.
* This method does not change the original key.
* @param {Key} privateKey the private key to encrypt
* @param {String|Array<String>} passphrase if multiple passphrases, they should be in the same order as the packets each should encrypt
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key} options.privateKey - the private key to encrypt
* @param {String|Array<String>} options.passphrase - if multiple passphrases, they should be in the same order as the packets each should encrypt
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Key>} the locked key object
* @async
*/
@ -225,21 +230,22 @@ export async function encryptKey({ privateKey, passphrase, config }) {
/**
* 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 {Message} message message to be encrypted as created by openpgp.Message.fromText or openpgp.Message.fromBinary
* @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 {Object} sessionKey (optional) session key in the form: { data:Uint8Array, algorithm:String }
* @param {Boolean} armor (optional) whether the return values should be ascii armored (true, the default) or binary (false)
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Signature} signature (optional) a detached signature to add to the encrypted message
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Array<module:type/keyid~Keyid>} encryptionKeyIds (optional) array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} date (optional) override the creation date of the message signature
* @param {Array<Object>} fromUserIds (optional) array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Array<Object>} toUserIds (optional) array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Message} options.message - message to be encrypted as created by {@link Message.fromText} or {@link Message.fromBinary}
* @param {Key|Array<Key>} [options.publicKeys] - array of keys or single key, used to encrypt the message
* @param {Key|Array<Key>} [options.privateKeys] - private keys for signing. If omitted message will not be signed
* @param {String|Array<String>} [options.passwords] - array of passwords or a single password to encrypt the message
* @param {Object} [options.sessionKey] - session key in the form: `{ data:Uint8Array, algorithm:String }`
* @param {Boolean} [options.armor=true] - whether the return values should be ascii armored (true, the default) or binary (false)
* @param {'web'|'ponyfill'|'node'|false} [options.streaming=type of stream `message` was created from, if any] - whether to return data as a stream
* @param {Signature} [options.signature] - a detached signature to add to the encrypted message
* @param {Boolean} [options.wildcard=false] - use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} [options.signingKeyIds=latest-created valid signing (sub)keys] - array of key IDs to use for signing. Each `signingKeyIds[i]` corresponds to `privateKeys[i]`
* @param {Array<module:type/keyid~Keyid>} [options.encryptionKeyIds=latest-created valid encryption (sub)keys] - array of key IDs to use for encryption. Each `encryptionKeyIds[i]` corresponds to `publicKeys[i]`
* @param {Date} [options.date=current date] - override the creation date of the message signature
* @param {Array<Object>} [options.fromUserIds=primary user IDs] - array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Array<Object>} [options.toUserIds=primary user IDs] - array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<String|ReadableStream<String>|NodeStream<String>|Uint8Array|ReadableStream<Uint8Array>|NodeStream<Uint8Array>>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
@ -268,16 +274,17 @@ export function encrypt({ message, publicKeys, privateKeys, passwords, sessionKe
/**
* 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|Array<Key>} privateKeys (optional) private keys with decrypted secret key data or session key
* @param {String|Array<String>} passwords (optional) passwords to decrypt the message
* @param {Object|Array<Object>} sessionKeys (optional) session keys in the form: { data:Uint8Array, algorithm:String }
* @param {Key|Array<Key>} publicKeys (optional) array of public keys or single key, to verify signatures
* @param {'utf8'|'binary'} format (optional) whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines.
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Signature} signature (optional) detached signature for verification
* @param {Date} date (optional) use the given date for verification instead of the current time
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Message} options.message - the message object with the encrypted data
* @param {Key|Array<Key>} [options.privateKeys] - private keys with decrypted secret key data or session key
* @param {String|Array<String>} [options.passwords] - passwords to decrypt the message
* @param {Object|Array<Object>} [options.sessionKeys] - session keys in the form: { data:Uint8Array, algorithm:String }
* @param {Key|Array<Key>} [options.publicKeys] - array of public keys or single key, to verify signatures
* @param {'utf8'|'binary'} [options.format] - whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines.
* @param {'web'|'ponyfill'|'node'|false} [options.streaming=type of stream `message` was created from, if any] - whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Signature} [options.signature] - detached signature for verification
* @param {Date} [options.date=current date] - use the given date for verification instead of the current time
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object>} Object containing decrypted and verified message in the form:
*
* {
@ -325,15 +332,16 @@ export function decrypt({ message, privateKeys, passwords, sessionKeys, publicKe
/**
* Signs a message.
* @param {CleartextMessage|Message} message (cleartext) message to be signed
* @param {Key|Array<Key>} privateKeys array of keys or single key with decrypted secret key data to sign cleartext
* @param {Boolean} armor (optional) whether the return values should be ascii armored (true, the default) or binary (false)
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Boolean} detached (optional) if the return value should contain a detached signature
* @param {Array<module:type/keyid~Keyid>} signingKeyIds (optional) array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} date (optional) override the creation date of the signature
* @param {Array<Object>} fromUserIds (optional) array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {CleartextMessage|Message} options.message - (cleartext) message to be signed
* @param {Key|Array<Key>} options.privateKeys - array of keys or single key with decrypted secret key data to sign cleartext
* @param {Boolean} [options.armor=true] - whether the return values should be ascii armored (true, the default) or binary (false)
* @param {'web'|'ponyfill'|'node'|false} [options.streaming=type of stream `message` was created from, if any] - whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Boolean} [options.detached=false] - if the return value should contain a detached signature
* @param {Array<module:type/keyid~Keyid>} [options.signingKeyIds=latest-created valid signing (sub)keys] - array of key IDs to use for signing. Each signingKeyIds[i] corresponds to privateKeys[i]
* @param {Date} [options.date=current date] - override the creation date of the signature
* @param {Array<Object>} [options.fromUserIds=primary user IDs] - array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<String|ReadableStream<String>|NodeStream<String>|Uint8Array|ReadableStream<Uint8Array>|NodeStream<Uint8Array>>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
@ -369,13 +377,14 @@ export function sign({ message, privateKeys, armor = true, streaming = message &
/**
* Verifies signatures of cleartext signed message
* @param {Key|Array<Key>} publicKeys array of publicKeys or single key, to verify signatures
* @param {CleartextMessage|Message} message (cleartext) message object with signatures
* @param {'utf8'|'binary'} format (optional) whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines.
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Signature} signature (optional) detached signature for verification
* @param {Date} date (optional) use the given date for verification instead of the current time
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key|Array<Key>} options.publicKeys - array of publicKeys or single key, to verify signatures
* @param {CleartextMessage|Message} options.message - (cleartext) message object with signatures
* @param {'utf8'|'binary'} [options.format] - whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines.
* @param {'web'|'ponyfill'|'node'|false} [options.streaming=type of stream `message` was created from, if any] - whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Signature} [options.signature] - detached signature for verification
* @param {Date} [options.date=current date] - use the given date for verification instead of the current time
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object>} Object containing verified message in the form:
*
* {
@ -422,10 +431,11 @@ export function verify({ message, publicKeys, format = 'utf8', streaming = messa
/**
* Generate a new session key object, taking the algorithm preferences of the passed public keys into account.
* @param {Key|Array<Key>} publicKeys array of public keys or single key used to select algorithm preferences for
* @param {Date} date (optional) date to select algorithm preferences at
* @param {Array} toUserIds (optional) user IDs to select algorithm preferences for
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Key|Array<Key>} options.publicKeys - array of public keys or single key used to select algorithm preferences for
* @param {Date} [options.date=current date] - date to select algorithm preferences at
* @param {Array} [options.toUserIds=primary user IDs] - user IDs to select algorithm preferences for
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<{ data: Uint8Array, algorithm: String }>} object with session key data and algorithm
* @async
* @static
@ -444,17 +454,18 @@ export function generateSessionKey({ publicKeys, date = new Date(), toUserIds =
/**
* Encrypt a symmetric session key with public keys, passwords, or both at once. At least either public keys
* or passwords must be specified.
* @param {Uint8Array} data the session key to be encrypted e.g. 16 random bytes (for aes128)
* @param {String} algorithm algorithm of the symmetric session key e.g. 'aes128' or 'aes256'
* @param {String} aeadAlgorithm (optional) aead algorithm, e.g. 'eax' or 'ocb'
* @param {Key|Array<Key>} publicKeys (optional) array of public keys or single key, used to encrypt the key
* @param {String|Array<String>} passwords (optional) passwords for the message
* @param {Boolean} armor (optional) whether the return values should be ascii armored (true, the default) or binary (false)
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} encryptionKeyIds (optional) array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} date (optional) override the date
* @param {Array} toUserIds (optional) array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Phil Zimmermann', email:'phil@openpgp.org' }]
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Uint8Array} options.data - the session key to be encrypted e.g. 16 random bytes (for aes128)
* @param {String} options.algorithm - algorithm of the symmetric session key e.g. 'aes128' or 'aes256'
* @param {String} [options.aeadAlgorithm] - aead algorithm, e.g. 'eax' or 'ocb'
* @param {Key|Array<Key>} [options.publicKeys] - array of public keys or single key, used to encrypt the key
* @param {String|Array<String>} [options.passwords] - passwords for the message
* @param {Boolean} [options.armor=true] - whether the return values should be ascii armored (true, the default) or binary (false)
* @param {Boolean} [options.wildcard] - use a key ID of 0 instead of the public key IDs
* @param {Array<module:type/keyid~Keyid>} [options.encryptionKeyIds=latest-created valid encryption (sub)keys] - array of key IDs to use for encryption. Each encryptionKeyIds[i] corresponds to publicKeys[i]
* @param {Date} [options.date=current date] - override the date
* @param {Array} [options.toUserIds=primary user IDs] - array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Phil Zimmermann', email:'phil@openpgp.org' }]
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<String|Uint8Array>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
@ -474,10 +485,11 @@ export function encryptSessionKey({ data, algorithm, aeadAlgorithm, publicKeys,
/**
* Decrypt symmetric session keys with a private key or password. Either a private key or
* a password must be specified.
* @param {Message} message a message object containing the encrypted session key packets
* @param {Key|Array<Key>} privateKeys (optional) private keys with decrypted secret key data
* @param {String|Array<String>} passwords (optional) passwords to decrypt the session key
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} options
* @param {Message} options.message - a message object containing the encrypted session key packets
* @param {Key|Array<Key>} [options.privateKeys] - private keys with decrypted secret key data
* @param {String|Array<String>} [options.passwords] - passwords to decrypt the session key
* @param {Object} [options.config] - custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Promise<Object|undefined>} Array of decrypted session key, algorithm pairs in form:
* { data:Uint8Array, algorithm:String }
* or 'undefined' if no key packets found
@ -544,8 +556,8 @@ function toArray(param) {
/**
* Convert data to or from Stream
* @param {Object} data the data to convert
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return a ReadableStream, and of what type
* @param {'utf8'|'binary'} encoding (optional) how to return data in Node Readable streams
* @param {'web'|'ponyfill'|'node'|false} [options.streaming] - whether to return a ReadableStream, and of what type
* @param {'utf8'|'binary'} [options.encoding] - how to return data in Node Readable streams
* @returns {Object} the data in the respective format
* @private
*/

2
src/packet/aead_encrypted_data.js
View File

@ -97,7 +97,7 @@ class AEADEncryptedDataPacket {
* @param {String} sessionKeyAlgorithm The session key's cipher algorithm e.g. 'aes128'
* @param {Uint8Array} key The session key used to encrypt the payload
* @param {Boolean} streaming Whether the top-level function will return a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @throws {Error} if encryption was not successful
* @async
*/

4
src/packet/public_key.js
View File

@ -38,8 +38,8 @@ import util from '../util';
*/
class PublicKeyPacket {
/**
* @param {Date} date (optional) creation date
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - creation date
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(date = new Date(), config = defaultConfig) {
/**

4
src/packet/public_subkey.js
View File

@ -28,8 +28,8 @@ import enums from '../enums';
*/
class PublicSubkeyPacket extends PublicKeyPacket {
/**
* @param {Date} date (optional) creation date
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - creation date
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(date, config) {
super(date, config);

8
src/packet/secret_key.js
View File

@ -30,8 +30,8 @@ import defaultConfig from '../config';
*/
class SecretKeyPacket extends PublicKeyPacket {
/**
* @param {Date} date (optional) creation date
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - creation date
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(date = new Date(), config = defaultConfig) {
super(date, config);
@ -242,7 +242,7 @@ class SecretKeyPacket extends PublicKeyPacket {
/**
* Remove private key material, converting the key to a dummy one.
* The resulting key cannot be used for signing/decrypting but can still verify signatures.
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
makeDummy(config = defaultConfig) {
if (this.isDummy()) {
@ -267,7 +267,7 @@ class SecretKeyPacket extends PublicKeyPacket {
* and the passphrase is empty or undefined, the key will be set as not encrypted.
* This can be used to remove passphrase protection after calling decrypt().
* @param {String} passphrase
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @throws {Error} if encryption was not successful
* @async
*/

4
src/packet/secret_subkey.js
View File

@ -26,8 +26,8 @@ import defaultConfig from '../config';
*/
class SecretSubkeyPacket extends SecretKeyPacket {
/**
* @param {Date} date (optional) creation date
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Date} [date] - creation date
* @param {Object} [config] - full configuration, defaults to openpgp.config
*/
constructor(date = new Date(), config = defaultConfig) {
super(date, config);

2
src/packet/signature.js
View File

@ -89,7 +89,7 @@ class SignaturePacket {
/**
* parsing function for a signature packet (tag 2).
* @param {String} bytes payload of a tag 2 packet
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {SignaturePacket} object representation
*/
read(bytes, config = defaultConfig) {

4
src/packet/sym_encrypted_integrity_protected_data.js
View File

@ -79,7 +79,7 @@ class SymEncryptedIntegrityProtectedDataPacket {
* @param {String} sessionKeyAlgorithm The selected symmetric encryption algorithm to be used e.g. 'aes128'
* @param {Uint8Array} key The key of cipher blocksize length to be used
* @param {Boolean} streaming Whether to set this.encrypted to a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Boolean>}
* @async
*/
@ -102,7 +102,7 @@ class SymEncryptedIntegrityProtectedDataPacket {
* @param {String} sessionKeyAlgorithm The selected symmetric encryption algorithm to be used e.g. 'aes128'
* @param {Uint8Array} key The key of cipher blocksize length to be used
* @param {Boolean} streaming Whether to read this.encrypted as a stream
* @param {Object} config (optional) full configuration, defaults to openpgp.config
* @param {Object} [config] - full configuration, defaults to openpgp.config
* @returns {Promise<Boolean>}
* @async
*/

2
src/signature.js
View File

@ -53,7 +53,7 @@ export class Signature {
* reads an (optionally armored) OpenPGP signature and returns a signature object
* @param {String | ReadableStream<String>} armoredSignature armored signature to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binarySignature binary signature to be parsed
* @param {Object} config (optional) custom configuration settings to overwrite those in openpgp.config
* @param {Object} config (optional) custom configuration settings to overwrite those in [config]{@link module:config}
* @returns {Signature} new signature object
* @async
* @static