diff options
Diffstat (limited to 'dom/push/test/webpush.js')
| -rw-r--r-- | dom/push/test/webpush.js | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/dom/push/test/webpush.js b/dom/push/test/webpush.js new file mode 100644 index 0000000000..91bc0fce85 --- /dev/null +++ b/dom/push/test/webpush.js @@ -0,0 +1,230 @@ +/* + * Browser-based Web Push client for the application server piece. + * + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + * + * Uses the WebCrypto API. + * + * Note that this test file uses the old, deprecated aesgcm128 encryption + * scheme. PushCrypto.encrypt() exists and uses the later aes128gcm, but + * there's no good reason to upgrade this at this time (and having mochitests + * use PushCrypto directly is easier said than done.) + */ + +(function(g) { + "use strict"; + + var P256DH = { + name: "ECDH", + namedCurve: "P-256", + }; + var webCrypto = g.crypto.subtle; + var ENCRYPT_INFO = new TextEncoder("utf-8").encode( + "Content-Encoding: aesgcm128" + ); + var NONCE_INFO = new TextEncoder("utf-8").encode("Content-Encoding: nonce"); + + function chunkArray(array, size) { + var start = array.byteOffset || 0; + array = array.buffer || array; + var index = 0; + var result = []; + while (index + size <= array.byteLength) { + result.push(new Uint8Array(array, start + index, size)); + index += size; + } + if (index < array.byteLength) { + result.push(new Uint8Array(array, start + index)); + } + return result; + } + + /* I can't believe that this is needed here, in this day and age ... + * Note: these are not efficient, merely expedient. + */ + var base64url = { + _strmap: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", + encode(data) { + data = new Uint8Array(data); + var len = Math.ceil((data.length * 4) / 3); + return chunkArray(data, 3) + .map(chunk => + [ + chunk[0] >>> 2, + ((chunk[0] & 0x3) << 4) | (chunk[1] >>> 4), + ((chunk[1] & 0xf) << 2) | (chunk[2] >>> 6), + chunk[2] & 0x3f, + ] + .map(v => base64url._strmap[v]) + .join("") + ) + .join("") + .slice(0, len); + }, + _lookup(s, i) { + return base64url._strmap.indexOf(s.charAt(i)); + }, + decode(str) { + var v = new Uint8Array(Math.floor((str.length * 3) / 4)); + var vi = 0; + for (var si = 0; si < str.length; ) { + var w = base64url._lookup(str, si++); + var x = base64url._lookup(str, si++); + var y = base64url._lookup(str, si++); + var z = base64url._lookup(str, si++); + v[vi++] = (w << 2) | (x >>> 4); + v[vi++] = (x << 4) | (y >>> 2); + v[vi++] = (y << 6) | z; + } + return v; + }, + }; + + g.base64url = base64url; + + /* Coerces data into a Uint8Array */ + function ensureView(data) { + if (typeof data === "string") { + return new TextEncoder("utf-8").encode(data); + } + if (data instanceof ArrayBuffer) { + return new Uint8Array(data); + } + if (ArrayBuffer.isView(data)) { + return new Uint8Array(data.buffer); + } + throw new Error("webpush() needs a string or BufferSource"); + } + + function bsConcat(arrays) { + var size = arrays.reduce((total, a) => total + a.byteLength, 0); + var index = 0; + return arrays.reduce((result, a) => { + result.set(new Uint8Array(a), index); + index += a.byteLength; + return result; + }, new Uint8Array(size)); + } + + function hmac(key) { + this.keyPromise = webCrypto.importKey( + "raw", + key, + { name: "HMAC", hash: "SHA-256" }, + false, + ["sign"] + ); + } + hmac.prototype.hash = function(input) { + return this.keyPromise.then(k => webCrypto.sign("HMAC", k, input)); + }; + + function hkdf(salt, ikm) { + this.prkhPromise = new hmac(salt).hash(ikm).then(prk => new hmac(prk)); + } + + hkdf.prototype.generate = function(info, len) { + var input = bsConcat([info, new Uint8Array([1])]); + return this.prkhPromise + .then(prkh => prkh.hash(input)) + .then(h => { + if (h.byteLength < len) { + throw new Error("Length is too long"); + } + return h.slice(0, len); + }); + }; + + /* generate a 96-bit IV for use in GCM, 48-bits of which are populated */ + function generateNonce(base, index) { + var nonce = base.slice(0, 12); + for (var i = 0; i < 6; ++i) { + nonce[nonce.length - 1 - i] ^= (index / Math.pow(256, i)) & 0xff; + } + return nonce; + } + + function encrypt(localKey, remoteShare, salt, data) { + return webCrypto + .importKey("raw", remoteShare, P256DH, false, ["deriveBits"]) + .then(remoteKey => + webCrypto.deriveBits( + { name: P256DH.name, public: remoteKey }, + localKey, + 256 + ) + ) + .then(rawKey => { + var kdf = new hkdf(salt, rawKey); + return Promise.all([ + kdf + .generate(ENCRYPT_INFO, 16) + .then(gcmBits => + webCrypto.importKey("raw", gcmBits, "AES-GCM", false, ["encrypt"]) + ), + kdf.generate(NONCE_INFO, 12), + ]); + }) + .then(([key, nonce]) => { + if (data.byteLength === 0) { + // Send an authentication tag for empty messages. + return webCrypto + .encrypt( + { + name: "AES-GCM", + iv: generateNonce(nonce, 0), + }, + key, + new Uint8Array([0]) + ) + .then(value => [value]); + } + // 4096 is the default size, though we burn 1 for padding + return Promise.all( + chunkArray(data, 4095).map((slice, index) => { + var padded = bsConcat([new Uint8Array([0]), slice]); + return webCrypto.encrypt( + { + name: "AES-GCM", + iv: generateNonce(nonce, index), + }, + key, + padded + ); + }) + ); + }) + .then(bsConcat); + } + + function webPushEncrypt(subscription, data) { + data = ensureView(data); + + var salt = g.crypto.getRandomValues(new Uint8Array(16)); + return webCrypto + .generateKey(P256DH, false, ["deriveBits"]) + .then(localKey => { + return Promise.all([ + encrypt( + localKey.privateKey, + subscription.getKey("p256dh"), + salt, + data + ), + // 1337 p-256 specific haxx to get the raw value out of the spki value + webCrypto.exportKey("raw", localKey.publicKey), + ]); + }) + .then(([payload, pubkey]) => { + return { + data: base64url.encode(payload), + encryption: "keyid=p256dh;salt=" + base64url.encode(salt), + encryption_key: "keyid=p256dh;dh=" + base64url.encode(pubkey), + encoding: "aesgcm128", + }; + }); + } + + g.webPushEncrypt = webPushEncrypt; +})(this); |