API tools faq
paste
Advertisement
krot

converse-otr.js

krot
Jun 10th, 2019
527
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 24.05 KB | None | 0 0
raw download clone embed print report
  1. // Converse.js (A browser based XMPP chat client)
  2. // http://conversejs.org
  3. //
  4. // Copyright (c) 2012-2017, Jan-Carel Brand <jc@opkode.com>
  5. // Licensed under the Mozilla Public License (MPLv2)
  6. //
  7. /*global define, window, crypto, CryptoJS */
  8.  
  9. /* This is a Converse.js plugin which add support Off-the-record (OTR)
  10.  * encryption of one-on-one chat messages.
  11.  */
  12. (function (root, factory) {
  13.  
  14.     define([ "converse-chatview",
  15.             "tpl!toolbar_otr",
  16.             'otr'
  17.     ], factory);
  18. }(this, function (converse, tpl_toolbar_otr, otr) {
  19.     "use strict";
  20.  
  21.     const { Strophe, utils, b64_sha1, _ } = converse.env;
  22.  
  23.     const HAS_CSPRNG = _.isUndefined(window.crypto) ? false : (
  24.         _.isFunction(window.crypto.randomBytes) ||
  25.         _.isFunction(window.crypto.getRandomValues)
  26.     );
  27.  
  28.     const HAS_CRYPTO = HAS_CSPRNG && (
  29.         (!_.isUndefined(otr.OTR)) &&
  30.         (!_.isUndefined(otr.DSA))
  31.     );
  32.  
  33.     const UNENCRYPTED = 0;
  34.     const UNVERIFIED= 1;
  35.     const VERIFIED= 2;
  36.     const FINISHED = 3;
  37.  
  38.     const OTR_TRANSLATED_MAPPING  = {}; // Populated in initialize
  39.     const OTR_CLASS_MAPPING = {};
  40.     OTR_CLASS_MAPPING[UNENCRYPTED] = 'unencrypted';
  41.     OTR_CLASS_MAPPING[UNVERIFIED] = 'unverified';
  42.     OTR_CLASS_MAPPING[VERIFIED] = 'verified';
  43.     OTR_CLASS_MAPPING[FINISHED] = 'finished';
  44.  
  45.  
  46.     converse.plugins.add('converse-otr', {
  47.         /* Plugin dependencies are other plugins which might be
  48.          * overridden or relied upon, and therefore need to be loaded before
  49.          * this plugin.
  50.          *
  51.          * If the setting "strict_plugin_dependencies" is set to true,
  52.          * an error will be raised if the plugin is not found. By default it's
  53.          * false, which means these plugins are only loaded opportunistically.
  54.          *
  55.          * NB: These plugins need to have already been loaded via require.js.
  56.          */
  57.         dependencies: ["converse-chatview"],
  58.  
  59.         overrides: {
  60.             // Overrides mentioned here will be picked up by converse.js's
  61.             // plugin architecture they will replace existing methods on the
  62.             // relevant objects or classes.
  63.             //
  64.             // New functions which don't exist yet can also be added.
  65.  
  66.             ChatBox: {
  67.                 initialize () {
  68.                     this.__super__.initialize.apply(this, arguments);
  69.                     if (this.get('box_id') !== 'controlbox') {
  70.                         this.save({'otr_status': this.get('otr_status') || UNENCRYPTED});
  71.                     }
  72.                 },
  73.  
  74.                 shouldPlayNotification ($message) {
  75.                     /* Don't play a notification if this is an OTR message but
  76.                      * encryption is not yet set up. That would mean that the
  77.                      * OTR session is still being established, so there are no
  78.                      * "visible" OTR messages being exchanged.
  79.                      */
  80.                     return this.__super__.shouldPlayNotification.apply(this, arguments) &&
  81.                         !(utils.isOTRMessage($message[0]) && !_.includes([UNVERIFIED, VERIFIED], this.get('otr_status')));
  82.                 },
  83.  
  84.                 createMessage (message, delay, original_stanza) {
  85.                     const { _converse } = this.__super__,
  86.                         text = _.propertyOf(message.querySelector('body'))('textContent');
  87.  
  88.                     if ((!text) || (!_converse.allow_otr)) {
  89.                         return this.__super__.createMessage.apply(this, arguments);
  90.                     }
  91.  
  92.                     if (utils.isNewMessage(original_stanza)) {
  93.                         if (text.match(/^\?OTRv23?/)) {
  94.                             return this.initiateOTR(text);
  95.                         } else if (_.includes([UNVERIFIED, VERIFIED], this.get('otr_status'))) {
  96.                             return this.otr.receiveMsg(text);
  97.                         } else if (text.match(/^\?OTR/)) {
  98.                             if (!this.otr) {
  99.                                 return this.initiateOTR(text);
  100.                             } else {
  101.                                 return this.otr.receiveMsg(text);
  102.                             }
  103.                         }
  104.                     }
  105.                     // Normal unencrypted message (or archived message)
  106.                     return this.__super__.createMessage.apply(this, arguments);
  107.                 },
  108.  
  109.                 generatePrivateKey (instance_tag) {
  110.                     const { _converse } = this.__super__;
  111.                     const key = new otr.DSA();
  112.                     const { jid } = _converse.connection;
  113.                     if (_converse.cache_otr_key) {
  114.                         this.save({
  115.                             'otr_priv_key': key.packPrivate(),
  116.                             'otr_instance_tag': instance_tag
  117.                         });
  118.                     }
  119.                     return key;
  120.                 },
  121.  
  122.                 getSession (callback) {
  123.                     const { _converse } = this.__super__,
  124.                         { __ } = _converse;
  125.                     let instance_tag, saved_key, encrypted_key;
  126.                     if (_converse.cache_otr_key) {
  127.                         encrypted_key = this.get('otr_priv_key');
  128.                         if (_.isString(encrypted_key)) {
  129.                             instance_tag = this.get('otr_instance_tag');
  130.                             saved_key = otr.DSA.parsePrivate(encrypted_key);
  131.                             if (saved_key && instance_tag) {
  132.                                 this.trigger('showHelpMessages', [__('Re-establishing encrypted session')]);
  133.                                 callback({
  134.                                     'key': saved_key,
  135.                                     'instance_tag': instance_tag
  136.                                 });
  137.                                 return; // Our work is done here
  138.                             }
  139.                         }
  140.                     }
  141.                     // We need to generate a new key and instance tag
  142.                     this.trigger('showHelpMessages', [
  143.                         __('Generating private key.'),
  144.                         __('Your browser might become unresponsive.')],
  145.                         null,
  146.                         true // show spinner
  147.                     );
  148.                     const that = this;
  149.                     window.setTimeout(function () {
  150.                         callback({
  151.                             'key': that.generatePrivateKey(instance_tag),
  152.                             'instance_tag': otr.OTR.makeInstanceTag()
  153.                         });
  154.                     }, 500);
  155.                 },
  156.  
  157.                 updateOTRStatus (state) {
  158.                     switch (state) {
  159.                         case otr.OTR.CONST.STATUS_AKE_SUCCESS:
  160.                             if (this.otr.msgstate === otr.OTR.CONST.MSGSTATE_ENCRYPTED) {
  161.                                 this.save({'otr_status': UNVERIFIED});
  162.                             }
  163.                             break;
  164.                         case otr.OTR.CONST.STATUS_END_OTR:
  165.                             if (this.otr.msgstate === otr.OTR.CONST.MSGSTATE_FINISHED) {
  166.                                 this.save({'otr_status': FINISHED});
  167.                             } else if (this.otr.msgstate === otr.OTR.CONST.MSGSTATE_PLAINTEXT) {
  168.                                 this.save({'otr_status': UNENCRYPTED});
  169.                             }
  170.                             break;
  171.                     }
  172.                 },
  173.  
  174.                 onSMP (type, data) {
  175.                     // Event handler for SMP (Socialist's Millionaire Protocol)
  176.                     // used by OTR (off-the-record).
  177.                     const { _converse } = this.__super__,
  178.                         { __ } = _converse;
  179.                     switch (type) {
  180.                         case 'question':
  181.                             this.otr.smpSecret(prompt(__(
  182.                                 'Authentication request from %1$s\n\nYour chat contact is attempting to verify your identity, by asking you the question below.\n\n%2$s',
  183.                                 [this.get('fullname'), data])));
  184.                             break;
  185.                         case 'trust':
  186.                             if (data === true) {
  187.                                 this.save({'otr_status': VERIFIED});
  188.                             } else {
  189.                                 this.trigger(
  190.                                     'showHelpMessages',
  191.                                     [__("Could not verify this user's identify.")],
  192.                                     'error');
  193.                                 this.save({'otr_status': UNVERIFIED});
  194.                             }
  195.                             break;
  196.                         default:
  197.                             throw new TypeError('ChatBox.onSMP: Unknown type for SMP');
  198.                     }
  199.                 },
  200.  
  201.                 initiateOTR (query_msg) {
  202.                     // Sets up an OTR object through which we can send and receive
  203.                     // encrypted messages.
  204.                     //
  205.                     // If 'query_msg' is passed in, it means there is an alread incoming
  206.                     // query message from our contact. Otherwise, it is us who will
  207.                     // send the query message to them.
  208.                     const { _converse } = this.__super__,
  209.                         { __ } = _converse;
  210.                     this.save({'otr_status': UNENCRYPTED});
  211.                     this.getSession((session) => {
  212.                         const { _converse } = this.__super__;
  213.                         this.otr = new otr.OTR({
  214.                             fragment_size: 140,
  215.                             send_interval: 200,
  216.                             priv: session.key,
  217.                             instance_tag: session.instance_tag,
  218.                             debug: this.debug
  219.                         });
  220.                         this.otr.on('status', this.updateOTRStatus.bind(this));
  221.                         this.otr.on('smp', this.onSMP.bind(this));
  222.  
  223.                         this.otr.on('ui', (msg) => {
  224.                             this.trigger('showReceivedOTRMessage', msg);
  225.                         });
  226.                         this.otr.on('io', (msg) => {
  227.                             this.trigger('sendMessage', new _converse.Message({ message: msg }));
  228.                         });
  229.                         this.otr.on('error', (msg) => {
  230.                             this.trigger('showOTRError', msg);
  231.                         });
  232.  
  233.                         this.trigger('showHelpMessages', [__('Exchanging private key with contact.')]);
  234.                         if (query_msg) {
  235.                             this.otr.receiveMsg(query_msg);
  236.                         } else {
  237.                             this.otr.sendQueryMsg();
  238.                         }
  239.                     });
  240.                 },
  241.  
  242.                 endOTR () {
  243.                     if (this.otr) {
  244.                         this.otr.endOtr();
  245.                     }
  246.                     this.save({'otr_status': UNENCRYPTED});
  247.                 }
  248.             },
  249.  
  250.             ChatBoxView:  {
  251.                 events: {
  252.                     'click .toggle-otr': 'toggleOTRMenu',
  253.                     'click .start-otr': 'startOTRFromToolbar',
  254.                     'click .end-otr': 'endOTR',
  255.                     'click .auth-otr': 'authOTR'
  256.                 },
  257.  
  258.                 initialize () {
  259.                     const { _converse } = this.__super__;
  260.                     this.__super__.initialize.apply(this, arguments);
  261.                     this.model.on('change:otr_status', this.onOTRStatusChanged, this);
  262.                     this.model.on('showOTRError', this.showOTRError, this);
  263.                     this.model.on('showSentOTRMessage', function (text) {
  264.                         this.showMessage({'message': text, 'sender': 'me'});
  265.                     }, this);
  266.                     this.model.on('showReceivedOTRMessage', function (text) {
  267.                         this.showMessage({'message': text, 'sender': 'them'});
  268.                     }, this);
  269.                     if ((_.includes([UNVERIFIED, VERIFIED], this.model.get('otr_status'))) || _converse.use_otr_by_default) {
  270.                         this.model.initiateOTR();
  271.                     }
  272.                 },
  273.  
  274.                 createMessageStanza () {
  275.                     const stanza = this.__super__.createMessageStanza.apply(this, arguments);
  276.                     if (this.model.get('otr_status') !== UNENCRYPTED || utils.isOTRMessage(stanza.nodeTree)) {
  277.                         // OTR messages aren't carbon copied
  278.                         stanza.c('private', {'xmlns': Strophe.NS.CARBONS}).up()
  279.                               .c('no-store', {'xmlns': Strophe.NS.HINTS}).up()
  280.                               .c('no-permanent-store', {'xmlns': Strophe.NS.HINTS}).up()
  281.                               .c('no-copy', {'xmlns': Strophe.NS.HINTS});
  282.                     }
  283.                     return stanza;
  284.                 },
  285.  
  286.                 parseMessageForCommands (text) {
  287.                     const { _converse } = this.__super__;
  288.                     const match = text.replace(/^\s*/, "").match(/^\/(.*)\s*$/);
  289.                     if (match) {
  290.                         if ((_converse.allow_otr) && (match[1] === "endotr")) {
  291.                             this.endOTR();
  292.                             return true;
  293.                         } else if ((_converse.allow_otr) && (match[1] === "otr")) {
  294.                             this.model.initiateOTR();
  295.                             return true;
  296.                         }
  297.                     }
  298.                     return this.__super__.parseMessageForCommands.apply(this, arguments);
  299.                 },
  300.  
  301.                 isOTREncryptedSession () {
  302.                     return _.includes([UNVERIFIED, VERIFIED], this.model.get('otr_status'));
  303.                 },
  304.  
  305.                 onMessageSubmitted (text, spoiler_hint) {
  306.                     const { _converse } = this.__super__;
  307.                     if (!_converse.connection.authenticated) {
  308.                         this.__super__.onMessageSubmitted.apply(this, arguments);
  309.                     }
  310.                     if (this.parseMessageForCommands(text)) {
  311.                         return;
  312.                     }
  313.                     if (this.isOTREncryptedSession()) {
  314.                         this.model.otr.sendMsg(text);
  315.                         this.model.trigger('showSentOTRMessage', text);
  316.                     } else {
  317.                         this.__super__.onMessageSubmitted.apply(this, arguments);
  318.                     }
  319.                 },
  320.  
  321.                 onOTRStatusChanged () {
  322.                     this.renderToolbar().informOTRChange();
  323.                 },
  324.  
  325.                 informOTRChange () {
  326.                     const { _converse } = this.__super__,
  327.                         { __ } = _converse,
  328.                         data = this.model.toJSON(),
  329.                         msgs = [];
  330.                     if (data.otr_status === UNENCRYPTED) {
  331.                         msgs.push(__("Your messages are not encrypted anymore"));
  332.                     } else if (data.otr_status === UNVERIFIED) {
  333.                         msgs.push(__("Your messages are now encrypted but your contact's identity has not been verified."));
  334.                     } else if (data.otr_status === VERIFIED) {
  335.                         msgs.push(__("Your contact's identify has been verified."));
  336.                     } else if (data.otr_status === FINISHED) {
  337.                         msgs.push(__("Your contact has ended encryption on their end, you should do the same."));
  338.                     }
  339.                     return this.showHelpMessages(msgs, 'info', false);
  340.                 },
  341.  
  342.                 showOTRError (msg) {
  343.                     const { _converse } = this.__super__,
  344.                         { __ } = _converse;
  345.                     if (msg === 'Message cannot be sent at this time.') {
  346.                         this.showHelpMessages(
  347.                             [__('Your message could not be sent')], 'error');
  348.                     } else if (msg === 'Received an unencrypted message.') {
  349.                         this.showHelpMessages(
  350.                             [__('We received an unencrypted message')], 'error');
  351.                     } else if (msg === 'Received an unreadable encrypted message.') {
  352.                         this.showHelpMessages(
  353.                             [__('We received an unreadable encrypted message')],
  354.                             'error');
  355.                     } else {
  356.                         this.showHelpMessages([`Encryption error occured: ${msg}`], 'error');
  357.                     }
  358.                     _converse.log(`OTR ERROR:${msg}`, Strophe.LogLevel.ERROR);
  359.                 },
  360.  
  361.                 startOTRFromToolbar (ev) {
  362.                     ev.stopPropagation();
  363.                     this.model.initiateOTR();
  364.                 },
  365.  
  366.                 endOTR (ev) {
  367.                     if (!_.isUndefined(ev)) {
  368.                         ev.preventDefault();
  369.                         ev.stopPropagation();
  370.                     }
  371.                     this.model.endOTR();
  372.                 },
  373.  
  374.                 authOTR (ev) {
  375.                     const { _converse } = this.__super__,
  376.                         { __ } = _converse,
  377.                         scheme = ev.target.getAttribute('data-scheme');
  378.                     let result, question, answer;
  379.                     if (scheme === 'fingerprint') {
  380.                         result = confirm(__('Here are the fingerprints, please confirm them with %1$s, outside of this chat.\n\nFingerprint for you, %2$s: %3$s\n\nFingerprint for %1$s: %4$s\n\nIf you have confirmed that the fingerprints match, click OK, otherwise click Cancel.', [
  381.                                 this.model.get('fullname'),
  382.                                 _converse.xmppstatus.get('fullname')||_converse.bare_jid,
  383.                                 this.model.otr.priv.fingerprint(),
  384.                                 this.model.otr.their_priv_pk.fingerprint()
  385.                             ]
  386.                         ));
  387.                         if (result === true) {
  388.                             this.model.save({'otr_status': VERIFIED});
  389.                         } else {
  390.                             this.model.save({'otr_status': UNVERIFIED});
  391.                         }
  392.                     } else if (scheme === 'smp') {
  393.                         alert(__('You will be prompted to provide a security question and then an answer to that question.\n\nYour contact will then be prompted the same question and if they type the exact same answer (case sensitive), their identity will be verified.'));
  394.                         question = prompt(__('What is your security question?'));
  395.                         if (question) {
  396.                             answer = prompt(__('What is the answer to the security question?'));
  397.                             this.model.otr.smpSecret(answer, question);
  398.                         }
  399.                     } else {
  400.                         this.showHelpMessages([__('Invalid authentication scheme provided')], 'error');
  401.                     }
  402.                 },
  403.  
  404.                 toggleOTRMenu (ev) {
  405.                     ev.stopPropagation();
  406.                     const { _converse } = this.__super__;
  407.                     const menu = this.el.querySelector('.toggle-otr ul');
  408.                     const elements = _.difference(
  409.                         _converse.root.querySelectorAll('.toolbar-menu'),
  410.                         [menu]
  411.                     );
  412.                     utils.slideInAllElements(elements).then(
  413.                         _.partial(utils.slideToggleElement, menu)
  414.                     );
  415.                 },
  416.  
  417.                 getOTRTooltip () {
  418.                     const { _converse } = this.__super__,
  419.                         { __ } = _converse,
  420.                         data = this.model.toJSON();
  421.                     if (data.otr_status === UNENCRYPTED) {
  422.                         return __('Your messages are not encrypted. Click here to enable OTR encryption.');
  423.                     } else if (data.otr_status === UNVERIFIED) {
  424.                         return __('Your messages are encrypted, but your contact has not been verified.');
  425.                     } else if (data.otr_status === VERIFIED) {
  426.                         return __('Your messages are encrypted and your contact verified.');
  427.                     } else if (data.otr_status === FINISHED) {
  428.                         return __('Your contact has closed their end of the private session, you should do the same');
  429.                     }
  430.                 },
  431.  
  432.                 addOTRToolbarButton (options) {
  433.                     const { _converse } = this.__super__,
  434.                           { __ } = _converse,
  435.                           data = this.model.toJSON();
  436.                     options = _.extend(options || {}, {
  437.                         FINISHED,
  438.                         UNENCRYPTED,
  439.                         UNVERIFIED,
  440.                         VERIFIED,
  441.                         // FIXME: Leaky abstraction MUC
  442.                         allow_otr: _converse.allow_otr && !this.is_chatroom,
  443.                         label_end_encrypted_conversation: __('End encrypted conversation'),
  444.                         label_refresh_encrypted_conversation: __('Refresh encrypted conversation'),
  445.                         label_start_encrypted_conversation: __('Start encrypted conversation'),
  446.                         label_verify_with_fingerprints: __('Verify with fingerprints'),
  447.                         label_verify_with_smp: __('Verify with SMP'),
  448.                         label_whats_this: __("What\'s this?"),
  449.                         otr_status_class: OTR_CLASS_MAPPING[data.otr_status],
  450.                         otr_tooltip: this.getOTRTooltip(),
  451.                         otr_translated_status: OTR_TRANSLATED_MAPPING[data.otr_status],
  452.                     });
  453.                     this.el.querySelector('.chat-toolbar').insertAdjacentHTML(
  454.                         'beforeend',
  455.                         tpl_toolbar_otr(_.extend(data, options || {})));
  456.                 },
  457.  
  458.                 getToolbarOptions (options) {
  459.                     options = this.__super__.getToolbarOptions();
  460.                     if (this.isOTREncryptedSession()) {
  461.                         options.show_spoiler_button = false;
  462.                     }
  463.                     return options;
  464.                 },
  465.  
  466.                 renderToolbar (toolbar, options) {
  467.                     const result = this.__super__.renderToolbar.apply(this, arguments);
  468.                     this.addOTRToolbarButton(options);
  469.                     return result;
  470.                 }
  471.             }
  472.         },
  473.  
  474.         initialize () {
  475.             /* The initialize function gets called as soon as the plugin is
  476.              * loaded by converse.js's plugin machinery.
  477.              */
  478.             const { _converse } = this,
  479.                 { __ } = _converse;
  480.  
  481.             _converse.api.settings.update({
  482.                 allow_otr: true,
  483.                 cache_otr_key: false,
  484.                 use_otr_by_default: false
  485.             });
  486.  
  487.             // Translation aware constants
  488.             // ---------------------------
  489.             // We can only call the __ translation method *after* converse.js
  490.             // has been initialized and with it the i18n machinery. That's why
  491.             // we do it here in the "initialize" method and not at the top of
  492.             // the module.
  493.             OTR_TRANSLATED_MAPPING[UNENCRYPTED] = __('unencrypted');
  494.             OTR_TRANSLATED_MAPPING[UNVERIFIED] = __('unverified');
  495.             OTR_TRANSLATED_MAPPING[VERIFIED] = __('verified');
  496.             OTR_TRANSLATED_MAPPING[FINISHED] = __('finished');
  497.  
  498.             // Only allow OTR if we have the capability
  499.             _converse.allow_otr = _converse.allow_otr && HAS_CRYPTO;
  500.             // Only use OTR by default if allow OTR is enabled to begin with
  501.             _converse.use_otr_by_default = _converse.use_otr_by_default && _converse.allow_otr;
  502.         }
  503.     });
  504. }));
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!