Switch util function names to camelCase (#1091)
This commit is contained in:
Ilya Chesnokov
Daniel Huigens
parent
d415bc2546
commit
e16807505f
16
README.md
16
README.md
|
|
@ -77,16 +77,16 @@ library to convert back and forth between them.
|
|||
|
||||
* Version 2.x of the library has been built from the ground up with Uint8Arrays. This allows for much better performance and memory usage than strings.
|
||||
|
||||
* If the user's browser supports [native WebCrypto](https://caniuse.com/#feat=cryptography) via the `window.crypto.subtle` API, this will be used. Under Node.js the native [crypto module](https://nodejs.org/api/crypto.html#crypto_crypto) is used. This can be deactivated by setting `openpgp.config.use_native = false`.
|
||||
* If the user's browser supports [native WebCrypto](https://caniuse.com/#feat=cryptography) via the `window.crypto.subtle` API, this will be used. Under Node.js the native [crypto module](https://nodejs.org/api/crypto.html#crypto_crypto) is used. This can be deactivated by setting `openpgp.config.useNative = false`.
|
||||
|
||||
* The library implements the [IETF proposal](https://tools.ietf.org/html/draft-ietf-openpgp-rfc4880bis-07) for authenticated encryption using native AES-EAX, OCB, or GCM. This makes symmetric encryption up to 30x faster on supported platforms. Since the specification has not been finalized and other OpenPGP implementations haven't adopted it yet, the feature is currently behind a flag. **Note: activating this setting can break compatibility with other OpenPGP implementations, and also with future versions of OpenPGP.js. Don't use it with messages you want to store on disk or in a database.** You can enable it by setting `openpgp.config.aead_protect = true`.
|
||||
* The library implements the [IETF proposal](https://tools.ietf.org/html/draft-ietf-openpgp-rfc4880bis-07) for authenticated encryption using native AES-EAX, OCB, or GCM. This makes symmetric encryption up to 30x faster on supported platforms. Since the specification has not been finalized and other OpenPGP implementations haven't adopted it yet, the feature is currently behind a flag. **Note: activating this setting can break compatibility with other OpenPGP implementations, and also with future versions of OpenPGP.js. Don't use it with messages you want to store on disk or in a database.** You can enable it by setting `openpgp.config.aeadProtect = true`.
|
||||
|
||||
You can change the AEAD mode by setting one of the following options:
|
||||
|
||||
```
|
||||
openpgp.config.aead_mode = openpgp.enums.aead.eax // Default, native
|
||||
openpgp.config.aead_mode = openpgp.enums.aead.ocb // Non-native
|
||||
openpgp.config.aead_mode = openpgp.enums.aead.experimental_gcm // **Non-standard**, fastest
|
||||
openpgp.config.aeadMode = openpgp.enums.aead.eax // Default, native
|
||||
openpgp.config.aeadMode = openpgp.enums.aead.ocb // Non-native
|
||||
openpgp.config.aeadMode = openpgp.enums.aead.experimental_gcm // **Non-standard**, fastest
|
||||
```
|
||||
|
||||
* For environments that don't provide native crypto, the library falls back to [asm.js](https://caniuse.com/#feat=asmjs) implementations of AES, SHA-1, and SHA-256. We use [Rusha](https://github.com/srijs/rusha) and [asmCrypto Lite](https://github.com/openpgpjs/asmcrypto-lite) (a minimal subset of asmCrypto.js built specifically for OpenPGP.js).
|
||||
|
|
@ -127,12 +127,12 @@ Copy `dist/openpgp.min.js` or `dist/compat/openpgp.min.js` (depending on the bro
|
|||
|
||||
To offload cryptographic operations off the main thread, you can implement a Web Worker in your application and load OpenPGP.js from there. This can be more performant if you store or fetch keys and messages directly inside the Worker, so that they don't have to be `postMessage`d there. For an example Worker implementation, see `test/worker/worker_example.js`.
|
||||
|
||||
If you want to use the lightweight build (which is smaller, and lazily loads non-default curves on demand), copy `dist/lightweight/openpgp.min.js` and `dist/lightweight/elliptic.min.js`, load the former in a script tag, and point `openpgp.config.indutny_elliptic_path` to the latter:
|
||||
If you want to use the lightweight build (which is smaller, and lazily loads non-default curves on demand), copy `dist/lightweight/openpgp.min.js` and `dist/lightweight/elliptic.min.js`, load the former in a script tag, and point `openpgp.config.indutnyEllipticPath` to the latter:
|
||||
|
||||
```html
|
||||
<script src="lightweight/openpgp.min.js"></script>
|
||||
<script>
|
||||
openpgp.config.indutny_elliptic_path = 'lightweight/elliptic.min.js';
|
||||
openpgp.config.indutnyEllipticPath = 'lightweight/elliptic.min.js';
|
||||
</script>
|
||||
```
|
||||
|
||||
|
|
@ -146,7 +146,7 @@ For more examples of how to generate a key, see [Generate new key pair](#generat
|
|||
|
||||
#### Encrypt and decrypt *Uint8Array* data with a password
|
||||
|
||||
Encryption will use the algorithm specified in config.encryption_cipher (defaults to aes256), and decryption will use the algorithm used for encryption.
|
||||
Encryption will use the algorithm specified in config.encryptionCipher (defaults to aes256), and decryption will use the algorithm used for encryption.
|
||||
|
||||
```js
|
||||
(async () => {
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ export default {
|
|||
switch (algo) {
|
||||
case enums.publicKey.rsa_encrypt:
|
||||
case enums.publicKey.rsa_encrypt_sign: {
|
||||
data = util.str_to_Uint8Array(data);
|
||||
data = util.strToUint8Array(data);
|
||||
const n = pub_params[0].toUint8Array();
|
||||
const e = pub_params[1].toUint8Array();
|
||||
const res = await publicKey.rsa.encrypt(data, n, e);
|
||||
|
|
|
|||
|
|
@ -20,8 +20,8 @@ import util from '../../util';
|
|||
|
||||
// MD5 Digest
|
||||
async function md5(entree) {
|
||||
const digest = md51(util.Uint8Array_to_str(entree));
|
||||
return util.hex_to_Uint8Array(hex(digest));
|
||||
const digest = md51(util.uint8ArrayToStr(entree));
|
||||
return util.hexToUint8Array(hex(digest));
|
||||
}
|
||||
|
||||
function md5cycle(x, k) {
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ eme.decode = function(EM) {
|
|||
*/
|
||||
emsa.encode = async function(algo, hashed, emLen) {
|
||||
let i;
|
||||
const H = util.Uint8Array_to_str(hashed);
|
||||
const H = util.uint8ArrayToStr(hashed);
|
||||
if (H.length !== hash.getHashByteLength(algo)) {
|
||||
throw new Error('Invalid hash length');
|
||||
}
|
||||
|
|
@ -160,7 +160,7 @@ emsa.encode = async function(algo, hashed, emLen) {
|
|||
PS +
|
||||
String.fromCharCode(0x00) +
|
||||
T;
|
||||
return util.str_to_hex(EM);
|
||||
return util.strToHex(EM);
|
||||
};
|
||||
|
||||
export default { eme, emsa };
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ export default {
|
|||
verify: async function(hash_algo, r, s, hashed, g, p, q, y) {
|
||||
if (zero.ucmp(r) >= 0 || r.ucmp(q) >= 0 ||
|
||||
zero.ucmp(s) >= 0 || s.ucmp(q) >= 0) {
|
||||
util.print_debug("invalid DSA Signature");
|
||||
util.printDebug("invalid DSA Signature");
|
||||
return null;
|
||||
}
|
||||
const redp = new BN.red(p);
|
||||
|
|
@ -113,7 +113,7 @@ export default {
|
|||
const h = new BN(hashed.subarray(0, q.byteLength()));
|
||||
const w = s.toRed(redq).redInvm(); // s**-1 mod q
|
||||
if (zero.cmp(w) === 0) {
|
||||
util.print_debug("invalid DSA Signature");
|
||||
util.printDebug("invalid DSA Signature");
|
||||
return null;
|
||||
}
|
||||
const u1 = h.toRed(redq).redMul(w); // H(m) * w mod q
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ Curve.prototype.genKeyPair = async function () {
|
|||
try {
|
||||
return await webGenKeyPair(this.name);
|
||||
} catch (err) {
|
||||
util.print_debug_error("Browser did not support generating ec key " + err.message);
|
||||
util.printDebugError("Browser did not support generating ec key " + err.message);
|
||||
break;
|
||||
}
|
||||
case 'node':
|
||||
|
|
@ -207,7 +207,7 @@ Curve.prototype.genKeyPair = async function () {
|
|||
}
|
||||
const indutnyCurve = await getIndutnyCurve(this.name);
|
||||
keyPair = await indutnyCurve.genKeyPair({
|
||||
entropy: util.Uint8Array_to_str(await random.getRandomBytes(32))
|
||||
entropy: util.uint8ArrayToStr(await random.getRandomBytes(32))
|
||||
});
|
||||
return { publicKey: new Uint8Array(keyPair.getPublic('array', false)), privateKey: keyPair.getPrivate().toArrayLike(Uint8Array) };
|
||||
};
|
||||
|
|
@ -313,7 +313,7 @@ async function webGenKeyPair(name) {
|
|||
|
||||
return {
|
||||
publicKey: jwkToRawPublic(publicKey),
|
||||
privateKey: util.b64_to_Uint8Array(privateKey.d, true)
|
||||
privateKey: util.b64ToUint8Array(privateKey.d, true)
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -339,8 +339,8 @@ async function nodeGenKeyPair(name) {
|
|||
* @returns {Uint8Array} raw public key
|
||||
*/
|
||||
function jwkToRawPublic(jwk) {
|
||||
const bufX = util.b64_to_Uint8Array(jwk.x);
|
||||
const bufY = util.b64_to_Uint8Array(jwk.y);
|
||||
const bufX = util.b64ToUint8Array(jwk.x);
|
||||
const bufY = util.b64ToUint8Array(jwk.y);
|
||||
const publicKey = new Uint8Array(bufX.length + bufY.length + 1);
|
||||
publicKey[0] = 0x04;
|
||||
publicKey.set(bufX, 1);
|
||||
|
|
@ -363,8 +363,8 @@ function rawPublicToJwk(payloadSize, name, publicKey) {
|
|||
const jwk = {
|
||||
kty: "EC",
|
||||
crv: name,
|
||||
x: util.Uint8Array_to_b64(bufX, true),
|
||||
y: util.Uint8Array_to_b64(bufY, true),
|
||||
x: util.uint8ArrayToB64(bufX, true),
|
||||
y: util.uint8ArrayToB64(bufY, true),
|
||||
ext: true
|
||||
};
|
||||
return jwk;
|
||||
|
|
@ -380,6 +380,6 @@ function rawPublicToJwk(payloadSize, name, publicKey) {
|
|||
*/
|
||||
function privateToJwk(payloadSize, name, publicKey, privateKey) {
|
||||
const jwk = rawPublicToJwk(payloadSize, name, publicKey);
|
||||
jwk.d = util.Uint8Array_to_b64(privateKey, true);
|
||||
jwk.d = util.uint8ArrayToB64(privateKey, true);
|
||||
return jwk;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ function buildEcdhParam(public_algo, oid, kdfParams, fingerprint) {
|
|||
oid.write(),
|
||||
new Uint8Array([public_algo]),
|
||||
kdfParams.write(),
|
||||
util.str_to_Uint8Array("Anonymous Sender "),
|
||||
util.strToUint8Array("Anonymous Sender "),
|
||||
fingerprint.subarray(0, 20)
|
||||
]);
|
||||
}
|
||||
|
|
@ -138,7 +138,7 @@ async function genPublicEphemeralKey(curve, Q) {
|
|||
try {
|
||||
return await webPublicEphemeralKey(curve, Q);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -196,7 +196,7 @@ async function genPrivateEphemeralKey(curve, V, Q, d) {
|
|||
try {
|
||||
return await webPrivateEphemeralKey(curve, V, Q, d);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -286,7 +286,7 @@ async function webPrivateEphemeralKey(curve, V, Q, d) {
|
|||
);
|
||||
[S, secret] = await Promise.all([S, secret]);
|
||||
const sharedKey = new Uint8Array(S);
|
||||
const secretKey = util.b64_to_Uint8Array(secret.d, true);
|
||||
const secretKey = util.b64ToUint8Array(secret.d, true);
|
||||
return { secretKey, sharedKey };
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ async function sign(oid, hash_algo, message, publicKey, privateKey, hashed) {
|
|||
if (curve.name !== 'p521' && (err.name === 'DataError' || err.name === 'OperationError')) {
|
||||
throw err;
|
||||
}
|
||||
util.print_debug_error("Browser did not support verifying: " + err.message);
|
||||
util.print_debug_error("Browser did not support signing: " + err.message);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ export default {
|
|||
try {
|
||||
return await this.webSign(enums.read(enums.webHash, hash_algo), data, n, e, d, p, q, u);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
}
|
||||
} else if (util.getNodeCrypto()) {
|
||||
return this.nodeSign(hash_algo, data, n, e, d, p, q, u);
|
||||
|
|
@ -122,7 +122,7 @@ export default {
|
|||
try {
|
||||
return await this.webVerify(enums.read(enums.webHash, hash_algo), data, s, n, e);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
}
|
||||
} else if (util.getNodeCrypto()) {
|
||||
return this.nodeVerify(hash_algo, data, s, n, e);
|
||||
|
|
@ -224,14 +224,14 @@ export default {
|
|||
}
|
||||
// map JWK parameters to BN
|
||||
key = {};
|
||||
key.n = new BN(util.b64_to_Uint8Array(jwk.n));
|
||||
key.n = new BN(util.b64ToUint8Array(jwk.n));
|
||||
key.e = E;
|
||||
key.d = new BN(util.b64_to_Uint8Array(jwk.d));
|
||||
key.d = new BN(util.b64ToUint8Array(jwk.d));
|
||||
// switch p and q
|
||||
key.p = new BN(util.b64_to_Uint8Array(jwk.q));
|
||||
key.q = new BN(util.b64_to_Uint8Array(jwk.p));
|
||||
key.p = new BN(util.b64ToUint8Array(jwk.q));
|
||||
key.q = new BN(util.b64ToUint8Array(jwk.p));
|
||||
// Since p and q are switched in places, we could keep u
|
||||
key.u = new BN(util.b64_to_Uint8Array(jwk.qi));
|
||||
key.u = new BN(util.b64ToUint8Array(jwk.qi));
|
||||
return key;
|
||||
} else if (util.getNodeCrypto() && nodeCrypto.generateKeyPair && RSAPrivateKey) {
|
||||
const opts = {
|
||||
|
|
@ -405,7 +405,7 @@ export default {
|
|||
const nred = new BN.red(n);
|
||||
const EM1 = s.toRed(nred).redPow(e).toArrayLike(Uint8Array, 'be', n.byteLength());
|
||||
const EM2 = await pkcs1.emsa.encode(hash_algo, hashed, n.byteLength());
|
||||
return util.Uint8Array_to_hex(EM1) === EM2;
|
||||
return util.uint8ArrayToHex(EM1) === EM2;
|
||||
},
|
||||
|
||||
webVerify: async function (hash_name, data, s, n, e) {
|
||||
|
|
@ -462,7 +462,7 @@ export default {
|
|||
|
||||
bnEncrypt: async function (data, n, e) {
|
||||
n = new BN(n);
|
||||
data = new type_mpi(await pkcs1.eme.encode(util.Uint8Array_to_str(data), n.byteLength()));
|
||||
data = new type_mpi(await pkcs1.eme.encode(util.uint8ArrayToStr(data), n.byteLength()));
|
||||
data = data.toBN();
|
||||
e = new BN(e);
|
||||
if (n.cmp(data) <= 0) {
|
||||
|
|
@ -502,7 +502,7 @@ export default {
|
|||
key = { key: pem, padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
|
||||
}
|
||||
try {
|
||||
return util.Uint8Array_to_str(nodeCrypto.privateDecrypt(key, data));
|
||||
return util.uint8ArrayToStr(nodeCrypto.privateDecrypt(key, data));
|
||||
} catch (err) {
|
||||
throw new Error('Decryption error');
|
||||
}
|
||||
|
|
@ -572,16 +572,16 @@ function privateToJwk(n, e, d, p, q, u) {
|
|||
dq = dq.toArrayLike(Uint8Array);
|
||||
return {
|
||||
kty: 'RSA',
|
||||
n: util.Uint8Array_to_b64(n, true),
|
||||
e: util.Uint8Array_to_b64(e, true),
|
||||
d: util.Uint8Array_to_b64(d, true),
|
||||
n: util.uint8ArrayToB64(n, true),
|
||||
e: util.uint8ArrayToB64(e, true),
|
||||
d: util.uint8ArrayToB64(d, true),
|
||||
// switch p and q
|
||||
p: util.Uint8Array_to_b64(q, true),
|
||||
q: util.Uint8Array_to_b64(p, true),
|
||||
p: util.uint8ArrayToB64(q, true),
|
||||
q: util.uint8ArrayToB64(p, true),
|
||||
// switch dp and dq
|
||||
dp: util.Uint8Array_to_b64(dq, true),
|
||||
dq: util.Uint8Array_to_b64(dp, true),
|
||||
qi: util.Uint8Array_to_b64(u, true),
|
||||
dp: util.uint8ArrayToB64(dq, true),
|
||||
dq: util.uint8ArrayToB64(dp, true),
|
||||
qi: util.uint8ArrayToB64(u, true),
|
||||
ext: true
|
||||
};
|
||||
}
|
||||
|
|
@ -595,8 +595,8 @@ function privateToJwk(n, e, d, p, q, u) {
|
|||
function publicToJwk(n, e) {
|
||||
return {
|
||||
kty: 'RSA',
|
||||
n: util.Uint8Array_to_b64(n, true),
|
||||
e: util.Uint8Array_to_b64(e, true),
|
||||
n: util.uint8ArrayToB64(n, true),
|
||||
e: util.uint8ArrayToB64(e, true),
|
||||
ext: true
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ export default {
|
|||
const q = key_params[4].toUint8Array();
|
||||
const u = key_params[5].toUint8Array();
|
||||
const signature = await publicKey.rsa.sign(hash_algo, data, n, e, d, p, q, u, hashed);
|
||||
return util.Uint8Array_to_MPI(signature);
|
||||
return util.uint8ArrayToMpi(signature);
|
||||
}
|
||||
case enums.publicKey.dsa: {
|
||||
const p = key_params[0].toBN();
|
||||
|
|
@ -107,8 +107,8 @@ export default {
|
|||
const x = key_params[4].toBN();
|
||||
const signature = await publicKey.dsa.sign(hash_algo, hashed, g, p, q, x);
|
||||
return util.concatUint8Array([
|
||||
util.Uint8Array_to_MPI(signature.r),
|
||||
util.Uint8Array_to_MPI(signature.s)
|
||||
util.uint8ArrayToMpi(signature.r),
|
||||
util.uint8ArrayToMpi(signature.s)
|
||||
]);
|
||||
}
|
||||
case enums.publicKey.elgamal: {
|
||||
|
|
@ -118,16 +118,16 @@ export default {
|
|||
const { oid, Q, d } = publicKey.elliptic.ecdsa.parseParams(key_params);
|
||||
const signature = await publicKey.elliptic.ecdsa.sign(oid, hash_algo, data, Q, d, hashed);
|
||||
return util.concatUint8Array([
|
||||
util.Uint8Array_to_MPI(signature.r),
|
||||
util.Uint8Array_to_MPI(signature.s)
|
||||
util.uint8ArrayToMpi(signature.r),
|
||||
util.uint8ArrayToMpi(signature.s)
|
||||
]);
|
||||
}
|
||||
case enums.publicKey.eddsa: {
|
||||
const { oid, Q, seed } = publicKey.elliptic.eddsa.parseParams(key_params);
|
||||
const signature = await publicKey.elliptic.eddsa.sign(oid, hash_algo, data, Q, seed, hashed);
|
||||
return util.concatUint8Array([
|
||||
util.Uint8Array_to_MPI(signature.R),
|
||||
util.Uint8Array_to_MPI(signature.S)
|
||||
util.uint8ArrayToMpi(signature.R),
|
||||
util.uint8ArrayToMpi(signature.S)
|
||||
]);
|
||||
}
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ function verifyHeaders(headers) {
|
|||
throw new Error('Improperly formatted armor header: ' + headers[i]);
|
||||
}
|
||||
if (!/^(Version|Comment|MessageID|Hash|Charset): .+$/.test(headers[i])) {
|
||||
util.print_debug_error(new Error('Unknown header: ' + headers[i]));
|
||||
util.printDebugError(new Error('Unknown header: ' + headers[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,8 +31,8 @@ if (Buffer) {
|
|||
return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
||||
};
|
||||
} else {
|
||||
encodeChunk = buf => btoa(util.Uint8Array_to_str(buf));
|
||||
decodeChunk = str => util.str_to_Uint8Array(atob(str));
|
||||
encodeChunk = buf => btoa(util.uint8ArrayToStr(buf));
|
||||
decodeChunk = str => util.strToUint8Array(atob(str));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ Key.prototype.packetlist2structure = function(packetlist) {
|
|||
case enums.signature.cert_casual:
|
||||
case enums.signature.cert_positive:
|
||||
if (!user) {
|
||||
util.print_debug('Dropping certification signatures without preceding user packet');
|
||||
util.printDebug('Dropping certification signatures without preceding user packet');
|
||||
continue;
|
||||
}
|
||||
if (packetlist[i].issuerKeyId.equals(primaryKeyId)) {
|
||||
|
|
@ -126,7 +126,7 @@ Key.prototype.packetlist2structure = function(packetlist) {
|
|||
break;
|
||||
case enums.signature.subkey_binding:
|
||||
if (!subKey) {
|
||||
util.print_debug('Dropping subkey binding signature without preceding subkey packet');
|
||||
util.printDebug('Dropping subkey binding signature without preceding subkey packet');
|
||||
continue;
|
||||
}
|
||||
subKey.bindingSignatures.push(packetlist[i]);
|
||||
|
|
@ -136,7 +136,7 @@ Key.prototype.packetlist2structure = function(packetlist) {
|
|||
break;
|
||||
case enums.signature.subkey_revocation:
|
||||
if (!subKey) {
|
||||
util.print_debug('Dropping subkey revocation signature without preceding subkey packet');
|
||||
util.printDebug('Dropping subkey revocation signature without preceding subkey packet');
|
||||
continue;
|
||||
}
|
||||
subKey.revocationSignatures.push(packetlist[i]);
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ Message.prototype.decrypt = async function(privateKeys, passwords, sessionKeys,
|
|||
try {
|
||||
await symEncryptedPacket.decrypt(keyObj.algorithm, keyObj.data, streaming);
|
||||
} catch (e) {
|
||||
util.print_debug_error(e);
|
||||
util.printDebugError(e);
|
||||
exception = e;
|
||||
}
|
||||
}));
|
||||
|
|
@ -172,7 +172,7 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) {
|
|||
await keyPacket.decrypt(password);
|
||||
keyPackets.push(keyPacket);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
}
|
||||
}));
|
||||
}));
|
||||
|
|
@ -212,7 +212,7 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) {
|
|||
}
|
||||
keyPackets.push(keyPacket);
|
||||
} catch (err) {
|
||||
util.print_debug_error(err);
|
||||
util.printDebugError(err);
|
||||
exception = err;
|
||||
}
|
||||
}));
|
||||
|
|
@ -229,7 +229,7 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) {
|
|||
if (keyPackets.length > 1) {
|
||||
const seen = {};
|
||||
keyPackets = keyPackets.filter(function(item) {
|
||||
const k = item.sessionKeyAlgorithm + util.Uint8Array_to_str(item.sessionKey);
|
||||
const k = item.sessionKeyAlgorithm + util.uint8ArrayToStr(item.sessionKey);
|
||||
if (seen.hasOwnProperty(k)) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -567,7 +567,7 @@ async function prepareSignatures(signatures) {
|
|||
} catch (e) {
|
||||
signature.valid = false;
|
||||
signature.error = e;
|
||||
util.print_debug_error(e);
|
||||
util.printDebugError(e);
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
|
@ -580,7 +580,7 @@ async function prepareSignatures(signatures) {
|
|||
*/
|
||||
function onError(message, error) {
|
||||
// log the stack trace
|
||||
util.print_debug_error(error);
|
||||
util.printDebugError(error);
|
||||
|
||||
// update error message
|
||||
try {
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ Literal.prototype.setText = function(text, format = 'utf8') {
|
|||
*/
|
||||
Literal.prototype.getText = function(clone = false) {
|
||||
if (this.text === null || util.isStream(this.text)) { // Assume that this.text has been read
|
||||
this.text = util.decode_utf8(util.nativeEOL(this.getBytes(clone)));
|
||||
this.text = util.decodeUtf8(util.nativeEOL(this.getBytes(clone)));
|
||||
}
|
||||
return this.text;
|
||||
};
|
||||
|
|
@ -89,7 +89,7 @@ Literal.prototype.setBytes = function(bytes, format) {
|
|||
Literal.prototype.getBytes = function(clone = false) {
|
||||
if (this.data === null) {
|
||||
// encode UTF8 and normalize EOL to \r\n
|
||||
this.data = util.canonicalizeEOL(util.encode_utf8(this.text));
|
||||
this.data = util.canonicalizeEOL(util.encodeUtf8(this.text));
|
||||
}
|
||||
if (clone) {
|
||||
return stream.passiveClone(this.data);
|
||||
|
|
@ -128,7 +128,7 @@ Literal.prototype.read = async function(bytes) {
|
|||
const format = enums.read(enums.literal, await reader.readByte());
|
||||
|
||||
const filename_len = await reader.readByte();
|
||||
this.filename = util.decode_utf8(await reader.readBytes(filename_len));
|
||||
this.filename = util.decodeUtf8(await reader.readBytes(filename_len));
|
||||
|
||||
this.date = util.readDate(await reader.readBytes(4));
|
||||
|
||||
|
|
@ -144,7 +144,7 @@ Literal.prototype.read = async function(bytes) {
|
|||
* @returns {Uint8Array} Uint8Array representation of the packet
|
||||
*/
|
||||
Literal.prototype.writeHeader = function() {
|
||||
const filename = util.encode_utf8(this.filename);
|
||||
const filename = util.encodeUtf8(this.filename);
|
||||
const filename_length = new Uint8Array([filename.length]);
|
||||
|
||||
const format = new Uint8Array([enums.write(enums.literal, this.format)]);
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ List.prototype.read = async function (bytes, streaming) {
|
|||
// about and throw on parse errors for.
|
||||
await writer.abort(e);
|
||||
}
|
||||
util.print_debug_error(e);
|
||||
util.printDebugError(e);
|
||||
}
|
||||
});
|
||||
if (done) {
|
||||
|
|
|
|||
|
|
@ -206,9 +206,9 @@ PublicKey.prototype.getKeyId = function () {
|
|||
}
|
||||
this.keyid = new type_keyid();
|
||||
if (this.version === 5) {
|
||||
this.keyid.read(util.hex_to_Uint8Array(this.getFingerprint()).subarray(0, 8));
|
||||
this.keyid.read(util.hexToUint8Array(this.getFingerprint()).subarray(0, 8));
|
||||
} else if (this.version === 4) {
|
||||
this.keyid.read(util.hex_to_Uint8Array(this.getFingerprint()).subarray(12, 20));
|
||||
this.keyid.read(util.hexToUint8Array(this.getFingerprint()).subarray(12, 20));
|
||||
}
|
||||
return this.keyid;
|
||||
};
|
||||
|
|
@ -235,7 +235,7 @@ PublicKey.prototype.getFingerprintBytes = function () {
|
|||
* @returns {String} A string containing the fingerprint in lowercase hex
|
||||
*/
|
||||
PublicKey.prototype.getFingerprint = function() {
|
||||
return util.Uint8Array_to_hex(this.getFingerprintBytes());
|
||||
return util.uint8ArrayToHex(this.getFingerprintBytes());
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -109,8 +109,8 @@ PublicKeyEncryptedSessionKey.prototype.write = function () {
|
|||
PublicKeyEncryptedSessionKey.prototype.encrypt = async function (key) {
|
||||
let data = String.fromCharCode(enums.write(enums.symmetric, this.sessionKeyAlgorithm));
|
||||
|
||||
data += util.Uint8Array_to_str(this.sessionKey);
|
||||
data += util.Uint8Array_to_str(util.write_checksum(this.sessionKey));
|
||||
data += util.uint8ArrayToStr(this.sessionKey);
|
||||
data += util.uint8ArrayToStr(util.writeChecksum(this.sessionKey));
|
||||
const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
|
||||
this.encrypted = await crypto.publicKeyEncrypt(
|
||||
algo, key.params, data, key.getFingerprintBytes());
|
||||
|
|
@ -134,10 +134,10 @@ PublicKeyEncryptedSessionKey.prototype.decrypt = async function (key) {
|
|||
throw new Error('Decryption error');
|
||||
}
|
||||
const decoded = await crypto.publicKeyDecrypt(algo, key.params, this.encrypted, key.getFingerprintBytes());
|
||||
const checksum = util.str_to_Uint8Array(decoded.substr(decoded.length - 2));
|
||||
key = util.str_to_Uint8Array(decoded.substring(1, decoded.length - 2));
|
||||
const checksum = util.strToUint8Array(decoded.substr(decoded.length - 2));
|
||||
key = util.strToUint8Array(decoded.substring(1, decoded.length - 2));
|
||||
|
||||
if (!util.equalsUint8Array(checksum, util.write_checksum(key))) {
|
||||
if (!util.equalsUint8Array(checksum, util.writeChecksum(key))) {
|
||||
throw new Error('Decryption error');
|
||||
} else {
|
||||
this.sessionKey = key;
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ SecretKey.prototype.read = function (bytes) {
|
|||
|
||||
if (!this.isEncrypted) {
|
||||
const cleartext = this.keyMaterial.subarray(0, -2);
|
||||
if (!util.equalsUint8Array(util.write_checksum(cleartext), this.keyMaterial.subarray(-2))) {
|
||||
if (!util.equalsUint8Array(util.writeChecksum(cleartext), this.keyMaterial.subarray(-2))) {
|
||||
throw new Error('Key checksum mismatch');
|
||||
}
|
||||
const privParams = parse_cleartext_params(cleartext, this.algorithm);
|
||||
|
|
@ -237,7 +237,7 @@ SecretKey.prototype.write = function () {
|
|||
const cleartextParams = write_cleartext_params(this.params, this.algorithm);
|
||||
this.keyMaterial = util.concatUint8Array([
|
||||
cleartextParams,
|
||||
util.write_checksum(cleartextParams)
|
||||
util.writeChecksum(cleartextParams)
|
||||
]);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ Signature.prototype.write_hashed_sub_packets = function () {
|
|||
arr.push(write_sub_packet(sub.key_expiration_time, util.writeNumber(this.keyExpirationTime, 4)));
|
||||
}
|
||||
if (this.preferredSymmetricAlgorithms !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.preferredSymmetricAlgorithms));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.preferredSymmetricAlgorithms));
|
||||
arr.push(write_sub_packet(sub.preferred_symmetric_algorithms, bytes));
|
||||
}
|
||||
if (this.revocationKeyClass !== null) {
|
||||
|
|
@ -238,55 +238,55 @@ Signature.prototype.write_hashed_sub_packets = function () {
|
|||
bytes.push(util.writeNumber(name.length, 2));
|
||||
// 2 octets of value length
|
||||
bytes.push(util.writeNumber(value.length, 2));
|
||||
bytes.push(util.str_to_Uint8Array(name));
|
||||
bytes.push(util.strToUint8Array(name));
|
||||
bytes.push(value);
|
||||
bytes = util.concat(bytes);
|
||||
arr.push(write_sub_packet(sub.notation_data, bytes));
|
||||
});
|
||||
if (this.preferredHashAlgorithms !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.preferredHashAlgorithms));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.preferredHashAlgorithms));
|
||||
arr.push(write_sub_packet(sub.preferred_hash_algorithms, bytes));
|
||||
}
|
||||
if (this.preferredCompressionAlgorithms !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.preferredCompressionAlgorithms));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.preferredCompressionAlgorithms));
|
||||
arr.push(write_sub_packet(sub.preferred_compression_algorithms, bytes));
|
||||
}
|
||||
if (this.keyServerPreferences !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.keyServerPreferences));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.keyServerPreferences));
|
||||
arr.push(write_sub_packet(sub.key_server_preferences, bytes));
|
||||
}
|
||||
if (this.preferredKeyServer !== null) {
|
||||
arr.push(write_sub_packet(sub.preferred_key_server, util.str_to_Uint8Array(this.preferredKeyServer)));
|
||||
arr.push(write_sub_packet(sub.preferred_key_server, util.strToUint8Array(this.preferredKeyServer)));
|
||||
}
|
||||
if (this.isPrimaryUserID !== null) {
|
||||
arr.push(write_sub_packet(sub.primary_user_id, new Uint8Array([this.isPrimaryUserID ? 1 : 0])));
|
||||
}
|
||||
if (this.policyURI !== null) {
|
||||
arr.push(write_sub_packet(sub.policy_uri, util.str_to_Uint8Array(this.policyURI)));
|
||||
arr.push(write_sub_packet(sub.policy_uri, util.strToUint8Array(this.policyURI)));
|
||||
}
|
||||
if (this.keyFlags !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.keyFlags));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.keyFlags));
|
||||
arr.push(write_sub_packet(sub.key_flags, bytes));
|
||||
}
|
||||
if (this.signersUserId !== null) {
|
||||
arr.push(write_sub_packet(sub.signers_user_id, util.str_to_Uint8Array(this.signersUserId)));
|
||||
arr.push(write_sub_packet(sub.signers_user_id, util.strToUint8Array(this.signersUserId)));
|
||||
}
|
||||
if (this.reasonForRevocationFlag !== null) {
|
||||
bytes = util.str_to_Uint8Array(String.fromCharCode(this.reasonForRevocationFlag) + this.reasonForRevocationString);
|
||||
bytes = util.strToUint8Array(String.fromCharCode(this.reasonForRevocationFlag) + this.reasonForRevocationString);
|
||||
arr.push(write_sub_packet(sub.reason_for_revocation, bytes));
|
||||
}
|
||||
if (this.features !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.features));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.features));
|
||||
arr.push(write_sub_packet(sub.features, bytes));
|
||||
}
|
||||
if (this.signatureTargetPublicKeyAlgorithm !== null) {
|
||||
bytes = [new Uint8Array([this.signatureTargetPublicKeyAlgorithm, this.signatureTargetHashAlgorithm])];
|
||||
bytes.push(util.str_to_Uint8Array(this.signatureTargetHash));
|
||||
bytes.push(util.strToUint8Array(this.signatureTargetHash));
|
||||
bytes = util.concat(bytes);
|
||||
arr.push(write_sub_packet(sub.signature_target, bytes));
|
||||
}
|
||||
if (this.preferredAeadAlgorithms !== null) {
|
||||
bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.preferredAeadAlgorithms));
|
||||
bytes = util.strToUint8Array(util.uint8ArrayToStr(this.preferredAeadAlgorithms));
|
||||
arr.push(write_sub_packet(sub.preferred_aead_algorithms, bytes));
|
||||
}
|
||||
|
||||
|
|
@ -447,13 +447,13 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
const n = util.readNumber(bytes.subarray(mypos, mypos + 2));
|
||||
mypos += 2;
|
||||
|
||||
const name = util.Uint8Array_to_str(bytes.subarray(mypos, mypos + m));
|
||||
const name = util.uint8ArrayToStr(bytes.subarray(mypos, mypos + m));
|
||||
const value = bytes.subarray(mypos + m, mypos + m + n);
|
||||
|
||||
this.rawNotations.push({ name, humanReadable, value });
|
||||
|
||||
if (humanReadable) {
|
||||
this.notations[name] = util.Uint8Array_to_str(value);
|
||||
this.notations[name] = util.uint8ArrayToStr(value);
|
||||
}
|
||||
|
||||
if (critical && (config.knownNotations.indexOf(name) === -1)) {
|
||||
|
|
@ -475,7 +475,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
break;
|
||||
case 24:
|
||||
// Preferred Key Server
|
||||
this.preferredKeyServer = util.Uint8Array_to_str(bytes.subarray(mypos, bytes.length));
|
||||
this.preferredKeyServer = util.uint8ArrayToStr(bytes.subarray(mypos, bytes.length));
|
||||
break;
|
||||
case 25:
|
||||
// Primary User ID
|
||||
|
|
@ -483,7 +483,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
break;
|
||||
case 26:
|
||||
// Policy URI
|
||||
this.policyURI = util.Uint8Array_to_str(bytes.subarray(mypos, bytes.length));
|
||||
this.policyURI = util.uint8ArrayToStr(bytes.subarray(mypos, bytes.length));
|
||||
break;
|
||||
case 27:
|
||||
// Key Flags
|
||||
|
|
@ -491,12 +491,12 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
break;
|
||||
case 28:
|
||||
// Signer's User ID
|
||||
this.signersUserId = util.Uint8Array_to_str(bytes.subarray(mypos, bytes.length));
|
||||
this.signersUserId = util.uint8ArrayToStr(bytes.subarray(mypos, bytes.length));
|
||||
break;
|
||||
case 29:
|
||||
// Reason for Revocation
|
||||
this.reasonForRevocationFlag = bytes[mypos++];
|
||||
this.reasonForRevocationString = util.Uint8Array_to_str(bytes.subarray(mypos, bytes.length));
|
||||
this.reasonForRevocationString = util.uint8ArrayToStr(bytes.subarray(mypos, bytes.length));
|
||||
break;
|
||||
case 30:
|
||||
// Features
|
||||
|
|
@ -510,7 +510,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
|
||||
const len = crypto.getHashByteLength(this.signatureTargetHashAlgorithm);
|
||||
|
||||
this.signatureTargetHash = util.Uint8Array_to_str(bytes.subarray(mypos, mypos + len));
|
||||
this.signatureTargetHash = util.uint8ArrayToStr(bytes.subarray(mypos, mypos + len));
|
||||
break;
|
||||
}
|
||||
case 32:
|
||||
|
|
@ -537,7 +537,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
|
|||
if (critical) {
|
||||
throw err;
|
||||
} else {
|
||||
util.print_debug(err);
|
||||
util.printDebug(err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -569,7 +569,7 @@ Signature.prototype.toSign = function (type, data) {
|
|||
switch (type) {
|
||||
case t.binary:
|
||||
if (data.text !== null) {
|
||||
return util.encode_utf8(data.getText(true));
|
||||
return util.encodeUtf8(data.getText(true));
|
||||
}
|
||||
return data.getBytes(true);
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ UserAttribute.prototype.read = function(bytes) {
|
|||
const len = packet.readSimpleLength(bytes.subarray(i, bytes.length));
|
||||
i += len.offset;
|
||||
|
||||
this.attributes.push(util.Uint8Array_to_str(bytes.subarray(i, i + len.len)));
|
||||
this.attributes.push(util.uint8ArrayToStr(bytes.subarray(i, i + len.len)));
|
||||
i += len.len;
|
||||
}
|
||||
};
|
||||
|
|
@ -72,7 +72,7 @@ UserAttribute.prototype.write = function() {
|
|||
const arr = [];
|
||||
for (let i = 0; i < this.attributes.length; i++) {
|
||||
arr.push(packet.writeSimpleLength(this.attributes[i].length));
|
||||
arr.push(util.str_to_Uint8Array(this.attributes[i]));
|
||||
arr.push(util.strToUint8Array(this.attributes[i]));
|
||||
}
|
||||
return util.concatUint8Array(arr);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ function Userid() {
|
|||
* @param {Uint8Array} input payload of a tag 13 packet
|
||||
*/
|
||||
Userid.prototype.read = function (bytes) {
|
||||
this.parse(util.decode_utf8(bytes));
|
||||
this.parse(util.decodeUtf8(bytes));
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -70,7 +70,7 @@ Userid.prototype.parse = function (userid) {
|
|||
* @returns {Uint8Array} binary representation
|
||||
*/
|
||||
Userid.prototype.write = function () {
|
||||
return util.encode_utf8(this.userid);
|
||||
return util.encodeUtf8(this.userid);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ function ECDHSymmetricKey(data) {
|
|||
if (typeof data === 'undefined') {
|
||||
data = new Uint8Array([]);
|
||||
} else if (util.isString(data)) {
|
||||
data = util.str_to_Uint8Array(data);
|
||||
data = util.strToUint8Array(data);
|
||||
} else {
|
||||
data = new Uint8Array(data);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ function Keyid() {
|
|||
* @param {Uint8Array} input Input to read the key id from
|
||||
*/
|
||||
Keyid.prototype.read = function(bytes) {
|
||||
this.bytes = util.Uint8Array_to_str(bytes.subarray(0, 8));
|
||||
this.bytes = util.uint8ArrayToStr(bytes.subarray(0, 8));
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -49,7 +49,7 @@ Keyid.prototype.read = function(bytes) {
|
|||
* @returns {Uint8Array} Key ID as a Uint8Array
|
||||
*/
|
||||
Keyid.prototype.write = function() {
|
||||
return util.str_to_Uint8Array(this.bytes);
|
||||
return util.strToUint8Array(this.bytes);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -57,7 +57,7 @@ Keyid.prototype.write = function() {
|
|||
* @returns {String} Key ID as a hexadecimal string
|
||||
*/
|
||||
Keyid.prototype.toHex = function() {
|
||||
return util.str_to_hex(this.bytes);
|
||||
return util.strToHex(this.bytes);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -91,7 +91,7 @@ Keyid.mapToHex = function (keyId) {
|
|||
|
||||
Keyid.fromId = function (hex) {
|
||||
const keyid = new Keyid();
|
||||
keyid.read(util.hex_to_Uint8Array(hex));
|
||||
keyid.read(util.hexToUint8Array(hex));
|
||||
return keyid;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ function MPI(data) {
|
|||
*/
|
||||
MPI.prototype.read = function (bytes, endian = 'be') {
|
||||
if (util.isString(bytes)) {
|
||||
bytes = util.str_to_Uint8Array(bytes);
|
||||
bytes = util.strToUint8Array(bytes);
|
||||
}
|
||||
|
||||
const bits = (bytes[0] << 8) | bytes[1];
|
||||
|
|
@ -82,7 +82,7 @@ MPI.prototype.read = function (bytes, endian = 'be') {
|
|||
* @returns {Uint8Aray} mpi Byte representation
|
||||
*/
|
||||
MPI.prototype.write = function (endian, length) {
|
||||
return util.Uint8Array_to_MPI(this.toUint8Array(endian, length));
|
||||
return util.uint8ArrayToMpi(this.toUint8Array(endian, length));
|
||||
};
|
||||
|
||||
MPI.prototype.bitLength = function () {
|
||||
|
|
@ -116,11 +116,11 @@ MPI.prototype.fromUint8Array = function (bytes, endian = 'be') {
|
|||
};
|
||||
|
||||
MPI.prototype.toString = function () {
|
||||
return util.Uint8Array_to_str(this.toUint8Array());
|
||||
return util.uint8ArrayToStr(this.toUint8Array());
|
||||
};
|
||||
|
||||
MPI.prototype.fromString = function (str, endian = 'be') {
|
||||
this.fromUint8Array(util.str_to_Uint8Array(str), endian);
|
||||
this.fromUint8Array(util.strToUint8Array(str), endian);
|
||||
};
|
||||
|
||||
MPI.prototype.toBN = function () {
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ OID.prototype.write = function () {
|
|||
* @returns {string} String with the hex value of the OID
|
||||
*/
|
||||
OID.prototype.toHex = function() {
|
||||
return util.Uint8Array_to_hex(this.oid);
|
||||
return util.uint8ArrayToHex(this.oid);
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ S2K.prototype.read = function (bytes) {
|
|||
break;
|
||||
|
||||
case 'gnu':
|
||||
if (util.Uint8Array_to_str(bytes.subarray(i, i + 3)) === "GNU") {
|
||||
if (util.uint8ArrayToStr(bytes.subarray(i, i + 3)) === "GNU") {
|
||||
i += 3; // GNU
|
||||
const gnuExtType = 1000 + bytes[i++];
|
||||
if (gnuExtType === 1001) {
|
||||
|
|
@ -118,7 +118,7 @@ S2K.prototype.read = function (bytes) {
|
|||
*/
|
||||
S2K.prototype.write = function () {
|
||||
if (this.type === 'gnu-dummy') {
|
||||
return new Uint8Array([101, 0, ...util.str_to_Uint8Array('GNU'), 1]);
|
||||
return new Uint8Array([101, 0, ...util.strToUint8Array('GNU'), 1]);
|
||||
}
|
||||
|
||||
const arr = [new Uint8Array([enums.write(enums.s2k, this.type), enums.write(enums.hash, this.algorithm)])];
|
||||
|
|
@ -150,7 +150,7 @@ S2K.prototype.write = function () {
|
|||
* hashAlgorithm hash length
|
||||
*/
|
||||
S2K.prototype.produce_key = async function (passphrase, numBytes) {
|
||||
passphrase = util.encode_utf8(passphrase);
|
||||
passphrase = util.encodeUtf8(passphrase);
|
||||
const algorithm = enums.write(enums.hash, this.algorithm);
|
||||
|
||||
const arr = [];
|
||||
|
|
|
|||
44
src/util.js
44
src/util.js
|
|
@ -123,7 +123,7 @@ export default {
|
|||
* @param {String} str String to convert
|
||||
* @returns {String} String containing the hexadecimal values
|
||||
*/
|
||||
str_to_hex: function (str) {
|
||||
strToHex: function (str) {
|
||||
if (str === null) {
|
||||
return "";
|
||||
}
|
||||
|
|
@ -146,7 +146,7 @@ export default {
|
|||
* @param {String} str Hex string to convert
|
||||
* @returns {String}
|
||||
*/
|
||||
hex_to_str: function (hex) {
|
||||
hexToStr: function (hex) {
|
||||
let str = '';
|
||||
for (let i = 0; i < hex.length; i += 2) {
|
||||
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
|
||||
|
|
@ -162,7 +162,7 @@ export default {
|
|||
* @param {Uint8Array} bin An array of 8-bit integers to convert
|
||||
* @returns {Uint8Array} MPI-formatted Uint8Array
|
||||
*/
|
||||
Uint8Array_to_MPI: function (bin) {
|
||||
uint8ArrayToMpi: function (bin) {
|
||||
const size = (bin.length - 1) * 8 + util.nbits(bin[0]);
|
||||
const prefix = Uint8Array.from([(size & 0xFF00) >> 8, size & 0xFF]);
|
||||
return util.concatUint8Array([prefix, bin]);
|
||||
|
|
@ -175,7 +175,7 @@ export default {
|
|||
* @param {String} base64 Base-64 encoded string to convert
|
||||
* @returns {Uint8Array} An array of 8-bit integers
|
||||
*/
|
||||
b64_to_Uint8Array: function (base64) {
|
||||
b64ToUint8Array: function (base64) {
|
||||
return b64.decode(base64.replace(/-/g, '+').replace(/_/g, '/'));
|
||||
},
|
||||
|
||||
|
|
@ -185,7 +185,7 @@ export default {
|
|||
* @param {bool} url If true, output is URL-safe
|
||||
* @returns {String} Base-64 encoded string
|
||||
*/
|
||||
Uint8Array_to_b64: function (bytes, url) {
|
||||
uint8ArrayToB64: function (bytes, url) {
|
||||
let encoded = b64.encode(bytes).replace(/[\r\n]/g, '');
|
||||
if (url) {
|
||||
encoded = encoded.replace(/[+]/g, '-').replace(/[/]/g, '_').replace(/[=]/g, '');
|
||||
|
|
@ -198,7 +198,7 @@ export default {
|
|||
* @param {String} hex A hex string to convert
|
||||
* @returns {Uint8Array} An array of 8-bit integers
|
||||
*/
|
||||
hex_to_Uint8Array: function (hex) {
|
||||
hexToUint8Array: function (hex) {
|
||||
const result = new Uint8Array(hex.length >> 1);
|
||||
for (let k = 0; k < hex.length >> 1; k++) {
|
||||
result[k] = parseInt(hex.substr(k << 1, 2), 16);
|
||||
|
|
@ -211,7 +211,7 @@ export default {
|
|||
* @param {Uint8Array} bytes Array of 8-bit integers to convert
|
||||
* @returns {String} Hexadecimal representation of the array
|
||||
*/
|
||||
Uint8Array_to_hex: function (bytes) {
|
||||
uint8ArrayToHex: function (bytes) {
|
||||
const r = [];
|
||||
const e = bytes.length;
|
||||
let c = 0;
|
||||
|
|
@ -231,10 +231,10 @@ export default {
|
|||
* @param {String} str String to convert
|
||||
* @returns {Uint8Array} An array of 8-bit integers
|
||||
*/
|
||||
str_to_Uint8Array: function (str) {
|
||||
strToUint8Array: function (str) {
|
||||
return stream.transform(str, str => {
|
||||
if (!util.isString(str)) {
|
||||
throw new Error('str_to_Uint8Array: Data must be in the form of a string');
|
||||
throw new Error('strToUint8Array: Data must be in the form of a string');
|
||||
}
|
||||
|
||||
const result = new Uint8Array(str.length);
|
||||
|
|
@ -250,7 +250,7 @@ export default {
|
|||
* @param {Uint8Array} bytes An array of 8-bit integers to convert
|
||||
* @returns {String} String representation of the array
|
||||
*/
|
||||
Uint8Array_to_str: function (bytes) {
|
||||
uint8ArrayToStr: function (bytes) {
|
||||
bytes = new Uint8Array(bytes);
|
||||
const result = [];
|
||||
const bs = 1 << 14;
|
||||
|
|
@ -267,7 +267,7 @@ export default {
|
|||
* @param {String|ReadableStream} str The string to convert
|
||||
* @returns {Uint8Array|ReadableStream} A valid squence of utf8 bytes
|
||||
*/
|
||||
encode_utf8: function (str) {
|
||||
encodeUtf8: function (str) {
|
||||
const encoder = new TextEncoder('utf-8');
|
||||
// eslint-disable-next-line no-inner-declarations
|
||||
function process(value, lastChunk = false) {
|
||||
|
|
@ -281,7 +281,7 @@ export default {
|
|||
* @param {Uint8Array|ReadableStream} utf8 A valid squence of utf8 bytes
|
||||
* @returns {String|ReadableStream} A native javascript string
|
||||
*/
|
||||
decode_utf8: function (utf8) {
|
||||
decodeUtf8: function (utf8) {
|
||||
const decoder = new TextDecoder('utf-8');
|
||||
// eslint-disable-next-line no-inner-declarations
|
||||
function process(value, lastChunk = false) {
|
||||
|
|
@ -334,7 +334,7 @@ export default {
|
|||
* @param {Uint8Array} Uint8Array to create a sum of
|
||||
* @returns {Uint8Array} 2 bytes containing the sum of all charcodes % 65535
|
||||
*/
|
||||
write_checksum: function (text) {
|
||||
writeChecksum: function (text) {
|
||||
let s = 0;
|
||||
for (let i = 0; i < text.length; i++) {
|
||||
s = (s + text[i]) & 0xFFFF;
|
||||
|
|
@ -348,7 +348,7 @@ export default {
|
|||
* @link module:config/config.debug is set to true.
|
||||
* @param {String} str String of the debug message
|
||||
*/
|
||||
print_debug: function (str) {
|
||||
printDebug: function (str) {
|
||||
if (config.debug) {
|
||||
console.log(str);
|
||||
}
|
||||
|
|
@ -358,12 +358,12 @@ export default {
|
|||
* Helper function to print a debug message. Debug
|
||||
* messages are only printed if
|
||||
* @link module:config/config.debug is set to true.
|
||||
* Different than print_debug because will call Uint8Array_to_hex iff necessary.
|
||||
* Different than print_debug because will call Uint8ArrayToHex iff necessary.
|
||||
* @param {String} str String of the debug message
|
||||
*/
|
||||
print_debug_hexarray_dump: function (str, arrToHex) {
|
||||
printDebugHexArrayDump: function (str, arrToHex) {
|
||||
if (config.debug) {
|
||||
str += ': ' + util.Uint8Array_to_hex(arrToHex);
|
||||
str += ': ' + util.uint8ArrayToHex(arrToHex);
|
||||
console.log(str);
|
||||
}
|
||||
},
|
||||
|
|
@ -372,12 +372,12 @@ export default {
|
|||
* Helper function to print a debug message. Debug
|
||||
* messages are only printed if
|
||||
* @link module:config/config.debug is set to true.
|
||||
* Different than print_debug because will call str_to_hex iff necessary.
|
||||
* Different than print_debug because will call strToHex iff necessary.
|
||||
* @param {String} str String of the debug message
|
||||
*/
|
||||
print_debug_hexstr_dump: function (str, strToHex) {
|
||||
printDebugHexStrDump: function (str, strToHex) {
|
||||
if (config.debug) {
|
||||
str += util.str_to_hex(strToHex);
|
||||
str += util.strToHex(strToHex);
|
||||
console.log(str);
|
||||
}
|
||||
},
|
||||
|
|
@ -388,7 +388,7 @@ export default {
|
|||
* @link module:config/config.debug is set to true.
|
||||
* @param {String} str String of the debug message
|
||||
*/
|
||||
print_debug_error: function (error) {
|
||||
printDebugError: function (error) {
|
||||
if (config.debug) {
|
||||
console.error(error);
|
||||
}
|
||||
|
|
@ -400,7 +400,7 @@ export default {
|
|||
* @param {ReadableStream|Uint8array|String} input Stream to print
|
||||
* @param {Function} concat Function to concatenate chunks of the stream (defaults to util.concat).
|
||||
*/
|
||||
print_entire_stream: function (str, input, concat) {
|
||||
printEntireStream: function (str, input, concat) {
|
||||
stream.readToEnd(stream.clone(input), concat).then(result => {
|
||||
console.log(str + ': ', result);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ WKD.prototype.lookup = async function(options) {
|
|||
}
|
||||
|
||||
const [, localPart, domain] = /(.*)@(.*)/.exec(options.email);
|
||||
const localEncoded = util.encodeZBase32(await crypto.hash.sha1(util.str_to_Uint8Array(localPart.toLowerCase())));
|
||||
const localEncoded = util.encodeZBase32(await crypto.hash.sha1(util.strToUint8Array(localPart.toLowerCase())));
|
||||
|
||||
const urlAdvanced = `https://openpgpkey.${domain}/.well-known/openpgpkey/${domain}/hu/${localEncoded}`;
|
||||
const urlDirect = `https://${domain}/.well-known/openpgpkey/hu/${localEncoded}`;
|
||||
|
|
|
|||
|
|
@ -44,13 +44,13 @@ describe('AES Key Wrap and Unwrap', function () {
|
|||
|
||||
test_vectors.forEach(function(test) {
|
||||
it(test[0], function(done) {
|
||||
const kek = openpgp.util.hex_to_Uint8Array(test[1]);
|
||||
const kek = openpgp.util.hexToUint8Array(test[1]);
|
||||
const input = test[2].replace(/\s/g, "");
|
||||
const input_bin = openpgp.util.hex_to_str(input);
|
||||
const input_bin = openpgp.util.hexToStr(input);
|
||||
const output = test[3].replace(/\s/g, "");
|
||||
const output_bin = openpgp.util.hex_to_str(output);
|
||||
expect(openpgp.util.Uint8Array_to_hex(openpgp.crypto.aes_kw.wrap(kek, input_bin)).toUpperCase()).to.equal(output);
|
||||
expect(openpgp.util.Uint8Array_to_hex(openpgp.crypto.aes_kw.unwrap(kek, output_bin)).toUpperCase()).to.equal(input);
|
||||
const output_bin = openpgp.util.hexToStr(output);
|
||||
expect(openpgp.util.uint8ArrayToHex(openpgp.crypto.aes_kw.wrap(kek, input_bin)).toUpperCase()).to.equal(output);
|
||||
expect(openpgp.util.uint8ArrayToHex(openpgp.crypto.aes_kw.unwrap(kek, output_bin)).toUpperCase()).to.equal(input);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@ const { expect } = chai;
|
|||
|
||||
it('Blowfish cipher test with test vectors from https://www.schneier.com/code/vectors.txt', function(done) {
|
||||
function test_bf(input, key, output) {
|
||||
const blowfish = new openpgp.crypto.cipher.blowfish(util.Uint8Array_to_str(key));
|
||||
const result = util.Uint8Array_to_str(blowfish.encrypt(input));
|
||||
const blowfish = new openpgp.crypto.cipher.blowfish(util.uint8ArrayToStr(key));
|
||||
const result = util.uint8ArrayToStr(blowfish.encrypt(input));
|
||||
|
||||
return (util.str_to_hex(result) === util.str_to_hex(util.Uint8Array_to_str(output)));
|
||||
return (util.strToHex(result) === util.strToHex(util.uint8ArrayToStr(output)));
|
||||
}
|
||||
|
||||
const testvectors = [[[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],[0x4E,0xF9,0x97,0x45,0x61,0x98,0xDD,0x78]],
|
||||
|
|
@ -50,9 +50,9 @@ it('Blowfish cipher test with test vectors from https://www.schneier.com/code/ve
|
|||
|
||||
for (let i = 0; i < testvectors.length; i++) {
|
||||
const res = test_bf(testvectors[i][1],testvectors[i][0],testvectors[i][2]);
|
||||
expect(res, 'vector ' + i + '" with block ' + util.Uint8Array_to_hex(testvectors[i][0]) +
|
||||
' and key ' + util.Uint8Array_to_hex(testvectors[i][1]) +
|
||||
' should be ' + util.Uint8Array_to_hex(testvectors[i][2]), false);
|
||||
expect(res, 'vector ' + i + '" with block ' + util.uint8ArrayToHex(testvectors[i][0]) +
|
||||
' and key ' + util.uint8ArrayToHex(testvectors[i][1]) +
|
||||
' should be ' + util.uint8ArrayToHex(testvectors[i][2]), false);
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -8,18 +8,18 @@ const { expect } = chai;
|
|||
it('CAST-128 cipher test with test vectors from RFC2144', function (done) {
|
||||
function test_cast(input, key, output) {
|
||||
const cast5 = new openpgp.crypto.cipher.cast5(key);
|
||||
const result = util.Uint8Array_to_str(cast5.encrypt(input));
|
||||
const result = util.uint8ArrayToStr(cast5.encrypt(input));
|
||||
|
||||
return util.str_to_hex(result) === util.str_to_hex(util.Uint8Array_to_str(output));
|
||||
return util.strToHex(result) === util.strToHex(util.uint8ArrayToStr(output));
|
||||
}
|
||||
|
||||
const testvectors = [[[0x01,0x23,0x45,0x67,0x12,0x34,0x56,0x78,0x23,0x45,0x67,0x89,0x34,0x56,0x78,0x9A],[0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF],[0x23,0x8B,0x4F,0xE5,0x84,0x7E,0x44,0xB2]]];
|
||||
|
||||
for (let i = 0; i < testvectors.length; i++) {
|
||||
const res = test_cast(testvectors[i][1],testvectors[i][0],testvectors[i][2]);
|
||||
expect(res, 'vector with block ' + util.Uint8Array_to_hex(testvectors[i][0]) +
|
||||
' and key ' + util.Uint8Array_to_hex(testvectors[i][1]) +
|
||||
' should be ' + util.Uint8Array_to_hex(testvectors[i][2])).to.be.true;
|
||||
expect(res, 'vector with block ' + util.uint8ArrayToHex(testvectors[i][0]) +
|
||||
' and key ' + util.uint8ArrayToHex(testvectors[i][1]) +
|
||||
' should be ' + util.uint8ArrayToHex(testvectors[i][2])).to.be.true;
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -77,12 +77,12 @@ describe('TripleDES (EDE) cipher test with test vectors from NIST SP 800-20', fu
|
|||
for (let i = 0; i < testvectors.length; i++) {
|
||||
const des = new openpgp.crypto.cipher.tripledes(key);
|
||||
|
||||
const encr = util.Uint8Array_to_str(des.encrypt(testvectors[i][0], key));
|
||||
const encr = util.uint8ArrayToStr(des.encrypt(testvectors[i][0], key));
|
||||
|
||||
expect(encr, 'vector with block ' + util.Uint8Array_to_hex(testvectors[i][0]) +
|
||||
' and key ' + util.str_to_hex(util.Uint8Array_to_str(key)) +
|
||||
' should be ' + util.Uint8Array_to_hex(testvectors[i][1]) +
|
||||
' != ' + util.Uint8Array_to_hex(encr)).to.be.equal(util.Uint8Array_to_str(testvectors[i][1]));
|
||||
expect(encr, 'vector with block ' + util.uint8ArrayToHex(testvectors[i][0]) +
|
||||
' and key ' + util.strToHex(util.uint8ArrayToStr(key)) +
|
||||
' should be ' + util.uint8ArrayToHex(testvectors[i][1]) +
|
||||
' != ' + util.uint8ArrayToHex(encr)).to.be.equal(util.uint8ArrayToStr(testvectors[i][1]));
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
|
@ -124,18 +124,18 @@ describe('TripleDES (EDE) cipher test with test vectors from NIST SP 800-20', fu
|
|||
const encrypted = des.encrypt(thisVectorSet[i][0], padding);
|
||||
const decrypted = des.decrypt(encrypted, padding);
|
||||
|
||||
expect(util.Uint8Array_to_str(encrypted), 'vector with block [' + util.Uint8Array_to_hex(thisVectorSet[i][0]) +
|
||||
'] and key [' + util.str_to_hex(util.Uint8Array_to_str(key)) +
|
||||
expect(util.uint8ArrayToStr(encrypted), 'vector with block [' + util.uint8ArrayToHex(thisVectorSet[i][0]) +
|
||||
'] and key [' + util.strToHex(util.uint8ArrayToStr(key)) +
|
||||
'] and padding [' + padding +
|
||||
'] should be ' + util.Uint8Array_to_hex(thisVectorSet[i][1]) +
|
||||
' - Actually [' + util.Uint8Array_to_hex(encrypted) +
|
||||
']').to.equal(util.Uint8Array_to_str(thisVectorSet[i][1]));
|
||||
expect(util.Uint8Array_to_str(decrypted), 'vector with block [' + util.Uint8Array_to_hex(thisVectorSet[i][0]) +
|
||||
'] and key [' + util.str_to_hex(util.Uint8Array_to_str(key)) +
|
||||
'] should be ' + util.uint8ArrayToHex(thisVectorSet[i][1]) +
|
||||
' - Actually [' + util.uint8ArrayToHex(encrypted) +
|
||||
']').to.equal(util.uint8ArrayToStr(thisVectorSet[i][1]));
|
||||
expect(util.uint8ArrayToStr(decrypted), 'vector with block [' + util.uint8ArrayToHex(thisVectorSet[i][0]) +
|
||||
'] and key [' + util.strToHex(util.uint8ArrayToStr(key)) +
|
||||
'] and padding [' + padding +
|
||||
'] should be ' + util.Uint8Array_to_hex(thisVectorSet[i][0]) +
|
||||
' - Actually [' + util.Uint8Array_to_hex(decrypted) +
|
||||
']').to.equal(util.Uint8Array_to_str(thisVectorSet[i][0]));
|
||||
'] should be ' + util.uint8ArrayToHex(thisVectorSet[i][0]) +
|
||||
' - Actually [' + util.uint8ArrayToHex(decrypted) +
|
||||
']').to.equal(util.uint8ArrayToStr(thisVectorSet[i][0]));
|
||||
}
|
||||
}
|
||||
done();
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ const { expect } = chai;
|
|||
|
||||
it('Twofish with test vectors from https://www.schneier.com/code/ecb_ival.txt', function(done) {
|
||||
function tfencrypt(block, key) {
|
||||
const tf = new openpgp.crypto.cipher.twofish(util.str_to_Uint8Array(key));
|
||||
const tf = new openpgp.crypto.cipher.twofish(util.strToUint8Array(key));
|
||||
|
||||
return tf.encrypt(block);
|
||||
}
|
||||
|
|
@ -36,36 +36,36 @@ it('Twofish with test vectors from https://www.schneier.com/code/ecb_ival.txt',
|
|||
|
||||
if (i === 0) {
|
||||
blk = start_short;
|
||||
key = util.Uint8Array_to_str(start);
|
||||
key = util.uint8ArrayToStr(start);
|
||||
ct = testvectors[0];
|
||||
res = util.Uint8Array_to_str(tfencrypt(blk,key));
|
||||
exp = util.Uint8Array_to_str(ct);
|
||||
res = util.uint8ArrayToStr(tfencrypt(blk,key));
|
||||
exp = util.uint8ArrayToStr(ct);
|
||||
} else if (i === 1) {
|
||||
blk = testvectors[0];
|
||||
key = util.Uint8Array_to_str(start);
|
||||
key = util.uint8ArrayToStr(start);
|
||||
ct = testvectors[1];
|
||||
res = util.Uint8Array_to_str(tfencrypt(blk,key));
|
||||
exp = util.Uint8Array_to_str(ct);
|
||||
res = util.uint8ArrayToStr(tfencrypt(blk,key));
|
||||
exp = util.uint8ArrayToStr(ct);
|
||||
} else if (i === 2) {
|
||||
blk = testvectors[i - 1];
|
||||
key = util.Uint8Array_to_str(testvectors[i - 2].concat(start_short));
|
||||
key = util.uint8ArrayToStr(testvectors[i - 2].concat(start_short));
|
||||
ct = testvectors[i];
|
||||
res = util.Uint8Array_to_str(tfencrypt(blk,key));
|
||||
exp = util.Uint8Array_to_str(ct);
|
||||
res = util.uint8ArrayToStr(tfencrypt(blk,key));
|
||||
exp = util.uint8ArrayToStr(ct);
|
||||
} else if (i < 10 || i > 46) {
|
||||
blk = testvectors[i - 1];
|
||||
key = util.Uint8Array_to_str(testvectors[i - 2].concat(testvectors[i - 3]));
|
||||
key = util.uint8ArrayToStr(testvectors[i - 2].concat(testvectors[i - 3]));
|
||||
ct = testvectors[i];
|
||||
res = util.Uint8Array_to_str(tfencrypt(blk,key));
|
||||
exp = util.Uint8Array_to_str(ct);
|
||||
res = util.uint8ArrayToStr(tfencrypt(blk,key));
|
||||
exp = util.uint8ArrayToStr(ct);
|
||||
} else {
|
||||
testvectors[i] = tfencrypt(testvectors[i - 1],util.Uint8Array_to_str(testvectors[i - 2].concat(testvectors[i - 3])));
|
||||
testvectors[i] = tfencrypt(testvectors[i - 1],util.uint8ArrayToStr(testvectors[i - 2].concat(testvectors[i - 3])));
|
||||
continue;
|
||||
}
|
||||
expect(res, 'vector with block ' + util.Uint8Array_to_hex(blk) +
|
||||
' with key ' + util.str_to_hex(key) +
|
||||
' should be ' + util.Uint8Array_to_hex(ct) +
|
||||
' but is ' + util.Uint8Array_to_hex(tfencrypt(blk,key))).to.equal(exp);
|
||||
expect(res, 'vector with block ' + util.uint8ArrayToHex(blk) +
|
||||
' with key ' + util.strToHex(key) +
|
||||
' should be ' + util.uint8ArrayToHex(ct) +
|
||||
' but is ' + util.uint8ArrayToHex(tfencrypt(blk,key))).to.equal(exp);
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -231,7 +231,7 @@ describe('API functional testing', function() {
|
|||
ElgamalpubMPIs[i].read(ElgamalpubMPIstrs[i]);
|
||||
}
|
||||
|
||||
const data = util.str_to_Uint8Array("foobar");
|
||||
const data = util.strToUint8Array("foobar");
|
||||
|
||||
describe('Sign and verify', function () {
|
||||
it('RSA', async function () {
|
||||
|
|
@ -256,7 +256,7 @@ describe('API functional testing', function() {
|
|||
return crypto.signature.sign(
|
||||
17, 2, DSApubMPIs.concat(DSAsecMPIs), data, await crypto.hash.digest(2, data)
|
||||
).then(async DSAsignedData => {
|
||||
DSAsignedData = util.Uint8Array_to_str(DSAsignedData);
|
||||
DSAsignedData = util.uint8ArrayToStr(DSAsignedData);
|
||||
const DSAmsgMPIs = [];
|
||||
DSAmsgMPIs[0] = new openpgp.MPI();
|
||||
DSAmsgMPIs[1] = new openpgp.MPI();
|
||||
|
|
@ -281,8 +281,8 @@ describe('API functional testing', function() {
|
|||
await Promise.all(symmAlgos.map(async function(algo) {
|
||||
const symmKey = await crypto.generateSessionKey(algo);
|
||||
const IV = new Uint8Array(crypto.cipher[algo].blockSize);
|
||||
const symmencData = await crypto.cfb.encrypt(algo, symmKey, util.str_to_Uint8Array(plaintext), IV);
|
||||
const text = util.Uint8Array_to_str(await crypto.cfb.decrypt(algo, symmKey, symmencData, new Uint8Array(crypto.cipher[algo].blockSize)));
|
||||
const symmencData = await crypto.cfb.encrypt(algo, symmKey, util.strToUint8Array(plaintext), IV);
|
||||
const text = util.uint8ArrayToStr(await crypto.cfb.decrypt(algo, symmKey, symmencData, new Uint8Array(crypto.cipher[algo].blockSize)));
|
||||
expect(text).to.equal(plaintext);
|
||||
}));
|
||||
}
|
||||
|
|
@ -295,13 +295,13 @@ describe('API functional testing', function() {
|
|||
const iv = await crypto.random.getRandomBytes(crypto.gcm.ivLength);
|
||||
let modeInstance = await crypto.gcm(algo, key);
|
||||
|
||||
const ciphertext = await modeInstance.encrypt(util.str_to_Uint8Array(plaintext), iv);
|
||||
const ciphertext = await modeInstance.encrypt(util.strToUint8Array(plaintext), iv);
|
||||
|
||||
openpgp.config.useNative = nativeDecrypt;
|
||||
modeInstance = await crypto.gcm(algo, key);
|
||||
|
||||
const decrypted = await modeInstance.decrypt(util.str_to_Uint8Array(util.Uint8Array_to_str(ciphertext)), iv);
|
||||
const decryptedStr = util.Uint8Array_to_str(decrypted);
|
||||
const decrypted = await modeInstance.decrypt(util.strToUint8Array(util.uint8ArrayToStr(ciphertext)), iv);
|
||||
const decryptedStr = util.uint8ArrayToStr(decrypted);
|
||||
expect(decryptedStr).to.equal(plaintext);
|
||||
});
|
||||
}
|
||||
|
|
@ -355,26 +355,26 @@ describe('API functional testing', function() {
|
|||
});
|
||||
|
||||
it('Asymmetric using RSA with eme_pkcs1 padding', function () {
|
||||
const symmKey = util.Uint8Array_to_str(crypto.generateSessionKey('aes256'));
|
||||
const symmKey = util.uint8ArrayToStr(crypto.generateSessionKey('aes256'));
|
||||
crypto.publicKeyEncrypt(1, RSApubMPIs, symmKey).then(RSAEncryptedData => {
|
||||
return crypto.publicKeyDecrypt(
|
||||
1, RSApubMPIs.concat(RSAsecMPIs), RSAEncryptedData
|
||||
).then(data => {
|
||||
data = new openpgp.MPI(data).write();
|
||||
data = util.Uint8Array_to_str(data.subarray(2, data.length));
|
||||
data = util.uint8ArrayToStr(data.subarray(2, data.length));
|
||||
expect(data).to.equal(symmKey);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('Asymmetric using Elgamal with eme_pkcs1 padding', function () {
|
||||
const symmKey = util.Uint8Array_to_str(crypto.generateSessionKey('aes256'));
|
||||
const symmKey = util.uint8ArrayToStr(crypto.generateSessionKey('aes256'));
|
||||
crypto.publicKeyEncrypt(16, ElgamalpubMPIs, symmKey).then(ElgamalEncryptedData => {
|
||||
return crypto.publicKeyDecrypt(
|
||||
16, ElgamalpubMPIs.concat(ElgamalsecMPIs), ElgamalEncryptedData
|
||||
).then(data => {
|
||||
data = new openpgp.MPI(data).write();
|
||||
data = util.Uint8Array_to_str(data.subarray(2, data.length));
|
||||
data = util.uint8ArrayToStr(data.subarray(2, data.length));
|
||||
expect(data).to.equal(symmKey);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -88,21 +88,21 @@ function testAESEAX() {
|
|||
const cipher = 'aes128';
|
||||
|
||||
await Promise.all(vectors.map(async vec => {
|
||||
const keyBytes = openpgp.util.hex_to_Uint8Array(vec.key);
|
||||
const msgBytes = openpgp.util.hex_to_Uint8Array(vec.msg);
|
||||
const nonceBytes = openpgp.util.hex_to_Uint8Array(vec.nonce);
|
||||
const headerBytes = openpgp.util.hex_to_Uint8Array(vec.header);
|
||||
const ctBytes = openpgp.util.hex_to_Uint8Array(vec.ct);
|
||||
const keyBytes = openpgp.util.hexToUint8Array(vec.key);
|
||||
const msgBytes = openpgp.util.hexToUint8Array(vec.msg);
|
||||
const nonceBytes = openpgp.util.hexToUint8Array(vec.nonce);
|
||||
const headerBytes = openpgp.util.hexToUint8Array(vec.header);
|
||||
const ctBytes = openpgp.util.hexToUint8Array(vec.ct);
|
||||
|
||||
const eax = await openpgp.crypto.eax(cipher, keyBytes);
|
||||
|
||||
// encryption test
|
||||
let ct = await eax.encrypt(msgBytes, nonceBytes, headerBytes);
|
||||
expect(openpgp.util.Uint8Array_to_hex(ct)).to.equal(vec.ct.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(ct)).to.equal(vec.ct.toLowerCase());
|
||||
|
||||
// decryption test with verification
|
||||
let pt = await eax.decrypt(ctBytes, nonceBytes, headerBytes);
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
|
||||
// tampering detection test
|
||||
ct = await eax.encrypt(msgBytes, nonceBytes, headerBytes);
|
||||
|
|
@ -113,12 +113,12 @@ function testAESEAX() {
|
|||
// testing without additional data
|
||||
ct = await eax.encrypt(msgBytes, nonceBytes, new Uint8Array());
|
||||
pt = await eax.decrypt(ct, nonceBytes, new Uint8Array());
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
|
||||
// testing with multiple additional data
|
||||
ct = await eax.encrypt(msgBytes, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
|
||||
pt = await eax.decrypt(ct, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.msg.toLowerCase());
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ describe('ECDH key exchange @lightweight', function () {
|
|||
const elliptic_curves = openpgp.crypto.publicKey.elliptic;
|
||||
const decrypt_message = function (oid, hash, cipher, priv, pub, ephemeral, data, fingerprint) {
|
||||
if (openpgp.util.isString(data)) {
|
||||
data = openpgp.util.str_to_Uint8Array(data);
|
||||
data = openpgp.util.strToUint8Array(data);
|
||||
} else {
|
||||
data = new Uint8Array(data);
|
||||
}
|
||||
|
|
@ -257,7 +257,7 @@ describe('ECDH key exchange @lightweight', function () {
|
|||
namedCurve: curve.web.web
|
||||
}, false, ["sign", "verify"]);
|
||||
} catch (err) {
|
||||
openpgp.util.print_debug_error(err);
|
||||
openpgp.util.printDebugError(err);
|
||||
return;
|
||||
}
|
||||
const ECDHE_VZ1 = await genPublicEphemeralKey(name, key_data[name].pub, fingerprint1);
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ describe('Elliptic Curve Cryptography @lightweight', function () {
|
|||
describe('ECDSA signature', function () {
|
||||
const verify_signature = async function (oid, hash, r, s, message, pub) {
|
||||
if (openpgp.util.isString(message)) {
|
||||
message = openpgp.util.str_to_Uint8Array(message);
|
||||
message = openpgp.util.strToUint8Array(message);
|
||||
} else if (!openpgp.util.isUint8Array(message)) {
|
||||
message = new Uint8Array(message);
|
||||
}
|
||||
|
|
@ -115,7 +115,7 @@ describe('Elliptic Curve Cryptography @lightweight', function () {
|
|||
};
|
||||
const verify_signature_elliptic = async function (oid, hash, r, s, message, pub) {
|
||||
if (openpgp.util.isString(message)) {
|
||||
message = openpgp.util.str_to_Uint8Array(message);
|
||||
message = openpgp.util.strToUint8Array(message);
|
||||
} else if (!openpgp.util.isUint8Array(message)) {
|
||||
message = new Uint8Array(message);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@ const md5 = openpgp.crypto.hash.md5;
|
|||
const { expect } = chai;
|
||||
|
||||
it('MD5 with test vectors from RFC 1321', async function() {
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array(''))), 'MD5("") = d41d8cd98f00b204e9800998ecf8427e')).to.equal('d41d8cd98f00b204e9800998ecf8427e');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('abc'))), 'MD5("a") = 0cc175b9c0f1b6a831c399e269772661')).to.equal('900150983cd24fb0d6963f7d28e17f72');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('message digest'))), 'MD5("message digest") = f96b697d7cb7938d525a2f31aaf161d0')).to.equal('f96b697d7cb7938d525a2f31aaf161d0');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('abcdefghijklmnopqrstuvwxyz'))), 'MD5("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b')).to.equal('c3fcd3d76192e4007dfb496cca67e13b');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'))), 'MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f')).to.equal('d174ab98d277d9f5a5611c2c9f419d9f');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await md5(util.str_to_Uint8Array('12345678901234567890123456789012345678901234567890123456789012345678901234567890'))), 'MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a')).to.equal('57edf4a22be3c955ac49da2e2107b67a');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array(''))), 'MD5("") = d41d8cd98f00b204e9800998ecf8427e')).to.equal('d41d8cd98f00b204e9800998ecf8427e');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array('abc'))), 'MD5("a") = 0cc175b9c0f1b6a831c399e269772661')).to.equal('900150983cd24fb0d6963f7d28e17f72');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array('message digest'))), 'MD5("message digest") = f96b697d7cb7938d525a2f31aaf161d0')).to.equal('f96b697d7cb7938d525a2f31aaf161d0');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array('abcdefghijklmnopqrstuvwxyz'))), 'MD5("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b')).to.equal('c3fcd3d76192e4007dfb496cca67e13b');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'))), 'MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f')).to.equal('d174ab98d277d9f5a5611c2c9f419d9f');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await md5(util.strToUint8Array('12345678901234567890123456789012345678901234567890123456789012345678901234567890'))), 'MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a')).to.equal('57edf4a22be3c955ac49da2e2107b67a');
|
||||
});
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ const rmdString = openpgp.crypto.hash.ripemd;
|
|||
const { expect } = chai;
|
||||
|
||||
it("RIPE-MD 160 bits with test vectors from https://homes.esat.kuleuven.be/~bosselae/ripemd160.html", async function() {
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array(''))), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31')).to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('a'))), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe')).to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('abc'))), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc')).to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await rmdString(util.str_to_Uint8Array('message digest'))), 'RMDstring("message digest") = 5d0689ef49d2fae572b881b123a85ffa21595f36')).to.equal('5d0689ef49d2fae572b881b123a85ffa21595f36');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await rmdString(util.strToUint8Array(''))), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31')).to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await rmdString(util.strToUint8Array('a'))), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe')).to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await rmdString(util.strToUint8Array('abc'))), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc')).to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await rmdString(util.strToUint8Array('message digest'))), 'RMDstring("message digest") = 5d0689ef49d2fae572b881b123a85ffa21595f36')).to.equal('5d0689ef49d2fae572b881b123a85ffa21595f36');
|
||||
});
|
||||
|
|
|
|||
|
|
@ -7,14 +7,14 @@ const { hash } = openpgp.crypto;
|
|||
const { expect } = chai;
|
||||
|
||||
it('SHA* with test vectors from NIST FIPS 180-2', async function() {
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha1(util.str_to_Uint8Array('abc'))), 'hash.sha1("abc") = a9993e364706816aba3e25717850c26c9cd0d89d')).to.equal('a9993e364706816aba3e25717850c26c9cd0d89d');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha1(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e441c3bd26ebaae4aa1f95129e5e54670f1')).to.equal('84983e441c3bd26ebaae4aa1f95129e5e54670f1');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha224(util.str_to_Uint8Array('abc'))), 'hash.sha224("abc") = 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7')).to.equal('23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha224(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525')).to.equal('75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha256(util.str_to_Uint8Array('abc'))), 'hash.sha256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')).to.equal('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha256(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1')).to.equal('248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha384(util.str_to_Uint8Array('abc'))), 'hash.sha384("abc") = cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7')).to.equal('cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha384(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b')).to.equal('3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha512(util.str_to_Uint8Array('abc'))), 'hash.sha512("abc") = ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f')).to.equal('ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f');
|
||||
expect(util.str_to_hex(util.Uint8Array_to_str(await hash.sha512(util.str_to_Uint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445')).to.equal('204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha1(util.strToUint8Array('abc'))), 'hash.sha1("abc") = a9993e364706816aba3e25717850c26c9cd0d89d')).to.equal('a9993e364706816aba3e25717850c26c9cd0d89d');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha1(util.strToUint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e441c3bd26ebaae4aa1f95129e5e54670f1')).to.equal('84983e441c3bd26ebaae4aa1f95129e5e54670f1');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha224(util.strToUint8Array('abc'))), 'hash.sha224("abc") = 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7')).to.equal('23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha224(util.strToUint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525')).to.equal('75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha256(util.strToUint8Array('abc'))), 'hash.sha256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')).to.equal('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha256(util.strToUint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1')).to.equal('248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha384(util.strToUint8Array('abc'))), 'hash.sha384("abc") = cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7')).to.equal('cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha384(util.strToUint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b')).to.equal('3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha512(util.strToUint8Array('abc'))), 'hash.sha512("abc") = ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f')).to.equal('ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f');
|
||||
expect(util.strToHex(util.uint8ArrayToStr(await hash.sha512(util.strToUint8Array('abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'))), 'hash.sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445')).to.equal('204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445');
|
||||
});
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ const expect = chai.expect;
|
|||
describe('Symmetric AES-OCB', function() {
|
||||
it('Passes all test vectors', async function() {
|
||||
const K = '000102030405060708090A0B0C0D0E0F';
|
||||
const keyBytes = openpgp.util.hex_to_Uint8Array(K);
|
||||
const keyBytes = openpgp.util.hexToUint8Array(K);
|
||||
|
||||
const vectors = [
|
||||
// From https://tools.ietf.org/html/rfc7253#appendix-A
|
||||
|
|
@ -117,20 +117,20 @@ describe('Symmetric AES-OCB', function() {
|
|||
const cipher = 'aes128';
|
||||
|
||||
await Promise.all(vectors.map(async vec => {
|
||||
const msgBytes = openpgp.util.hex_to_Uint8Array(vec.P);
|
||||
const nonceBytes = openpgp.util.hex_to_Uint8Array(vec.N);
|
||||
const headerBytes = openpgp.util.hex_to_Uint8Array(vec.A);
|
||||
const ctBytes = openpgp.util.hex_to_Uint8Array(vec.C);
|
||||
const msgBytes = openpgp.util.hexToUint8Array(vec.P);
|
||||
const nonceBytes = openpgp.util.hexToUint8Array(vec.N);
|
||||
const headerBytes = openpgp.util.hexToUint8Array(vec.A);
|
||||
const ctBytes = openpgp.util.hexToUint8Array(vec.C);
|
||||
|
||||
const ocb = await openpgp.crypto.ocb(cipher, keyBytes);
|
||||
|
||||
// encryption test
|
||||
let ct = await ocb.encrypt(msgBytes, nonceBytes, headerBytes);
|
||||
expect(openpgp.util.Uint8Array_to_hex(ct)).to.equal(vec.C.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(ct)).to.equal(vec.C.toLowerCase());
|
||||
|
||||
// decryption test with verification
|
||||
let pt = await ocb.decrypt(ctBytes, nonceBytes, headerBytes);
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.P.toLowerCase());
|
||||
|
||||
// tampering detection test
|
||||
ct = await ocb.encrypt(msgBytes, nonceBytes, headerBytes);
|
||||
|
|
@ -141,12 +141,12 @@ describe('Symmetric AES-OCB', function() {
|
|||
// testing without additional data
|
||||
ct = await ocb.encrypt(msgBytes, nonceBytes, new Uint8Array());
|
||||
pt = await ocb.decrypt(ct, nonceBytes, new Uint8Array());
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.P.toLowerCase());
|
||||
|
||||
// testing with multiple additional data
|
||||
ct = await ocb.encrypt(msgBytes, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
|
||||
pt = await ocb.decrypt(ct, nonceBytes, openpgp.util.concatUint8Array([headerBytes, headerBytes, headerBytes]));
|
||||
expect(openpgp.util.Uint8Array_to_hex(pt)).to.equal(vec.P.toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(pt)).to.equal(vec.P.toLowerCase());
|
||||
}));
|
||||
});
|
||||
|
||||
|
|
@ -177,7 +177,7 @@ describe('Symmetric AES-OCB', function() {
|
|||
}
|
||||
n = openpgp.util.concatUint8Array([new Uint8Array(8), openpgp.util.writeNumber(385, 4)]);
|
||||
const output = await ocb.encrypt(new Uint8Array(), n, openpgp.util.concatUint8Array(c));
|
||||
expect(openpgp.util.Uint8Array_to_hex(output)).to.equal(outputs[keylen].toLowerCase());
|
||||
expect(openpgp.util.uint8ArrayToHex(output)).to.equal(outputs[keylen].toLowerCase());
|
||||
}));
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -47,8 +47,8 @@ const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
|
|||
const p = keyParams[3].toUint8Array();
|
||||
const q = keyParams[4].toUint8Array();
|
||||
const u = keyParams[5].toUint8Array();
|
||||
const message = openpgp.util.Uint8Array_to_str(await openpgp.crypto.generateSessionKey('aes256'));
|
||||
const encrypted = await openpgp.crypto.publicKey.rsa.encrypt(openpgp.util.str_to_Uint8Array(message), n, e);
|
||||
const message = openpgp.util.uint8ArrayToStr(await openpgp.crypto.generateSessionKey('aes256'));
|
||||
const encrypted = await openpgp.crypto.publicKey.rsa.encrypt(openpgp.util.strToUint8Array(message), n, e);
|
||||
const result = new openpgp.MPI(encrypted);
|
||||
const decrypted = await openpgp.crypto.publicKey.rsa.decrypt(result.toUint8Array(), n, e, d, p, q, u);
|
||||
expect(decrypted).to.be.equal(message);
|
||||
|
|
@ -66,12 +66,12 @@ const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
|
|||
const p = keyParams[3].toUint8Array();
|
||||
const q = keyParams[4].toUint8Array();
|
||||
const u = keyParams[5].toUint8Array();
|
||||
const message = openpgp.util.Uint8Array_to_str(await openpgp.crypto.generateSessionKey('aes256'));
|
||||
const encryptedBn = await openpgp.crypto.publicKey.rsa.bnEncrypt(openpgp.util.str_to_Uint8Array(message), n, e);
|
||||
const message = openpgp.util.uint8ArrayToStr(await openpgp.crypto.generateSessionKey('aes256'));
|
||||
const encryptedBn = await openpgp.crypto.publicKey.rsa.bnEncrypt(openpgp.util.strToUint8Array(message), n, e);
|
||||
const resultBN = new openpgp.MPI(encryptedBn);
|
||||
const decrypted1 = await openpgp.crypto.publicKey.rsa.nodeDecrypt(resultBN.toUint8Array(), n, e, d, p, q, u);
|
||||
expect(decrypted1).to.be.equal(message);
|
||||
const encryptedNode = await openpgp.crypto.publicKey.rsa.nodeEncrypt(openpgp.util.str_to_Uint8Array(message), n, e);
|
||||
const encryptedNode = await openpgp.crypto.publicKey.rsa.nodeEncrypt(openpgp.util.strToUint8Array(message), n, e);
|
||||
const resultNode = new openpgp.MPI(encryptedNode);
|
||||
const decrypted2 = await openpgp.crypto.publicKey.rsa.bnDecrypt(resultNode.toUint8Array(), n, e, d, p, q, u);
|
||||
expect(decrypted2).to.be.equal(message);
|
||||
|
|
@ -97,11 +97,11 @@ const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
|
|||
try {
|
||||
signatureWeb = await openpgp.crypto.publicKey.rsa.webSign('SHA-256', message, n, e, d, p, q, u, hashed);
|
||||
} catch (error) {
|
||||
openpgp.util.print_debug_error('web crypto error');
|
||||
openpgp.util.printDebugError('web crypto error');
|
||||
this.skip();
|
||||
}
|
||||
const signatureBN = await openpgp.crypto.publicKey.rsa.bnSign(hash_algo, n, d, hashed);
|
||||
expect(openpgp.util.Uint8Array_to_hex(signatureWeb)).to.be.equal(openpgp.util.Uint8Array_to_hex(signatureBN));
|
||||
expect(openpgp.util.uint8ArrayToHex(signatureWeb)).to.be.equal(openpgp.util.uint8ArrayToHex(signatureBN));
|
||||
});
|
||||
|
||||
it('compare webCrypto and bn math verify', async function() {
|
||||
|
|
@ -126,7 +126,7 @@ const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
|
|||
signature = await openpgp.crypto.publicKey.rsa.webSign('SHA-256', message, n, e, d, p, q, u, hashed);
|
||||
verifyWeb = await openpgp.crypto.publicKey.rsa.webVerify('SHA-256', message, signature, n, e);
|
||||
} catch (error) {
|
||||
openpgp.util.print_debug_error('web crypto error');
|
||||
openpgp.util.printDebugError('web crypto error');
|
||||
this.skip();
|
||||
}
|
||||
const verifyBN = await openpgp.crypto.publicKey.rsa.bnVerify(hash_algo, signature, n, e, hashed);
|
||||
|
|
@ -152,7 +152,7 @@ const native = openpgp.util.getWebCrypto() || openpgp.util.getNodeCrypto();
|
|||
const hashed = await openpgp.crypto.hash.digest(hash_algo, message);
|
||||
const signatureNode = await openpgp.crypto.publicKey.rsa.nodeSign(hash_algo, message, n, e, d, p, q, u);
|
||||
const signatureBN = await openpgp.crypto.publicKey.rsa.bnSign(hash_algo, n, d, hashed);
|
||||
expect(openpgp.util.Uint8Array_to_hex(signatureNode)).to.be.equal(openpgp.util.Uint8Array_to_hex(signatureBN));
|
||||
expect(openpgp.util.uint8ArrayToHex(signatureNode)).to.be.equal(openpgp.util.uint8ArrayToHex(signatureBN));
|
||||
});
|
||||
|
||||
it('compare nodeCrypto and bn math verify', async function() {
|
||||
|
|
|
|||
|
|
@ -2598,7 +2598,7 @@ describe('Key', function() {
|
|||
|
||||
it('Parsing V5 public key packet', async function() {
|
||||
// Manually modified from https://gitlab.com/openpgp-wg/rfc4880bis/blob/00b2092/back.mkd#sample-eddsa-key
|
||||
let packetBytes = openpgp.util.hex_to_Uint8Array(`
|
||||
let packetBytes = openpgp.util.hexToUint8Array(`
|
||||
98 37 05 53 f3 5f 0b 16 00 00 00 2d 09 2b 06 01 04 01 da 47
|
||||
0f 01 01 07 40 3f 09 89 94 bd d9 16 ed 40 53 19
|
||||
79 34 e4 a8 7c 80 73 3a 12 80 d6 2f 80 10 99 2e
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ describe('Oid tests', function() {
|
|||
expect(oid).to.exist;
|
||||
expect(oid.oid).to.exist;
|
||||
expect(oid.oid).to.have.length(data.length);
|
||||
expect(oid.toHex()).to.equal(util.Uint8Array_to_hex(data));
|
||||
expect(oid.toHex()).to.equal(util.uint8ArrayToHex(data));
|
||||
});
|
||||
});
|
||||
it('Reading and writing', function() {
|
||||
|
|
@ -26,14 +26,14 @@ describe('Oid tests', function() {
|
|||
expect(oid.read(data)).to.equal(data.length);
|
||||
expect(oid.oid).to.exist;
|
||||
expect(oid.oid).to.have.length(data.length-1);
|
||||
expect(oid.toHex()).to.equal(util.Uint8Array_to_hex(data.subarray(1)));
|
||||
expect(oid.toHex()).to.equal(util.uint8ArrayToHex(data.subarray(1)));
|
||||
const result = oid.write();
|
||||
expect(result).to.exist;
|
||||
expect(result).to.have.length(data.length);
|
||||
expect(result[0]).to.equal(data.length-1);
|
||||
expect(
|
||||
util.Uint8Array_to_hex(result.subarray(1))
|
||||
).to.equal(util.Uint8Array_to_hex(data.subarray(1)));
|
||||
util.uint8ArrayToHex(result.subarray(1))
|
||||
).to.equal(util.uint8ArrayToHex(data.subarray(1)));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1502,7 +1502,7 @@ describe('OpenPGP.js public api tests', function() {
|
|||
}
|
||||
const badBodyEncrypted = data.replace(/\n=([a-zA-Z0-9/+]{4})/, 'aaa\n=$1');
|
||||
for (let allow_streaming = 1; allow_streaming >= 0; allow_streaming--) {
|
||||
openpgp.config.allow_unauthenticated_stream = !!allow_streaming;
|
||||
openpgp.config.allowUnauthenticatedStream = !!allow_streaming;
|
||||
await Promise.all([badSumEncrypted, badBodyEncrypted].map(async (encrypted, i) => {
|
||||
await Promise.all([
|
||||
encrypted,
|
||||
|
|
@ -2345,7 +2345,7 @@ J9I8AcH94nE77JUtCm7s1kOlo0EIshZsAqJwGveDGdAuabfViVwVxG4I24M6
|
|||
});
|
||||
|
||||
it('should decrypt with three passwords', async function() {
|
||||
const messageBinary = openpgp.util.b64_to_Uint8Array('wy4ECQMIElIx/jiwJV9gp/MZ/ElZwUfHrzOBfOtM8VmgDy76F7eSGWH26tAlx3WI0kMBZv6Tlc1Y6baaZ6MEcOLTG/C7uzHH7KMfuQFd3fcMaVcDawk9EEy/CybiGBE+acT6id2pemHQy6Nk76d9UUTFubcB');
|
||||
const messageBinary = openpgp.util.b64ToUint8Array('wy4ECQMIElIx/jiwJV9gp/MZ/ElZwUfHrzOBfOtM8VmgDy76F7eSGWH26tAlx3WI0kMBZv6Tlc1Y6baaZ6MEcOLTG/C7uzHH7KMfuQFd3fcMaVcDawk9EEy/CybiGBE+acT6id2pemHQy6Nk76d9UUTFubcB');
|
||||
const message = await openpgp.message.read(messageBinary);
|
||||
const passwords = ['Test', 'Pinata', 'a'];
|
||||
const decrypted = await openpgp.decrypt({ message, passwords });
|
||||
|
|
@ -2421,7 +2421,7 @@ amnR6g==
|
|||
message: await openpgp.message.readArmored(encrypted),
|
||||
format: 'binary'
|
||||
});
|
||||
expect(openpgp.util.decode_utf8(decrypted.data)).to.equal('"BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:123\r\nDTSTART:20191211T121212Z\r\nDTEND:20191212T121212Z\r\nEND:VEVENT\r\nEND:VCALENDAR"');
|
||||
expect(openpgp.util.decodeUtf8(decrypted.data)).to.equal('"BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:123\r\nDTSTART:20191211T121212Z\r\nDTEND:20191212T121212Z\r\nEND:VEVENT\r\nEND:VCALENDAR"');
|
||||
});
|
||||
|
||||
});
|
||||
|
|
|
|||
|
|
@ -242,7 +242,7 @@ describe("Packet", function() {
|
|||
it('Sym. encrypted AEAD protected packet test vector (AEAD)', async function() {
|
||||
// From https://gitlab.com/openpgp-wg/rfc4880bis/commit/00b20923e6233fb6ff1666ecd5acfefceb32907d
|
||||
|
||||
let packetBytes = openpgp.util.hex_to_Uint8Array(`
|
||||
let packetBytes = openpgp.util.hexToUint8Array(`
|
||||
d4 4a 01 07 01 0e b7 32 37 9f 73 c4 92 8d e2 5f
|
||||
ac fe 65 17 ec 10 5d c1 1a 81 dc 0c b8 a2 f6 f3
|
||||
d9 00 16 38 4a 56 fc 82 1a e1 1a e8 db cb 49 86
|
||||
|
|
@ -255,8 +255,8 @@ describe("Packet", function() {
|
|||
openpgp.config.aeadProtect = true;
|
||||
openpgp.config.aeadChunkSizeByte = 14;
|
||||
|
||||
const iv = openpgp.util.hex_to_Uint8Array('b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10'.replace(/\s+/g, ''));
|
||||
const key = openpgp.util.hex_to_Uint8Array('86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d'.replace(/\s+/g, ''));
|
||||
const iv = openpgp.util.hexToUint8Array('b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10'.replace(/\s+/g, ''));
|
||||
const key = openpgp.util.hexToUint8Array('86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d'.replace(/\s+/g, ''));
|
||||
const algo = 'aes128';
|
||||
|
||||
const literal = new openpgp.packet.Literal(0);
|
||||
|
|
@ -264,7 +264,7 @@ describe("Packet", function() {
|
|||
const msg = new openpgp.packet.List();
|
||||
|
||||
msg.push(enc);
|
||||
literal.setBytes(openpgp.util.str_to_Uint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.setBytes(openpgp.util.strToUint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.filename = '';
|
||||
enc.packets.push(literal);
|
||||
|
||||
|
|
@ -535,10 +535,10 @@ describe("Packet", function() {
|
|||
openpgp.config.aeadChunkSizeByte = 14;
|
||||
openpgp.config.s2kIterationCountByte = 0x90;
|
||||
|
||||
let salt = openpgp.util.hex_to_Uint8Array(`cd5a9f70fbe0bc65`);
|
||||
let sessionKey = openpgp.util.hex_to_Uint8Array(`86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d`.replace(/\s+/g, ''));
|
||||
let sessionIV = openpgp.util.hex_to_Uint8Array(`bc 66 9e 34 e5 00 dc ae dc 5b 32 aa 2d ab 02 35`.replace(/\s+/g, ''));
|
||||
let dataIV = openpgp.util.hex_to_Uint8Array(`b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10`.replace(/\s+/g, ''));
|
||||
let salt = openpgp.util.hexToUint8Array(`cd5a9f70fbe0bc65`);
|
||||
let sessionKey = openpgp.util.hexToUint8Array(`86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d`.replace(/\s+/g, ''));
|
||||
let sessionIV = openpgp.util.hexToUint8Array(`bc 66 9e 34 e5 00 dc ae dc 5b 32 aa 2d ab 02 35`.replace(/\s+/g, ''));
|
||||
let dataIV = openpgp.util.hexToUint8Array(`b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10`.replace(/\s+/g, ''));
|
||||
|
||||
let randomBytesStub = stub(openpgp.crypto.random, 'getRandomBytes');
|
||||
randomBytesStub.onCall(0).returns(resolves(salt));
|
||||
|
|
@ -546,7 +546,7 @@ describe("Packet", function() {
|
|||
randomBytesStub.onCall(2).returns(resolves(sessionIV));
|
||||
randomBytesStub.onCall(3).returns(resolves(dataIV));
|
||||
|
||||
let packetBytes = openpgp.util.hex_to_Uint8Array(`
|
||||
let packetBytes = openpgp.util.hexToUint8Array(`
|
||||
c3 3e 05 07 01 03 08 cd 5a 9f 70 fb e0 bc 65 90
|
||||
bc 66 9e 34 e5 00 dc ae dc 5b 32 aa 2d ab 02 35
|
||||
9d ee 19 d0 7c 34 46 c4 31 2a 34 ae 19 67 a2 fb
|
||||
|
|
@ -576,7 +576,7 @@ describe("Packet", function() {
|
|||
|
||||
const key = key_enc.sessionKey;
|
||||
|
||||
literal.setBytes(openpgp.util.str_to_Uint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.setBytes(openpgp.util.strToUint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.filename = '';
|
||||
enc.packets.push(literal);
|
||||
await enc.encrypt(algo, key);
|
||||
|
|
@ -610,10 +610,10 @@ describe("Packet", function() {
|
|||
openpgp.config.aeadChunkSizeByte = 14;
|
||||
openpgp.config.s2kIterationCountByte = 0x90;
|
||||
|
||||
let salt = openpgp.util.hex_to_Uint8Array(`9f0b7da3e5ea6477`);
|
||||
let sessionKey = openpgp.util.hex_to_Uint8Array(`d1 f0 1b a3 0e 13 0a a7 d2 58 2c 16 e0 50 ae 44`.replace(/\s+/g, ''));
|
||||
let sessionIV = openpgp.util.hex_to_Uint8Array(`99 e3 26 e5 40 0a 90 93 6c ef b4 e8 eb a0 8c`.replace(/\s+/g, ''));
|
||||
let dataIV = openpgp.util.hex_to_Uint8Array(`5e d2 bc 1e 47 0a be 8f 1d 64 4c 7a 6c 8a 56`.replace(/\s+/g, ''));
|
||||
let salt = openpgp.util.hexToUint8Array(`9f0b7da3e5ea6477`);
|
||||
let sessionKey = openpgp.util.hexToUint8Array(`d1 f0 1b a3 0e 13 0a a7 d2 58 2c 16 e0 50 ae 44`.replace(/\s+/g, ''));
|
||||
let sessionIV = openpgp.util.hexToUint8Array(`99 e3 26 e5 40 0a 90 93 6c ef b4 e8 eb a0 8c`.replace(/\s+/g, ''));
|
||||
let dataIV = openpgp.util.hexToUint8Array(`5e d2 bc 1e 47 0a be 8f 1d 64 4c 7a 6c 8a 56`.replace(/\s+/g, ''));
|
||||
|
||||
let randomBytesStub = stub(openpgp.crypto.random, 'getRandomBytes');
|
||||
randomBytesStub.onCall(0).returns(resolves(salt));
|
||||
|
|
@ -621,7 +621,7 @@ describe("Packet", function() {
|
|||
randomBytesStub.onCall(2).returns(resolves(sessionIV));
|
||||
randomBytesStub.onCall(3).returns(resolves(dataIV));
|
||||
|
||||
let packetBytes = openpgp.util.hex_to_Uint8Array(`
|
||||
let packetBytes = openpgp.util.hexToUint8Array(`
|
||||
c3 3d 05 07 02 03 08 9f 0b 7d a3 e5 ea 64 77 90
|
||||
99 e3 26 e5 40 0a 90 93 6c ef b4 e8 eb a0 8c 67
|
||||
73 71 6d 1f 27 14 54 0a 38 fc ac 52 99 49 da c5
|
||||
|
|
@ -652,7 +652,7 @@ describe("Packet", function() {
|
|||
|
||||
const key = key_enc.sessionKey;
|
||||
|
||||
literal.setBytes(openpgp.util.str_to_Uint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.setBytes(openpgp.util.strToUint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
|
||||
literal.filename = '';
|
||||
enc.packets.push(literal);
|
||||
await enc.encrypt(algo, key);
|
||||
|
|
|
|||
|
|
@ -1118,7 +1118,7 @@ bwM=
|
|||
});
|
||||
|
||||
it('Verify latin-1 signed message', async function() {
|
||||
const latin1Binary = openpgp.util.hex_to_Uint8Array('48e46c6cf62057e86c74');
|
||||
const latin1Binary = openpgp.util.hexToUint8Array('48e46c6cf62057e86c74');
|
||||
const message = openpgp.message.fromBinary(latin1Binary);
|
||||
|
||||
message.appendSignature(`-----BEGIN PGP SIGNATURE-----
|
||||
|
|
@ -1404,7 +1404,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
});
|
||||
|
||||
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same bytes cleartext and valid signatures - armored', async function() {
|
||||
const plaintext = openpgp.util.str_to_Uint8Array('short message\nnext line \n한국어/조선말');
|
||||
const plaintext = openpgp.util.strToUint8Array('short message\nnext line \n한국어/조선말');
|
||||
const pubKey = await openpgp.key.readArmored(pub_key_arm2);
|
||||
const privKey = await openpgp.key.readArmored(priv_key_arm2);
|
||||
await privKey.decrypt('hello world');
|
||||
|
|
@ -1424,7 +1424,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
});
|
||||
|
||||
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same bytes cleartext and valid signatures - not armored', async function() {
|
||||
const plaintext = openpgp.util.str_to_Uint8Array('short message\nnext line \n한국어/조선말');
|
||||
const plaintext = openpgp.util.strToUint8Array('short message\nnext line \n한국어/조선말');
|
||||
const pubKey = await openpgp.key.readArmored(pub_key_arm2);
|
||||
const privKey = await openpgp.key.readArmored(priv_key_arm2);
|
||||
await privKey.decrypt('hello world');
|
||||
|
|
@ -1450,7 +1450,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
await privKey.decrypt('hello world');
|
||||
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromText(plaintext), detached: true}).then(async function(signed) {
|
||||
const signature = await openpgp.signature.readArmored(signed);
|
||||
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.message.fromBinary(openpgp.util.encode_utf8(plaintext)), signature: signature });
|
||||
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.message.fromBinary(openpgp.util.encodeUtf8(plaintext)), signature: signature });
|
||||
}).then(function(cleartextSig) {
|
||||
expect(cleartextSig).to.exist;
|
||||
expect(cleartextSig.signatures).to.have.length(1);
|
||||
|
|
@ -1461,7 +1461,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
|
||||
it('Should verify cleartext message correctly when using a detached binary signature and text literal data', async function () {
|
||||
const plaintext = 'short message\nnext line \n한국어/조선말';
|
||||
const plaintextArray = openpgp.util.encode_utf8(plaintext);
|
||||
const plaintextArray = openpgp.util.encodeUtf8(plaintext);
|
||||
const pubKey = await openpgp.key.readArmored(pub_key_arm2);
|
||||
const privKey = await openpgp.key.readArmored(priv_key_arm2);
|
||||
await privKey.decrypt('hello world');
|
||||
|
|
@ -1483,7 +1483,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
await Promise.all([privKey.primaryKey.decrypt('hello world'), privKey.subKeys[0].keyPacket.decrypt('hello world')]);
|
||||
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromText(plaintext), detached: true}).then(async function(signed) {
|
||||
const signature = await openpgp.signature.readArmored(signed);
|
||||
return openpgp.encrypt({ message: openpgp.message.fromBinary(openpgp.util.encode_utf8(plaintext)), publicKeys: [pubKey], signature })
|
||||
return openpgp.encrypt({ message: openpgp.message.fromBinary(openpgp.util.encodeUtf8(plaintext)), publicKeys: [pubKey], signature })
|
||||
}).then(async data => {
|
||||
const csMsg = await openpgp.message.readArmored(data);
|
||||
return openpgp.decrypt({ message: csMsg, privateKeys: [ privKey ], publicKeys: [ pubKey ] });
|
||||
|
|
|
|||
|
|
@ -170,8 +170,8 @@ function tests() {
|
|||
dataArrived(); // Do not wait until data arrived.
|
||||
const data = new ReadableStream({
|
||||
async start(controller) {
|
||||
controller.enqueue(util.str_to_Uint8Array('hello '));
|
||||
controller.enqueue(util.str_to_Uint8Array('world'));
|
||||
controller.enqueue(util.strToUint8Array('hello '));
|
||||
controller.enqueue(util.strToUint8Array('world'));
|
||||
controller.close();
|
||||
}
|
||||
});
|
||||
|
|
@ -726,8 +726,8 @@ function tests() {
|
|||
dataArrived(); // Do not wait until data arrived.
|
||||
const data = new ReadableStream({
|
||||
async start(controller) {
|
||||
controller.enqueue(util.str_to_Uint8Array('hello '));
|
||||
controller.enqueue(util.str_to_Uint8Array('world'));
|
||||
controller.enqueue(util.strToUint8Array('hello '));
|
||||
controller.enqueue(util.strToUint8Array('world'));
|
||||
controller.close();
|
||||
}
|
||||
});
|
||||
|
|
@ -754,8 +754,8 @@ function tests() {
|
|||
dataArrived(); // Do not wait until data arrived.
|
||||
const data = new ReadableStream({
|
||||
async start(controller) {
|
||||
controller.enqueue(util.str_to_Uint8Array('hello '));
|
||||
controller.enqueue(util.str_to_Uint8Array('world'));
|
||||
controller.enqueue(util.strToUint8Array('hello '));
|
||||
controller.enqueue(util.strToUint8Array('world'));
|
||||
controller.close();
|
||||
}
|
||||
});
|
||||
|
|
@ -782,8 +782,8 @@ function tests() {
|
|||
dataArrived(); // Do not wait until data arrived.
|
||||
const data = new ReadableStream({
|
||||
async start(controller) {
|
||||
controller.enqueue(util.str_to_Uint8Array('hello '));
|
||||
controller.enqueue(util.str_to_Uint8Array('world'));
|
||||
controller.enqueue(util.strToUint8Array('hello '));
|
||||
controller.enqueue(util.strToUint8Array('world'));
|
||||
controller.close();
|
||||
}
|
||||
});
|
||||
|
|
@ -813,8 +813,8 @@ function tests() {
|
|||
dataArrived(); // Do not wait until data arrived.
|
||||
const data = new ReadableStream({
|
||||
async start(controller) {
|
||||
controller.enqueue(util.str_to_Uint8Array('hello '));
|
||||
controller.enqueue(util.str_to_Uint8Array('world'));
|
||||
controller.enqueue(util.strToUint8Array('hello '));
|
||||
controller.enqueue(util.strToUint8Array('world'));
|
||||
controller.close();
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -143,7 +143,7 @@ describe('Util unit tests', function() {
|
|||
|
||||
describe("Zbase32", function() {
|
||||
it('util.encodeZBase32 encodes correctly', function() {
|
||||
const encoded = openpgp.util.encodeZBase32(openpgp.util.str_to_Uint8Array('test-wkd'));
|
||||
const encoded = openpgp.util.encodeZBase32(openpgp.util.strToUint8Array('test-wkd'));
|
||||
expect(encoded).to.equal('qt1zg7bpq7ise');
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -216,23 +216,23 @@ const input = require('./testInputs');
|
|||
const util = openpgp.util;
|
||||
function testVector(vector) {
|
||||
const curve = new elliptic.Curve('ed25519');
|
||||
const { publicKey } = openpgp.crypto.publicKey.nacl.sign.keyPair.fromSeed(openpgp.util.hex_to_Uint8Array(vector.SECRET_KEY));
|
||||
expect(publicKey).to.deep.equal(openpgp.util.hex_to_Uint8Array(vector.PUBLIC_KEY));
|
||||
const data = util.str_to_Uint8Array(vector.MESSAGE);
|
||||
const { publicKey } = openpgp.crypto.publicKey.nacl.sign.keyPair.fromSeed(openpgp.util.hexToUint8Array(vector.SECRET_KEY));
|
||||
expect(publicKey).to.deep.equal(openpgp.util.hexToUint8Array(vector.PUBLIC_KEY));
|
||||
const data = util.strToUint8Array(vector.MESSAGE);
|
||||
const keyIntegers = [
|
||||
new openpgp.OID(curve.oid),
|
||||
new openpgp.MPI(util.hex_to_str('40'+vector.PUBLIC_KEY)),
|
||||
new openpgp.MPI(util.hex_to_str(vector.SECRET_KEY))
|
||||
new openpgp.MPI(util.hexToStr('40'+vector.PUBLIC_KEY)),
|
||||
new openpgp.MPI(util.hexToStr(vector.SECRET_KEY))
|
||||
];
|
||||
const msg_MPIs = [
|
||||
new openpgp.MPI(util.Uint8Array_to_str(util.hex_to_Uint8Array(vector.SIGNATURE.R).reverse())),
|
||||
new openpgp.MPI(util.Uint8Array_to_str(util.hex_to_Uint8Array(vector.SIGNATURE.S).reverse()))
|
||||
new openpgp.MPI(util.uint8ArrayToStr(util.hexToUint8Array(vector.SIGNATURE.R).reverse())),
|
||||
new openpgp.MPI(util.uint8ArrayToStr(util.hexToUint8Array(vector.SIGNATURE.S).reverse()))
|
||||
];
|
||||
return Promise.all([
|
||||
signature.sign(22, undefined, keyIntegers, undefined, data).then(signed => {
|
||||
const len = ((signed[0] << 8| signed[1]) + 7) / 8;
|
||||
expect(util.hex_to_Uint8Array(vector.SIGNATURE.R)).to.deep.eq(signed.slice(2, 2 + len));
|
||||
expect(util.hex_to_Uint8Array(vector.SIGNATURE.S)).to.deep.eq(signed.slice(4 + len));
|
||||
expect(util.hexToUint8Array(vector.SIGNATURE.R)).to.deep.eq(signed.slice(2, 2 + len));
|
||||
expect(util.hexToUint8Array(vector.SIGNATURE.S)).to.deep.eq(signed.slice(4 + len));
|
||||
}),
|
||||
signature.verify(22, undefined, msg_MPIs, keyIntegers, undefined, data).then(result => {
|
||||
expect(result).to.be.true;
|
||||
|
|
@ -265,7 +265,7 @@ const input = require('./testInputs');
|
|||
PUBLIC_KEY:
|
||||
['3d4017c3e843895a92b70aa74d1b7ebc',
|
||||
'9c982ccf2ec4968cc0cd55f12af4660c'].join(''),
|
||||
MESSAGE: util.hex_to_str('72'),
|
||||
MESSAGE: util.hexToStr('72'),
|
||||
SIGNATURE:
|
||||
{ R: ['92a009a9f0d4cab8720e820b5f642540',
|
||||
'a2b27b5416503f8fb3762223ebdb69da'].join(''),
|
||||
|
|
@ -282,7 +282,7 @@ const input = require('./testInputs');
|
|||
PUBLIC_KEY:
|
||||
['fc51cd8e6218a1a38da47ed00230f058',
|
||||
'0816ed13ba3303ac5deb911548908025'].join(''),
|
||||
MESSAGE: util.hex_to_str('af82'),
|
||||
MESSAGE: util.hexToStr('af82'),
|
||||
SIGNATURE:
|
||||
{ R: ['6291d657deec24024827e69c3abe01a3',
|
||||
'0ce548a284743a445e3680d7db5ac3ac'].join(''),
|
||||
|
|
@ -299,7 +299,7 @@ const input = require('./testInputs');
|
|||
PUBLIC_KEY:
|
||||
['278117fc144c72340f67d0f2316e8386',
|
||||
'ceffbf2b2428c9c51fef7c597f1d426e'].join(''),
|
||||
MESSAGE: util.hex_to_str([
|
||||
MESSAGE: util.hexToStr([
|
||||
'08b8b2b733424243760fe426a4b54908',
|
||||
'632110a66c2f6591eabd3345e3e4eb98',
|
||||
'fa6e264bf09efe12ee50f8f54e9f77b1',
|
||||
|
|
@ -381,7 +381,7 @@ const input = require('./testInputs');
|
|||
PUBLIC_KEY:
|
||||
['ec172b93ad5e563bf4932c70e1245034',
|
||||
'c35467ef2efd4d64ebf819683467e2bf'].join(''),
|
||||
MESSAGE: util.hex_to_str([
|
||||
MESSAGE: util.hexToStr([
|
||||
'ddaf35a193617abacc417349ae204131',
|
||||
'12e6fa4e89a97ea20a9eeee64b55d39a',
|
||||
'2192992a274fc1a836ba3c23a3feebbd',
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ async function getOtherPubKey() {
|
|||
/**
|
||||
* The "standalone" signature signed by the victim.
|
||||
*/
|
||||
const STANDALONE_PKT = util.b64_to_Uint8Array(`
|
||||
const STANDALONE_PKT = util.b64ToUint8Array(`
|
||||
BAIBCAAQBQJbq3MKCRBVIIstGKzjzgAAWdoIALgj7OuhuuAWr6WEvGfvkx3e
|
||||
Fn/mg76lh2Hawxq6ryI6+kzUH+YJsG94CfLgGuh5LghZFBnlkdZS11gK87fN
|
||||
+ifmPdSDj8fsKqSFdX1sHGwzvzBcuPt+qhtHrACCWwiiBgajIOmIczKUlX4D
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@ if (typeof Promise === 'undefined') {
|
|||
describe('Unit Tests', function () {
|
||||
|
||||
if (typeof window !== 'undefined') {
|
||||
openpgp.config.s2k_iteration_count_byte = 0;
|
||||
openpgp.config.indutny_elliptic_path = '../dist/elliptic.min.js';
|
||||
openpgp.config.s2kIterationCountByte = 0;
|
||||
openpgp.config.indutnyEllipticPath = '../dist/elliptic.min.js';
|
||||
|
||||
window.location.search.substr(1).split('&').forEach(param => {
|
||||
const [key, value] = param.split('=');
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user