mozilla-central/dom/push/test/xpcshell/test_crypto.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

"use strict";
const { getCryptoParamsFromHeaders, PushCrypto } = ChromeUtils.importESModule(
);
const REJECT_PADDING = { padding: "reject" };
// A common key to decrypt some aesgcm and aesgcm128 messages. Other decryption
// tests have their own keys.
const LEGACY_PRIVATE_KEY = {
kty: "EC",
crv: "P-256",
d: "4h23G_KkXC9TvBSK2v0Q7ImpS2YAuRd8hQyN0rFAwBg",
x: "sd85ZCbEG6dEkGMCmDyGBIt454Qy-Yo-1xhbaT2Jlk4",
y: "vr3cKpQ-Sp1kpZ9HipNjUCwSA55yy0uM8N9byE8dmLs",
ext: true,
};
const LEGACY_PUBLIC_KEY =
"BLHfOWQmxBunRJBjApg8hgSLeOeEMvmKPtcYW2k9iZZOvr3cKpQ-Sp1kpZ9HipNjUCwSA55yy0uM8N9byE8dmLs";
async function assertDecrypts(test, headers) {
let privateKey = test.privateKey;
let publicKey = ChromeUtils.base64URLDecode(test.publicKey, REJECT_PADDING);
let authSecret = null;
if (test.authSecret) {
authSecret = ChromeUtils.base64URLDecode(test.authSecret, REJECT_PADDING);
}
let payload = ChromeUtils.base64URLDecode(test.data, REJECT_PADDING);
let result = await PushCrypto.decrypt(
privateKey,
publicKey,
authSecret,
headers,
payload
);
let decoder = new TextDecoder("utf-8");
equal(decoder.decode(new Uint8Array(result)), test.result, test.desc);
}
async function assertNotDecrypts(test, headers) {
let authSecret = null;
if (test.authSecret) {
authSecret = ChromeUtils.base64URLDecode(test.authSecret, REJECT_PADDING);
}
let data = ChromeUtils.base64URLDecode(test.data, REJECT_PADDING);
let publicKey = ChromeUtils.base64URLDecode(test.publicKey, REJECT_PADDING);
let promise = PushCrypto.decrypt(
test.privateKey,
publicKey,
authSecret,
headers,
data
);
await Assert.rejects(promise, test.expected, test.desc);
}
add_task(async function test_crypto_getCryptoParamsFromHeaders() {
// These headers should parse correctly.
let shouldParse = [
{
desc: "aesgcm with multiple keys",
headers: {
encoding: "aesgcm",
crypto_key: "keyid=p256dh;dh=Iy1Je2Kv11A,p256ecdsa=o2M8QfiEKuI",
encryption: "keyid=p256dh;salt=upk1yFkp1xI",
},
params: {
senderKey: "Iy1Je2Kv11A",
salt: "upk1yFkp1xI",
rs: 4096,
},
},
{
desc: "aesgcm with quoted key param",
headers: {
encoding: "aesgcm",
crypto_key: 'dh="byfHbUffc-k"',
encryption: "salt=C11AvAsp6Gc",
},
params: {
senderKey: "byfHbUffc-k",
salt: "C11AvAsp6Gc",
rs: 4096,
},
},
{
desc: "aesgcm with Crypto-Key and rs = 24",
headers: {
encoding: "aesgcm",
crypto_key: 'dh="ybuT4VDz-Bg"',
encryption: "salt=H7U7wcIoIKs; rs=24",
},
params: {
senderKey: "ybuT4VDz-Bg",
salt: "H7U7wcIoIKs",
rs: 24,
},
},
{
desc: "aesgcm128 with Encryption-Key and rs = 2",
headers: {
encoding: "aesgcm128",
encryption_key: "keyid=legacy; dh=LqrDQuVl9lY",
encryption: "keyid=legacy; salt=YngI8B7YapM; rs=2",
},
params: {
senderKey: "LqrDQuVl9lY",
salt: "YngI8B7YapM",
rs: 2,
},
},
{
desc: "aesgcm128 with Encryption-Key",
headers: {
encoding: "aesgcm128",
encryption_key: "keyid=v2; dh=VA6wmY1IpiE",
encryption: "keyid=v2; salt=khtpyXhpDKM",
},
params: {
senderKey: "VA6wmY1IpiE",
salt: "khtpyXhpDKM",
rs: 4096,
},
},
];
for (let test of shouldParse) {
let params = getCryptoParamsFromHeaders(test.headers);
let senderKey = ChromeUtils.base64URLDecode(
test.params.senderKey,
REJECT_PADDING
);
let salt = ChromeUtils.base64URLDecode(test.params.salt, REJECT_PADDING);
deepEqual(
new Uint8Array(params.senderKey),
new Uint8Array(senderKey),
"Sender key should match for " + test.desc
);
deepEqual(
new Uint8Array(params.salt),
new Uint8Array(salt),
"Salt should match for " + test.desc
);
equal(
params.rs,
test.params.rs,
"Record size should match for " + test.desc
);
}
// These headers should be rejected.
let shouldThrow = [
{
desc: "aesgcm128 with Crypto-Key",
headers: {
encoding: "aesgcm128",
crypto_key: "keyid=v2; dh=VA6wmY1IpiE",
encryption: "keyid=v2; salt=F0Im7RtGgNY",
},
exception: /Missing Encryption-Key header/,
},
{
desc: "Invalid encoding",
headers: {
encoding: "nonexistent",
},
exception: /Missing encryption header/,
},
{
desc: "Invalid record size",
headers: {
encoding: "aesgcm",
crypto_key: "dh=pbmv1QkcEDY",
encryption: "dh=Esao8aTBfIk;rs=bad",
},
exception: /Invalid salt parameter/,
},
{
desc: "aesgcm with Encryption-Key",
headers: {
encoding: "aesgcm",
encryption_key: "dh=FplK5KkvUF0",
encryption: "salt=p6YHhFF3BQY",
},
exception: /Missing Crypto-Key header/,
},
];
for (let test of shouldThrow) {
throws(
() => getCryptoParamsFromHeaders(test.headers),
test.exception,
test.desc
);
}
});
add_task(async function test_aes128gcm_ok() {
let expectedSuccesses = [
{
desc: "Example from draft-ietf-webpush-encryption-latest",
result: "When I grow up, I want to be a watermelon",
data: "DGv6ra1nlYgDCS1FRnbzlwAAEABBBP4z9KsN6nGRTbVYI_c7VJSPQTBtkgcy27mlmlMoZIIgDll6e3vCYLocInmYWAmS6TlzAC8wEqKK6PBru3jl7A_yl95bQpu6cVPTpK4Mqgkf1CXztLVBSt2Ks3oZwbuwXPXLWyouBWLVWGNWQexSgSxsj_Qulcy4a-fN",
authSecret: "BTBZMqHH6r4Tts7J_aSIgg",
privateKey: {
kty: "EC",
crv: "P-256",
d: "q1dXpw3UpT5VOmu_cf_v6ih07Aems3njxI-JWgLcM94",
x: "JXGyvs3942BVGq8e0PTNNmwRzr5VX4m8t7GGpTM5FzE",
y: "aOzi6-AYWXvTBHm4bjyPjs7Vd8pZGH6SRpkNtoIAiw4",
ext: true,
},
publicKey:
"BCVxsr7N_eNgVRqvHtD0zTZsEc6-VV-JvLexhqUzORcxaOzi6-AYWXvTBHm4bjyPjs7Vd8pZGH6SRpkNtoIAiw4",
},
{
desc: "rs = 24, pad = 0",
result:
"I am the very model of a modern Major-General; I've information vegetable, animal, and mineral",
data: "goagSH7PP0ZGwUsgShmdkwAAABhBBDJVyIuUJbOSVMeWHP8VNPnxY-dZSw86doqOkEzZZZY1ALBWVXTVf0rUDH3oi68I9Hrp-01zA-mr8XKWl5kcH8cX0KiV2PtCwdkEyaQ73YF5fsDxgoWDiaTA3wPqMvuLDqGsZWHnE9Psnfoy7UMEqKlh2a1nE7ZOXiXcOBHLNj260jYzSJnEPV2eXixSXfyWpaSJHAwfj4wVdAAocmViIg6ywk8wFB1hgJpnX2UVEU_qIOcaP6AOIOr1UUQPfosQqC2MEHe5u9gHXF5pi-E267LAlkoYefq01KV_xK_vjbxpw8GAYfSjQEm0L8FG-CN37c8pnQ2Yf61MkihaXac9OctfNeWq_22cN6hn4qsOq0F7QoWIiZqWhB1vS9cJ3KUlyPQvKI9cvevDxw0fJHWeTFzhuwT9BjdILjjb2Vkqc0-qTDOawqD4c8WXsvdGDQCec5Y1x3UhdQXdjR_mhXypxFM37OZTvKJBr1vPCpRXl-bI6iOd7KScgtMM1x5luKhGzZyz25HyuFyj1ec82A",
authSecret: "_tK2LDGoIt6be6agJ_nvGA",
privateKey: {
kty: "EC",
crv: "P-256",
d: "bGViEe3PvjjFJg8lcnLsqu71b2yqWGnZN9J2MTed-9s",
x: "auB0GHF0AZ2LAocFnvOXDS7EeCMopnzbg-tS21FMHrU",
y: "GpbhrW-_xKj3XhhXA-kDZSicKZ0kn0BuVhqzhLOB-Cc",
ext: true,
},
publicKey:
"BGrgdBhxdAGdiwKHBZ7zlw0uxHgjKKZ824PrUttRTB61GpbhrW-_xKj3XhhXA-kDZSicKZ0kn0BuVhqzhLOB-Cc",
},
{
desc: "rs = 49, pad = 84; ciphertext length falls on record boundary",
result: "Hello, world",
data: "-yiDzsHE_K3W0TcfbqSR4AAAADFBBC1EHuf5_2oDKaZJJ9BST9vnsixvtl4Qq0_cA4-UQgoMo_oo2tNshOyRoWLq4Hj6rSwc7XjegRPhlgKyDolPSXa5c-L89oL6DIzNmvPVv_Ht4W-tWjHOGdOLXh_h94pPrYQrvBAlTCxs3ZaitVKE2XLFPK2MO6yxD19X6w1KQzO2BBAroRfK4pEI-9n2Kai6aWDdAZRbOe03unBsQ0oQ_SvSCU_5JJvNrUUTX1_kX804Bx-LLTlBr9pDmBDXeqyvfOULVDJb9YyVAzN9BzeFoyPfo0M",
authSecret: "lfF1cOUI72orKtG09creMw",
privateKey: {
kty: "EC",
crv: "P-256",
d: "ZwBKTqgg3u2OSdtelIDmPT6jzOGujhpgYJcT1SfQAe8",
x: "AU6PFLktoHzgg7k_ljZ-h7IXpH9-8u6TqdNDqgY-V1o",
y: "nzDVnGkMajmz_IFbFQyn3RSWAXQTN7U1B6UfQbFzpyE",
ext: true,
},
publicKey:
"BAFOjxS5LaB84IO5P5Y2foeyF6R_fvLuk6nTQ6oGPldanzDVnGkMajmz_IFbFQyn3RSWAXQTN7U1B6UfQbFzpyE",
},
{
desc: "rs = 18, pad = 0",
result: "1",
data: "fK69vCCTjuNAqUbxvU9o8QAAABJBBDfP21Ij2fleqgL27ZQP8i6vBbNiLpSdw86fM15u-bJq6qzKD3QICos2RZLyzMbV7d1DAEtwuRiH0UTZ-pPxbDvH6mj0_VR6lOyoSxbhOKYIAXc",
authSecret: "1loE35Xy215gSDn3F9zeeQ",
privateKey: {
kty: "EC",
crv: "P-256",
d: "J0M_q4lws8tShLYRg--0YoZWLNKnMw2MrpYJEaVXHQw",
x: "UV1DJjVWUjmdoksr6SQeYztc8U-vDPOm_WAxe5VMCi8",
y: "SEhUgASyewz3SAvIEMa-wDqPt5yOoA_IsF4A-INFY-8",
ext: true,
},
publicKey:
"BFFdQyY1VlI5naJLK-kkHmM7XPFPrwzzpv1gMXuVTAovSEhUgASyewz3SAvIEMa-wDqPt5yOoA_IsF4A-INFY-8",
},
];
for (let test of expectedSuccesses) {
let privateKey = test.privateKey;
let publicKey = ChromeUtils.base64URLDecode(test.publicKey, {
padding: "reject",
});
let authSecret = ChromeUtils.base64URLDecode(test.authSecret, {
padding: "reject",
});
let payload = ChromeUtils.base64URLDecode(test.data, {
padding: "reject",
});
let result = await PushCrypto.decrypt(
privateKey,
publicKey,
authSecret,
{
encoding: "aes128gcm",
},
payload
);
let decoder = new TextDecoder("utf-8");
equal(decoder.decode(new Uint8Array(result)), test.result, test.desc);
}
});
add_task(async function test_aes128gcm_err() {
let expectedFailures = [
{
// Just the payload; no header at all.
desc: "Missing header block",
data: "RbdNK2m-mwdN47NaqH58FWEd",
privateKey: {
kty: "EC",
crv: "P-256",
d: "G-g_ODMu8JaB-vPzB7H_LhDKt4zHzatoOsDukqw_buE",
x: "26mRyiFTQ_Nr3T6FfK_ePRi_V_GDWygzutQU8IhBYgU",
y: "GslqCyRJADfQfPUo5OGOEAoaZOt0R0hUS_HiINq6zyw",
ext: true,
},
publicKey:
"BNupkcohU0Pza90-hXyv3j0Yv1fxg1soM7rUFPCIQWIFGslqCyRJADfQfPUo5OGOEAoaZOt0R0hUS_HiINq6zyw",
authSecret: "NHG7mEgeAlM785VCvPPbpA",
expected: /Truncated header/,
},
{
// The sender key should be 65 bytes; this header contains an invalid key
// that's only 1 byte.
desc: "Truncated sender key",
data: "3ltpa4fxoVy2revdedb5ngAAABIBALa8GCbDfJ9z3WtIWcK1BRgZUg",
privateKey: {
kty: "EC",
crv: "P-256",
d: "zojo4LMFekdS60yPqTHrYhwwLaWtA7ga9FnPZzVWDK4",
x: "oyXZkITEDeDOcioELESNlKMmkXIcp54890XnjGmIYZQ",
y: "sCzqGSJBdnlanU27sgc68szW-m8KTHxJaFVr5QKjuoE",
ext: true,
},
publicKey:
"BKMl2ZCExA3gznIqBCxEjZSjJpFyHKeePPdF54xpiGGUsCzqGSJBdnlanU27sgc68szW-m8KTHxJaFVr5QKjuoE",
authSecret: "XDHg2W2aE5iZrAlp01n3QA",
expected: /Invalid sender public key/,
},
{
// The message is encrypted with only the first 12 bytes of the 16-byte
// auth secret, so the derived decryption key and nonce won't match.
desc: "Encrypted with mismatched auth secret",
data: "gRX0mIuMOSp7rLQ8jxrFZQAAABJBBBmUSDxUHpvDmmrwP_cTqndFwoThOKQqJDW3l7IMS2mM9RGLT4VVMXwZDqvr-rdJwWTT9r3r4NRBcZExo1fYiQoTxNvUsW_z3VqD98ka1uBArEJzCn8LPNMkXp-Nb_McdR1BDP0",
privateKey: {
kty: "EC",
crv: "P-256",
d: "YMdjalF95wOaCsLQ4wZEAHlMeOfgSTmBKaInzuD5qAE",
x: "_dBBKKhcBYltf4H-EYvcuIe588H_QYOtxMgk0ShgcwA",
y: "6Yay37WmEOWvQ-QIoAcwWE-T49_d_ERzfV8I-y1viRY",
ext: true,
},
publicKey:
"BP3QQSioXAWJbX-B_hGL3LiHufPB_0GDrcTIJNEoYHMA6Yay37WmEOWvQ-QIoAcwWE-T49_d_ERzfV8I-y1viRY",
authSecret: "NVo4zW2b7xWZDi0zCNvWAA",
expected: /Bad encryption/,
},
{
// Multiple records; the first has padding delimiter = 2, but should be 1.
desc: "Early final record",
data: "2-IVUH0a09Lq6r6ubodNjwAAABJBBHvEND80qDSM3E5GL_x8QKpqjGGnOcTEHUUSVQX3Dp_F-e-oaFLdSI3Pjo6iyvt14Hq9XufJ1cA4uv7weVcbC9opRBHOmMdt0DHA5YBXekmAo3XkXtMEKb4OLunafm34aW0BuOw",
privateKey: {
kty: "EC",
crv: "P-256",
d: "XdodkYvEB7o82hLLgBTUmqfgJpACggMERmvIADTKkkA",
x: "yVxlINrRHo9qG_gDGkDCpO4QRcGQO-BqHfp_gpzOst4",
y: "Akga5r0EdhIbEsVTLQsjF4gHfvoGg6W_4NYjObJRyzU",
ext: true,
},
publicKey:
"BMlcZSDa0R6Pahv4AxpAwqTuEEXBkDvgah36f4KczrLeAkga5r0EdhIbEsVTLQsjF4gHfvoGg6W_4NYjObJRyzU",
authSecret: "QMJB_eQmnuHm1yVZLZgnGA",
expected: /Padding is wrong!/,
},
];
for (let test of expectedFailures) {
await assertNotDecrypts(test, { encoding: "aes128gcm" });
}
});
add_task(async function test_aesgcm_ok() {
let expectedSuccesses = [
{
desc: "padSize = 2, rs = 24, pad = 0",
result: "Some message",
data: "Oo34w2F9VVnTMFfKtdx48AZWQ9Li9M6DauWJVgXU",
authSecret: "aTDc6JebzR6eScy2oLo4RQ",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BCHFVrflyxibGLlgztLwKelsRZp4gqX3tNfAKFaxAcBhpvYeN1yIUMrxaDKiLh4LNKPtj0BOXGdr-IQ-QP82Wjo",
encryption: "salt=zCU18Rw3A5aB_Xi-vfixmA; rs=24",
encoding: "aesgcm",
},
},
{
desc: "padSize = 2, rs = 8, pad = 16",
result: "Yet another message",
data: "uEC5B_tR-fuQ3delQcrzrDCp40W6ipMZjGZ78USDJ5sMj-6bAOVG3AK6JqFl9E6AoWiBYYvMZfwThVxmDnw6RHtVeLKFM5DWgl1EwkOohwH2EhiDD0gM3io-d79WKzOPZE9rDWUSv64JstImSfX_ADQfABrvbZkeaWxh53EG59QMOElFJqHue4dMURpsMXg",
authSecret: "6plwZnSpVUbF7APDXus3UQ",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BEaA4gzA3i0JDuirGhiLgymS4hfFX7TNTdEhSk_HBlLpkjgCpjPL5c-GL9uBGIfa_fhGNKKFhXz1k9Kyens2ZpQ",
encryption: "salt=ZFhzj0S-n29g9P2p4-I7tA; rs=8",
encoding: "aesgcm",
},
},
{
desc: "padSize = 2, rs = 3, pad = 0",
result: "Small record size",
data: "oY4e5eDatDVt2fpQylxbPJM-3vrfhDasfPc8Q1PWt4tPfMVbz_sDNL_cvr0DXXkdFzS1lxsJsj550USx4MMl01ihjImXCjrw9R5xFgFrCAqJD3GwXA1vzS4T5yvGVbUp3SndMDdT1OCcEofTn7VC6xZ-zP8rzSQfDCBBxmPU7OISzr8Z4HyzFCGJeBfqiZ7yUfNlKF1x5UaZ4X6iU_TXx5KlQy_toV1dXZ2eEAMHJUcSdArvB6zRpFdEIxdcHcJyo1BIYgAYTDdAIy__IJVCPY_b2CE5W_6ohlYKB7xDyH8giNuWWXAgBozUfScLUVjPC38yJTpAUi6w6pXgXUWffende5FreQpnMFL1L4G-38wsI_-ISIOzdO8QIrXHxmtc1S5xzYu8bMqSgCinvCEwdeGFCmighRjj8t1zRWo0D14rHbQLPR_b1P5SvEeJTtS9Nm3iibM",
authSecret: "g2rWVHUCpUxgcL9Tz7vyeQ",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BCg6ZIGuE2ZNm2ti6Arf4CDVD_8--aLXAGLYhpghwjl1xxVjTLLpb7zihuEOGGbyt8Qj0_fYHBP4ObxwJNl56bk",
encryption: "salt=5LIDBXbvkBvvb7ZdD-T4PQ; rs=3",
encoding: "aesgcm",
},
},
{
desc: "Example from draft-ietf-httpbis-encryption-encoding-02",
result: "I am the walrus",
data: "6nqAQUME8hNqw5J3kl8cpVVJylXKYqZOeseZG8UueKpA",
authSecret: "R29vIGdvbyBnJyBqb29iIQ",
privateKey: {
kty: "EC",
crv: "P-256",
d: "9FWl15_QUQAWDaD3k3l50ZBZQJ4au27F1V4F0uLSD_M",
x: "ISQGPMvxncL6iLZDugTm3Y2n6nuiyMYuD3epQ_TC-pE",
y: "T21EEWyf0cQDQcakQMqz4hQKYOQ3il2nNZct4HgAUQU",
ext: true,
},
publicKey:
"BCEkBjzL8Z3C-oi2Q7oE5t2Np-p7osjGLg93qUP0wvqRT21EEWyf0cQDQcakQMqz4hQKYOQ3il2nNZct4HgAUQU",
headers: {
crypto_key:
'keyid="dhkey"; dh="BNoRDbb84JGm8g5Z5CFxurSqsXWJ11ItfXEWYVLE85Y7CYkDjXsIEc4aqxYaQ1G8BqkXCJ6DPpDrWtdWj_mugHU"',
encryption: 'keyid="dhkey"; salt="lngarbyKfMoi9Z75xYXmkg"',
encoding: "aesgcm",
},
},
];
for (let test of expectedSuccesses) {
await assertDecrypts(test, test.headers);
}
});
add_task(async function test_aesgcm_err() {
let expectedFailures = [
{
desc: "aesgcm128 message decrypted as aesgcm",
data: "fwkuwTTChcLnrzsbDI78Y2EoQzfnbMI8Ax9Z27_rwX8",
authSecret: "BhbpNTWyO5wVJmVKTV6XaA",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BCHn-I-J3dfPRLJBlNZ3xFoAqaBLZ6qdhpaz9W7Q00JW1oD-hTxyEECn6KYJNK8AxKUyIDwn6Icx_PYWJiEYjQ0",
encryption: "salt=c6JQl9eJ0VvwrUVCQDxY7Q",
encoding: "aesgcm",
},
expected: /Bad encryption/,
},
{
// The plaintext is "O hai". The ciphertext is exactly `rs + 16` bytes,
// but we didn't include the empty trailing block that aesgcm requires for
// exact multiples.
desc: "rs = 7, no trailing block",
data: "YG4F-b06y590hRlnSsw_vuOw62V9Iz8",
authSecret: "QoDi0u6vcslIVJKiouXMXw",
privateKey: {
kty: "EC",
crv: "P-256",
d: "2bu4paOAZbL2ef1u-wTzONuTIcDPc00o0zUJgg46XTc",
x: "uEvLZUMVn1my0cwnLdcFT0mj1gSU5uzI3HeGwXC7jX8",
y: "SfNVLGL-FurydsuzciDfw8K1cUHyoDWnJJ_16UG6Dbo",
ext: true,
},
publicKey:
"BLhLy2VDFZ9ZstHMJy3XBU9Jo9YElObsyNx3hsFwu41_SfNVLGL-FurydsuzciDfw8K1cUHyoDWnJJ_16UG6Dbo",
headers: {
crypto_key:
"dh=BD_bsTUpxBMvSv8eksith3vijMLj44D4jhJjO51y7wK1ytbUlsyYBBYYyB5AAe5bnREA_WipTgemDVz00LiWcfM",
encryption: "salt=xKWvs_jWWeg4KOsot_uBhA; rs=7",
encoding: "aesgcm",
},
expected: /Encrypted data truncated/,
},
{
// The last block is only 1 byte, but valid blocks must be at least 2 bytes.
desc: "Pad size > last block length",
data: "JvX9HsJ4lL5gzP8_uCKc6s15iRIaNhD4pFCgq5-dfwbUqEcNUkqv",
authSecret: "QtGZeY8MQfCaq-XwKOVGBQ",
privateKey: {
kty: "EC",
crv: "P-256",
d: "CosERAVXgvTvoh7UkrRC2V-iXoNs0bXle9I68qzkles",
x: "_D0YqEwirvTJQJdjG6xXrjstMVpeAzf221cUqZz6hgY",
y: "9MnFbM7U14uiYMDI5e2I4jN29tYmsM9F66QodhKmA-c",
ext: true,
},
publicKey:
"BPw9GKhMIq70yUCXYxusV647LTFaXgM39ttXFKmc-oYG9MnFbM7U14uiYMDI5e2I4jN29tYmsM9F66QodhKmA-c",
headers: {
crypto_key:
"dh=BBNZNEi5Ew_ID5S4Y9jWBi1NeVDje6Mjs7SDLViUn6A8VAZj-6X3QAuYQ3j20BblqjwTgYst7PRnY6UGrKyLbmU",
encryption: "salt=ot8hzbwOo6CYe6ZhdlwKtg; rs=6",
encoding: "aesgcm",
},
expected: /Decoded array is too short/,
},
{
// The last block is 3 bytes (2 bytes for the pad length; 1 byte of data),
// but claims its pad length is 2.
desc: "Padding length > last block length",
data: "oWSOFA-UO5oWq-kI79RHaFfwAejLiQJ4C7eTmrSTBl4gArLXfx7lZ-Y",
authSecret: "gKG_P6-de5pyzS8hyH_NyQ",
privateKey: {
kty: "EC",
crv: "P-256",
d: "9l-ahcBM-I0ykwbWiDS9KRrPdhyvTZ0SxKiPpj2aeaI",
x: "qx0tU4EDaQv6ayFA3xvLLBdMmn4mLxjn7SK6mIeIxeg",
y: "ymbMcmUOEyh_-rLrBsi26NG4UFCis2MTDs5FG2VdDPI",
ext: true,
},
publicKey:
"BKsdLVOBA2kL-mshQN8byywXTJp-Ji8Y5-0iupiHiMXoymbMcmUOEyh_-rLrBsi26NG4UFCis2MTDs5FG2VdDPI",
headers: {
crypto_key:
"dh=BKe2IBO_cwmEzQyTVscSbQcj0Y3uBSzGZ_mHlANMciS8uGpb7U8_Bw7TNdlYfpwWDLd0cxM8YYWNDbNJ_p2Rp4o",
encryption: "salt=z7QJ6UR89SiFRkd4RsC4Vg; rs=6",
encoding: "aesgcm",
},
expected: /Padding is wrong/,
},
{
// The first block has no padding, but claims its pad length is 1.
desc: "Non-zero padding",
data: "Qdvjh0LkZXKu_1Hvv56D0rOSF6Mww3y0F8xkxUNlwVu2U1iakOUUGRs",
authSecret: "cMpWQW58BrpDbJ8KqbS9ig",
privateKey: {
kty: "EC",
crv: "P-256",
d: "IzuaxLqFJmjSu8GjLCo2oEaDZjDButW4m4T0qx02XsM",
x: "Xy7vt_TJTynxwWsQyY069BcKmrhkRjhKPFuTi-AphoY",
y: "0M10IVM1ourR7Q5AUX2b2fgdmGyTWcYsdHcdFK_b4Hk",
ext: true,
},
publicKey:
"BF8u77f0yU8p8cFrEMmNOvQXCpq4ZEY4Sjxbk4vgKYaG0M10IVM1ourR7Q5AUX2b2fgdmGyTWcYsdHcdFK_b4Hk",
headers: {
crypto_key:
"dh=BBicj01QI0ryiFzAaty9VpW_crgq9XbU1bOCtEZI9UNE6tuOgp4lyN_UN0N905ECnLWK5v_sCPUIxnQgOuCseSo",
encryption: "salt=SbkGHONbQBBsBcj9dLyIUw; rs=6",
encoding: "aesgcm",
},
expected: /Padding is wrong/,
},
{
// The first record is 22 bytes: 2 bytes for the pad length, 4 bytes of
// data, and a 16-byte auth tag. The second "record" is missing the pad
// and data, and contains just the auth tag.
desc: "rs = 6, second record truncated to only auth tag",
data: "C7u3j5AL4Yzh2yYB_umN6tzrVHxrt7D5baTEW9DE1Bk3up9fY4w",
authSecret: "3rWhsRCU_KdaqfKPbd3zBQ",
privateKey: {
kty: "EC",
crv: "P-256",
d: "nhOT9171xuoQBJGkiZ3aqT5qw_ILJ94_PPiVNu1LFSY",
x: "lCj7ctQTmRfwzTMcODlNfHjFMAHmgdI44OhTQXX_xpE",
y: "WBdgz4GWGtGAisC63O9DtP5l--hnCzPZiV-YZ-a6Lcw",
ext: true,
},
publicKey:
"BJQo-3LUE5kX8M0zHDg5TXx4xTAB5oHSOODoU0F1_8aRWBdgz4GWGtGAisC63O9DtP5l--hnCzPZiV-YZ-a6Lcw",
headers: {
crypto_key:
"dh=BI38Qs_OhDmQIxbszc6Nako-MrX3FzAE_8HzxM1wgoEIG4ocxyF-YAAVhfkpJUvDpRyKW2LDHIaoylaZuxQfRhE",
encryption: "salt=QClh48OlvGpSjZ0Mg0e8rg; rs=6",
encoding: "aesgcm",
},
expected: /Decoded array is too short/,
},
];
for (let test of expectedFailures) {
await assertNotDecrypts(test, test.headers);
}
});
add_task(async function test_aesgcm128_ok() {
let expectedSuccesses = [
{
desc: "padSize = 1, rs = 4096, pad = 2",
result: "aesgcm128 encrypted message",
data: "ljBJ44NPzJFH9EuyT5xWMU4vpZ90MdAqaq1TC1kOLRoPNHtNFXeJ0GtuSaE",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
encryption_key:
"dh=BOmnfg02vNd6RZ7kXWWrCGFF92bI-rQ-bV0Pku3-KmlHwbGv4ejWqgasEdLGle5Rhmp6SKJunZw2l2HxKvrIjfI",
encryption: "salt=btxxUtclbmgcc30b9rT3Bg; rs=4096",
encoding: "aesgcm128",
},
},
];
for (let test of expectedSuccesses) {
await assertDecrypts(test, test.headers);
}
});
add_task(async function test_aesgcm128_err() {
let expectedFailures = [
{
// aesgcm128 doesn't use an auth secret, but we've mixed one in during
// encryption, so the decryption key and nonce won't match.
desc: "padSize = 1, rs = 4096, auth secret, pad = 8",
data: "h0FmyldY8aT5EQ6CJrbfRn_IdDvytoLeHb9_q5CjtdFRfgDRknxLmOzavLaVG4oOiS0r",
authSecret: "Sxb6u0gJIhGEogyLawjmCw",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BCXHk7O8CE-9AOp6xx7g7c-NCaNpns1PyyHpdcmDaijLbT6IdGq0ezGatBwtFc34BBfscFxdk4Tjksa2Mx5rRCM",
encryption: "salt=aGBpoKklLtrLcAUCcCr7JQ",
encoding: "aesgcm128",
},
expected: /Missing Encryption-Key header/,
},
{
// The first byte of each record must be the pad length.
desc: "Missing padding",
data: "anvsHj7oBQTPMhv7XSJEsvyMS4-8EtbC7HgFZsKaTg",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BMSqfc3ohqw2DDgu3nsMESagYGWubswQPGxrW1bAbYKD18dIHQBUmD3ul_lu7MyQiT5gNdzn5JTXQvCcpf-oZE4",
encryption: "salt=Czx2i18rar8XWOXAVDnUuw",
encoding: "aesgcm128",
},
expected: /Missing Encryption-Key header/,
},
{
desc: "Truncated input",
data: "AlDjj6NvT5HGyrHbT8M5D6XBFSra6xrWS9B2ROaCIjwSu3RyZ1iyuv0",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BCHn-I-J3dfPRLJBlNZ3xFoAqaBLZ6qdhpaz9W7Q00JW1oD-hTxyEECn6KYJNK8AxKUyIDwn6Icx_PYWJiEYjQ0",
encryption: "salt=c6JQl9eJ0VvwrUVCQDxY7Q; rs=25",
encoding: "aesgcm128",
},
expected: /Missing Encryption-Key header/,
},
{
desc: "Padding length > rs",
data: "Ct_h1g7O55e6GvuhmpjLsGnv8Rmwvxgw8iDESNKGxk_8E99iHKDzdV8wJPyHA-6b2E6kzuVa5UWiQ7s4Zms1xzJ4FKgoxvBObXkc_r_d4mnb-j245z3AcvRmcYGk5_HZ0ci26SfhAN3lCgxGzTHS4nuHBRkGwOb4Tj4SFyBRlLoTh2jyVK2jYugNjH9tTrGOBg7lP5lajLTQlxOi91-RYZSfFhsLX3LrAkXuRoN7G1CdiI7Y3_eTgbPIPabDcLCnGzmFBTvoJSaQF17huMl_UnWoCj2WovA4BwK_TvWSbdgElNnQ4CbArJ1h9OqhDOphVu5GUGr94iitXRQR-fqKPMad0ULLjKQWZOnjuIdV1RYEZ873r62Yyd31HoveJcSDb1T8l_QK2zVF8V4k0xmK9hGuC0rF5YJPYPHgl5__usknzxMBnRrfV5_MOL5uPZwUEFsu",
privateKey: LEGACY_PRIVATE_KEY,
publicKey: LEGACY_PUBLIC_KEY,
headers: {
crypto_key:
"dh=BAcMdWLJRGx-kPpeFtwqR3GE1LWzd1TYh2rg6CEFu53O-y3DNLkNe_BtGtKRR4f7ZqpBMVS6NgfE2NwNPm3Ndls",
encryption: "salt=NQVTKhB0rpL7ZzKkotTGlA; rs=1",
encoding: "aesgcm128",
},
expected: /Missing Encryption-Key header/,
},
];
for (let test of expectedFailures) {
await assertNotDecrypts(test, test.headers);
}
});