summaryrefslogtreecommitdiff
path: root/jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js
diff options
context:
space:
mode:
Diffstat (limited to 'jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js')
-rw-r--r--jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js608
1 files changed, 608 insertions, 0 deletions
diff --git a/jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js b/jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js
new file mode 100644
index 0000000..9e9474a
--- /dev/null
+++ b/jitsi-meet/libs/lib-jitsi-meet.e2ee-worker.js
@@ -0,0 +1,608 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./modules/e2ee/crypto-utils.js
+/**
+ * Derives a set of keys from the master key.
+ * @param {CryptoKey} material - master key to derive from
+ *
+ * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
+ */
+async function deriveKeys(material) {
+ const info = new ArrayBuffer();
+ const textEncoder = new TextEncoder();
+
+ // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey#HKDF
+ // https://developer.mozilla.org/en-US/docs/Web/API/HkdfParams
+ const encryptionKey = await crypto.subtle.deriveKey({
+ name: 'HKDF',
+ salt: textEncoder.encode('JFrameEncryptionKey'),
+ hash: 'SHA-256',
+ info
+ }, material, {
+ name: 'AES-CTR',
+ length: 128
+ }, false, [ 'encrypt', 'decrypt' ]);
+ const authenticationKey = await crypto.subtle.deriveKey({
+ name: 'HKDF',
+ salt: textEncoder.encode('JFrameAuthenticationKey'),
+ hash: 'SHA-256',
+ info
+ }, material, {
+ name: 'HMAC',
+ hash: 'SHA-256'
+ }, false, [ 'sign' ]);
+ const saltKey = await crypto.subtle.deriveBits({
+ name: 'HKDF',
+ salt: textEncoder.encode('JFrameSaltKey'),
+ hash: 'SHA-256',
+ info
+ }, material, 128);
+
+ return {
+ material,
+ encryptionKey,
+ authenticationKey,
+ saltKey
+ };
+}
+
+/**
+ * Ratchets a key. See
+ * https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.5.1
+ * @param {CryptoKey} material - base key material
+ * @returns {ArrayBuffer} - ratcheted key material
+ */
+async function ratchet(material) {
+ const textEncoder = new TextEncoder();
+
+ // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveBits
+ return crypto.subtle.deriveBits({
+ name: 'HKDF',
+ salt: textEncoder.encode('JFrameRatchetKey'),
+ hash: 'SHA-256',
+ info: new ArrayBuffer()
+ }, material, 256);
+}
+
+/**
+ * Converts a raw key into a WebCrypto key object with default options
+ * suitable for our usage.
+ * @param {ArrayBuffer} keyBytes - raw key
+ * @param {Array} keyUsages - key usages, see importKey documentation
+ * @returns {CryptoKey} - the WebCrypto key.
+ */
+async function importKey(keyBytes) {
+ // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+ return crypto.subtle.importKey('raw', keyBytes, 'HKDF', false, [ 'deriveBits', 'deriveKey' ]);
+}
+
+// CONCATENATED MODULE: ./modules/e2ee/utils.js
+/**
+ * Polyfill RTCEncoded(Audio|Video)Frame.getMetadata() (not available in M83, available M84+).
+ * The polyfill can not be done on the prototype since its not exposed in workers. Instead,
+ * it is done as another transformation to keep it separate.
+ * TODO: remove when we decode to drop M83 support.
+ */
+function polyFillEncodedFrameMetadata(encodedFrame, controller) {
+ if (!encodedFrame.getMetadata) {
+ encodedFrame.getMetadata = function() {
+ return {
+ // TODO: provide a more complete polyfill based on additionalData for video.
+ synchronizationSource: this.synchronizationSource,
+ contributingSources: this.contributingSources
+ };
+ };
+ }
+ controller.enqueue(encodedFrame);
+}
+
+/**
+ * Compares two byteArrays for equality.
+ */
+function isArrayEqual(a1, a2) {
+ if (a1.byteLength !== a2.byteLength) {
+ return false;
+ }
+ for (let i = 0; i < a1.byteLength; i++) {
+ if (a1[i] !== a2[i]) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+// CONCATENATED MODULE: ./modules/e2ee/Context.js
+/* eslint-disable no-bitwise */
+/* global BigInt */
+
+
+
+
+// We use a ringbuffer of keys so we can change them and still decode packets that were
+// encrypted with an old key. We use a size of 16 which corresponds to the four bits
+// in the frame trailer.
+const keyRingSize = 16;
+
+// We copy the first bytes of the VP8 payload unencrypted.
+// For keyframes this is 10 bytes, for non-keyframes (delta) 3. See
+// https://tools.ietf.org/html/rfc6386#section-9.1
+// This allows the bridge to continue detecting keyframes (only one byte needed in the JVB)
+// and is also a bit easier for the VP8 decoder (i.e. it generates funny garbage pictures
+// instead of being unable to decode).
+// This is a bit for show and we might want to reduce to 1 unconditionally in the final version.
+//
+// For audio (where frame.type is not set) we do not encrypt the opus TOC byte:
+// https://tools.ietf.org/html/rfc6716#section-3.1
+const unencryptedBytes = {
+ key: 10,
+ delta: 3,
+ undefined: 1 // frame.type is not set on audio
+};
+
+// Use truncated SHA-256 hashes, 80 bіts for video, 32 bits for audio.
+// This follows the same principles as DTLS-SRTP.
+const authenticationTagOptions = {
+ name: 'HMAC',
+ hash: 'SHA-256'
+};
+const digestLength = {
+ key: 10,
+ delta: 10,
+ undefined: 4 // frame.type is not set on audio
+};
+
+// Maximum number of forward ratchets to attempt when the authentication
+// tag on a remote packet does not match the current key.
+const ratchetWindow = 8;
+
+/**
+ * Per-participant context holding the cryptographic keys and
+ * encode/decode functions
+ */
+class Context_Context {
+ /**
+ * @param {string} id - local muc resourcepart
+ */
+ constructor(id) {
+ // An array (ring) of keys that we use for sending and receiving.
+ this._cryptoKeyRing = new Array(keyRingSize);
+
+ // A pointer to the currently used key.
+ this._currentKeyIndex = -1;
+
+ // A per-sender counter that is used create the AES CTR.
+ // Must be incremented on every frame that is sent, can be reset on
+ // key changes.
+ this._sendCount = BigInt(0); // eslint-disable-line new-cap
+
+ this._id = id;
+ }
+
+ /**
+ * Derives the different subkeys and starts using them for encryption or
+ * decryption.
+ * @param {Uint8Array|false} key bytes. Pass false to disable.
+ * @param {Number} keyIndex
+ */
+ async setKey(keyBytes, keyIndex) {
+ let newKey;
+
+ if (keyBytes) {
+ const material = await importKey(keyBytes);
+
+ newKey = await deriveKeys(material);
+ } else {
+ newKey = false;
+ }
+ this._currentKeyIndex = keyIndex % this._cryptoKeyRing.length;
+ this._setKeys(newKey);
+ }
+
+ /**
+ * Sets a set of keys and resets the sendCount.
+ * decryption.
+ * @param {Object} keys set of keys.
+ * @private
+ */
+ _setKeys(keys) {
+ this._cryptoKeyRing[this._currentKeyIndex] = keys;
+ this._sendCount = BigInt(0); // eslint-disable-line new-cap
+ }
+
+ /**
+ * Function that will be injected in a stream and will encrypt the given encoded frames.
+ *
+ * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
+ * @param {TransformStreamDefaultController} controller - TransportStreamController.
+ *
+ * The packet format is a variant of
+ * https://tools.ietf.org/html/draft-omara-sframe-00
+ * using a trailer instead of a header. One of the design goals was to not require
+ * changes to the SFU which for video requires not encrypting the keyframe bit of VP8
+ * as SFUs need to detect a keyframe (framemarking or the generic frame descriptor will
+ * solve this eventually). This also "hides" that a client is using E2EE a bit.
+ *
+ * Note that this operates on the full frame, i.e. for VP8 the data described in
+ * https://tools.ietf.org/html/rfc6386#section-9.1
+ *
+ * The VP8 payload descriptor described in
+ * https://tools.ietf.org/html/rfc7741#section-4.2
+ * is part of the RTP packet and not part of the encoded frame and is therefore not
+ * controllable by us. This is fine as the SFU keeps having access to it for routing.
+ */
+ encodeFunction(encodedFrame, controller) {
+ const keyIndex = this._currentKeyIndex;
+
+ if (this._cryptoKeyRing[keyIndex]) {
+ this._sendCount++;
+
+ // Thіs is not encrypted and contains the VP8 payload descriptor or the Opus TOC byte.
+ const frameHeader = new Uint8Array(encodedFrame.data, 0, unencryptedBytes[encodedFrame.type]);
+
+ // Construct frame trailer. Similar to the frame header described in
+ // https://tools.ietf.org/html/draft-omara-sframe-00#section-4.2
+ // but we put it at the end.
+ // 0 1 2 3 4 5 6 7
+ // ---------+---------------------------------+-+-+-+-+-+-+-+-+
+ // payload | CTR... (length=LEN) |S|LEN |KID |
+ // ---------+---------------------------------+-+-+-+-+-+-+-+-+
+ const counter = new Uint8Array(16);
+ const counterView = new DataView(counter.buffer);
+
+ // The counter is encoded as a variable-length field.
+ counterView.setBigUint64(8, this._sendCount);
+ let counterLength = 8;
+
+ for (let i = 8; i < counter.byteLength; i++ && counterLength--) {
+ if (counterView.getUint8(i) !== 0) {
+ break;
+ }
+ }
+
+ const frameTrailer = new Uint8Array(counterLength + 1);
+
+ frameTrailer.set(new Uint8Array(counter.buffer, counter.byteLength - counterLength));
+
+ // Since we never send a counter of 0 we send counterLength - 1 on the wire.
+ // This is different from the sframe draft, increases the key space and lets us
+ // ignore the case of a zero-length counter at the receiver.
+ frameTrailer[frameTrailer.byteLength - 1] = keyIndex | ((counterLength - 1) << 4);
+
+ // XOR the counter with the saltKey to construct the AES CTR.
+ const saltKey = new DataView(this._cryptoKeyRing[keyIndex].saltKey);
+
+ for (let i = 0; i < counter.byteLength; i++) {
+ counterView.setUint8(i, counterView.getUint8(i) ^ saltKey.getUint8(i));
+ }
+
+ return crypto.subtle.encrypt({
+ name: 'AES-CTR',
+ counter,
+ length: 64
+ }, this._cryptoKeyRing[keyIndex].encryptionKey, new Uint8Array(encodedFrame.data,
+ unencryptedBytes[encodedFrame.type]))
+ .then(cipherText => {
+ const newData = new ArrayBuffer(frameHeader.byteLength + cipherText.byteLength
+ + digestLength[encodedFrame.type] + frameTrailer.byteLength);
+ const newUint8 = new Uint8Array(newData);
+
+ newUint8.set(frameHeader); // copy first bytes.
+ newUint8.set(new Uint8Array(cipherText), unencryptedBytes[encodedFrame.type]); // add ciphertext.
+ // Leave some space for the authentication tag. This is filled with 0s initially, similar to
+ // STUN message-integrity described in https://tools.ietf.org/html/rfc5389#section-15.4
+ newUint8.set(frameTrailer, frameHeader.byteLength + cipherText.byteLength
+ + digestLength[encodedFrame.type]); // append trailer.
+
+ return crypto.subtle.sign(authenticationTagOptions, this._cryptoKeyRing[keyIndex].authenticationKey,
+ new Uint8Array(newData)).then(authTag => {
+ // Set the truncated authentication tag.
+ newUint8.set(new Uint8Array(authTag, 0, digestLength[encodedFrame.type]),
+ unencryptedBytes[encodedFrame.type] + cipherText.byteLength);
+ encodedFrame.data = newData;
+
+ return controller.enqueue(encodedFrame);
+ });
+ }, e => {
+ // TODO: surface this to the app.
+ console.error(e);
+
+ // We are not enqueuing the frame here on purpose.
+ });
+ }
+
+ /* NOTE WELL:
+ * This will send unencrypted data (only protected by DTLS transport encryption) when no key is configured.
+ * This is ok for demo purposes but should not be done once this becomes more relied upon.
+ */
+ controller.enqueue(encodedFrame);
+ }
+
+ /**
+ * Function that will be injected in a stream and will decrypt the given encoded frames.
+ *
+ * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
+ * @param {TransformStreamDefaultController} controller - TransportStreamController.
+ */
+ async decodeFunction(encodedFrame, controller) {
+ const data = new Uint8Array(encodedFrame.data);
+ const keyIndex = data[encodedFrame.data.byteLength - 1] & 0xf; // lower four bits.
+
+ if (this._cryptoKeyRing[keyIndex]) {
+ const counterLength = 1 + ((data[encodedFrame.data.byteLength - 1] >> 4) & 0x7);
+ const frameHeader = new Uint8Array(encodedFrame.data, 0, unencryptedBytes[encodedFrame.type]);
+
+ // Extract the truncated authentication tag.
+ const authTagOffset = encodedFrame.data.byteLength - (digestLength[encodedFrame.type]
+ + counterLength + 1);
+ const authTag = encodedFrame.data.slice(authTagOffset, authTagOffset
+ + digestLength[encodedFrame.type]);
+
+ // Set authentication tag bytes to 0.
+ const zeros = new Uint8Array(digestLength[encodedFrame.type]);
+
+ data.set(zeros, encodedFrame.data.byteLength - (digestLength[encodedFrame.type] + counterLength + 1));
+
+ // Do truncated hash comparison. If the hash does not match we might have to advance the
+ // ratchet a limited number of times. See (even though the description there is odd)
+ // https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.5.1
+ let { authenticationKey, material } = this._cryptoKeyRing[keyIndex];
+ let valid = false;
+ let newKeys = null;
+
+ for (let distance = 0; distance < ratchetWindow; distance++) {
+ const calculatedTag = await crypto.subtle.sign(authenticationTagOptions,
+ authenticationKey, encodedFrame.data);
+
+ if (isArrayEqual(new Uint8Array(authTag),
+ new Uint8Array(calculatedTag.slice(0, digestLength[encodedFrame.type])))) {
+ valid = true;
+ if (distance > 0) {
+ this._setKeys(newKeys);
+ }
+ break;
+ }
+
+ // Attempt to ratchet and generate the next set of keys.
+ material = await importKey(await ratchet(material));
+ newKeys = await deriveKeys(material);
+ authenticationKey = newKeys.authenticationKey;
+ }
+
+ // Check whether we found a valid signature.
+ if (!valid) {
+ // TODO: return an error to the app.
+
+ console.error('Authentication tag mismatch');
+
+ return;
+ }
+
+ // Extract the counter.
+ const counter = new Uint8Array(16);
+
+ counter.set(data.slice(encodedFrame.data.byteLength - (counterLength + 1),
+ encodedFrame.data.byteLength - 1), 16 - counterLength);
+ const counterView = new DataView(counter.buffer);
+
+ // XOR the counter with the saltKey to construct the AES CTR.
+ const saltKey = new DataView(this._cryptoKeyRing[keyIndex].saltKey);
+
+ for (let i = 0; i < counter.byteLength; i++) {
+ counterView.setUint8(i,
+ counterView.getUint8(i) ^ saltKey.getUint8(i));
+ }
+
+ return crypto.subtle.decrypt({
+ name: 'AES-CTR',
+ counter,
+ length: 64
+ }, this._cryptoKeyRing[keyIndex].encryptionKey, new Uint8Array(encodedFrame.data,
+ unencryptedBytes[encodedFrame.type],
+ encodedFrame.data.byteLength - (unencryptedBytes[encodedFrame.type]
+ + digestLength[encodedFrame.type] + counterLength + 1))
+ ).then(plainText => {
+ const newData = new ArrayBuffer(unencryptedBytes[encodedFrame.type] + plainText.byteLength);
+ const newUint8 = new Uint8Array(newData);
+
+ newUint8.set(frameHeader);
+ newUint8.set(new Uint8Array(plainText), unencryptedBytes[encodedFrame.type]);
+ encodedFrame.data = newData;
+
+ return controller.enqueue(encodedFrame);
+ }, e => {
+ console.error(e);
+
+ // TODO: notify the application about error status.
+ // TODO: For video we need a better strategy since we do not want to based any
+ // non-error frames on a garbage keyframe.
+ if (encodedFrame.type === undefined) { // audio, replace with silence.
+ const newData = new ArrayBuffer(3);
+ const newUint8 = new Uint8Array(newData);
+
+ newUint8.set([ 0xd8, 0xff, 0xfe ]); // opus silence frame.
+ encodedFrame.data = newData;
+ controller.enqueue(encodedFrame);
+ }
+ });
+ } else if (keyIndex >= this._cryptoKeyRing.length && this._cryptoKeyRing[this._currentKeyIndex]) {
+ // If we are encrypting but don't have a key for the remote drop the frame.
+ // This is a heuristic since we don't know whether a packet is encrypted,
+ // do not have a checksum and do not have signaling for whether a remote participant does
+ // encrypt or not.
+ return;
+ }
+
+ // TODO: this just passes through to the decoder. Is that ok? If we don't know the key yet
+ // we might want to buffer a bit but it is still unclear how to do that (and for how long etc).
+ controller.enqueue(encodedFrame);
+ }
+}
+
+// CONCATENATED MODULE: ./modules/e2ee/Worker.js
+/* global TransformStream */
+/* eslint-disable no-bitwise */
+
+// Worker for E2EE/Insertable streams.
+//
+
+
+
+
+const contexts = new Map(); // Map participant id => context
+
+onmessage = async event => {
+ const { operation } = event.data;
+
+ if (operation === 'encode') {
+ const { readableStream, writableStream, participantId } = event.data;
+
+ if (!contexts.has(participantId)) {
+ contexts.set(participantId, new Context_Context(participantId));
+ }
+ const context = contexts.get(participantId);
+ const transformStream = new TransformStream({
+ transform: context.encodeFunction.bind(context)
+ });
+
+ readableStream
+ .pipeThrough(new TransformStream({
+ transform: polyFillEncodedFrameMetadata // M83 polyfill.
+ }))
+ .pipeThrough(transformStream)
+ .pipeTo(writableStream);
+ } else if (operation === 'decode') {
+ const { readableStream, writableStream, participantId } = event.data;
+
+ if (!contexts.has(participantId)) {
+ contexts.set(participantId, new Context_Context(participantId));
+ }
+ const context = contexts.get(participantId);
+ const transformStream = new TransformStream({
+ transform: context.decodeFunction.bind(context)
+ });
+
+ readableStream
+ .pipeThrough(new TransformStream({
+ transform: polyFillEncodedFrameMetadata // M83 polyfill.
+ }))
+ .pipeThrough(transformStream)
+ .pipeTo(writableStream);
+ } else if (operation === 'setKey') {
+ const { participantId, key, keyIndex } = event.data;
+
+ if (!contexts.has(participantId)) {
+ contexts.set(participantId, new Context_Context(participantId));
+ }
+ const context = contexts.get(participantId);
+
+ if (key) {
+ context.setKey(key, keyIndex);
+ } else {
+ context.setKey(false, keyIndex);
+ }
+ } else if (operation === 'cleanup') {
+ const { participantId } = event.data;
+
+ contexts.delete(participantId);
+ } else {
+ console.error('e2ee worker', operation);
+ }
+};
+
+
+/***/ })
+/******/ ]); \ No newline at end of file