├── bootstrap.js
├── changelog.md
├── chrome.manifest
├── chrome
    ├── content
    │   ├── addfinger.js
    │   ├── addfinger.xul
    │   ├── auth.js
    │   ├── auth.xul
    │   ├── coniks
    │   │   ├── coniks.js
    │   │   ├── context.js
    │   │   └── libconiks.js
    │   ├── finger.js
    │   ├── finger.xul
    │   ├── helpers.js
    │   ├── libc.js
    │   ├── libotr.js
    │   ├── otr.js
    │   ├── prefs.js
    │   ├── prefs.xul
    │   ├── priv.js
    │   ├── priv.xul
    │   ├── ui.js
    │   └── worker.js
    ├── locale
    │   └── en
    │   │   ├── auth.dtd
    │   │   ├── auth.properties
    │   │   ├── finger.dtd
    │   │   ├── finger.properties
    │   │   ├── otr.properties
    │   │   ├── prefs.dtd
    │   │   ├── priv.dtd
    │   │   ├── priv.properties
    │   │   └── ui.properties
    └── skin
    │   ├── icons
    │       ├── finished.png
    │       ├── not-private.png
    │       ├── private.png
    │       └── unverified.png
    │   └── otr.css
├── install.rdf
├── license
├── package.json
└── readme.md


/bootstrap.js:
--------------------------------------------------------------------------------
 1 | var { interfaces: Ci, utils: Cu, classes: Cc } = Components;
 2 | 
 3 | Cu.import("resource:///modules/imServices.jsm");
 4 | 
 5 | function init() {
 6 |   Cu.import("chrome://otr/content/ui.js");
 7 |   let sss = Cc["@mozilla.org/content/style-sheet-service;1"].getService(Ci.nsIStyleSheetService);
 8 |   let ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
 9 |   let uri = ios.newURI("chrome://otr/skin/otr.css", null, null);
10 |   sss.loadAndRegisterSheet(uri, sss.USER_SHEET);
11 |   ui.init();
12 | }
13 | 
14 | function initializer() {
15 |   init();
16 |   Services.obs.removeObserver(initializer, "prpl-init");
17 | }
18 | 
19 | function startup(data, reason) {
20 |   if (Services.core.initialized)
21 |     init();
22 |   else
23 |     Services.obs.addObserver(initializer, "prpl-init", false);
24 | }
25 | 
26 | function shutdown(data, reason) {
27 |   if (reason === APP_SHUTDOWN)
28 |     return;
29 |   ui.destroy();
30 |   Cu.unload("chrome://otr/content/ui.js");
31 | }
32 | 
33 | function install(data, reason) {}
34 | function uninstall(data, reason) {}


--------------------------------------------------------------------------------
/changelog.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 0.0.4 / 2016-12-14
 3 | ==================
 4 | 
 5 |   * export-ignore .jshintrc
 6 |   * Remove hacky _addedNodes
 7 |   * Cleanup menu observers
 8 |   * Fix Add Contact's Fingerprint menu item disappearing
 9 |   * Fix some linting errors
10 |   * More reliably checkout the pin of coniks-go
11 | 
12 | 0.0.3 / 2016-11-11
13 | ==================
14 | 
15 |   * Pin coniks-go to 90075472
16 |   * Remove incomplete translations until we have an import script
17 | 
18 | 0.0.2 / 2016-08-31
19 | ==================
20 | 
21 |   * Use a different hack to disable update pings
22 |   * Add coniks preferences GUI
23 | 
24 | 0.0.1 / 2016-08-20
25 | ==================
26 | 
27 |   * Thar be dragons
28 | 
29 | 0.0.0 / 2015-07-13
30 | ==================
31 | 
32 |   * Thar be dragons
33 | 
34 | 


--------------------------------------------------------------------------------
/chrome.manifest:
--------------------------------------------------------------------------------
1 | content otr chrome/content/
2 | skin otr classic/1.0 chrome/skin/
3 | 
4 | locale otr en chrome/locale/en/
5 | 


--------------------------------------------------------------------------------
/chrome/content/addfinger.js:
--------------------------------------------------------------------------------
 1 | var { interfaces: Ci, utils: Cu, classes: Cc } = Components;
 2 | 
 3 | Cu.import("resource:///modules/imServices.jsm");
 4 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
 5 | Cu.import("chrome://otr/content/otr.js");
 6 | 
 7 | XPCOMUtils.defineLazyGetter(this, "_", () =>
 8 |   l10nHelper("chrome://otr/locale/finger.properties")
 9 | );
10 | 
11 | var args = window.arguments[0].wrappedJSObject;
12 | 
13 | var otrAddFinger = {
14 |   onload: function() {
15 |     document.title = _("addfinger.title", args.screenname);
16 |   },
17 | 
18 |   oninput: function(e) {
19 |     e.value = e.value.replace(/[^0-9a-fA-F]/gi, "");
20 |     document.documentElement.getButton("accept").disabled = (e.value.length != 40);
21 |   },
22 | 
23 |   add: function(e) {
24 |     let hex = document.getElementById("finger").value;
25 |     let context = otr.getContextFromRecipient(
26 |       args.account,
27 |       args.protocol,
28 |       args.screenname
29 |     );
30 |     finger = otr.addFingerprint(context, hex);
31 |     if (finger.isNull())
32 |       return;
33 |     try {
34 |       // Ignore the return, this is just a test.
35 |       otr.getUIConvFromContext(context);
36 |     } catch(error) {
37 |       // We expect that a conversation may not have been started.
38 |       context = null;
39 |     }
40 |     otr.setTrust(finger, true, context);
41 |   },
42 | };
43 | 


--------------------------------------------------------------------------------
/chrome/content/addfinger.xul:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <?xml-stylesheet href="chrome://global/skin/" type="text/css" ?>
 3 | 
 4 | <!DOCTYPE window SYSTEM "chrome://otr/locale/finger.dtd">
 5 | 
 6 | <dialog id="otrAddFingerDialog"
 7 |         windowtype="OTR:AddFinger"
 8 |         onload="otrAddFinger.onload()"
 9 |         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
10 |         title="&addFingerDialog.title;"
11 |         buttons= "accept,cancel"
12 |         buttonlabelaccept="&addFingerDialog.accept;"
13 |         buttonlabelcancel="&addFingerDialog.cancel;"
14 |         ondialogaccept="otrAddFinger.add()"
15 |         buttondisabledaccept="true">
16 | 
17 |   <script type="application/javascript" src="chrome://otr/content/addfinger.js"/>
18 |   <grid>
19 |     <columns>
20 |       <column/>
21 |       <column flex="1"/>
22 |     </columns>
23 |     <rows>
24 |       <label value="&addFingerDialog.tooltip;" control="name"/>
25 |       <row id="fingerBox" align="baseline">
26 |         <label value="&addFingerDialog.finger;" control="name"/>
27 |         <textbox id="finger" oninput="otrAddFinger.oninput(this)"/>
28 |       </row>
29 |     </rows>
30 |   </grid>
31 | 
32 | </dialog>


--------------------------------------------------------------------------------
/chrome/content/auth.js:
--------------------------------------------------------------------------------
  1 | var { interfaces: Ci, utils: Cu, classes: Cc } = Components;
  2 | 
  3 | Cu.import("resource:///modules/imServices.jsm");
  4 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
  5 | Cu.import("chrome://otr/content/otr.js");
  6 | 
  7 | XPCOMUtils.defineLazyGetter(this, "_", () =>
  8 |   l10nHelper("chrome://otr/locale/auth.properties")
  9 | );
 10 | 
 11 | var [mode, uiConv, aObject] = window.arguments;
 12 | 
 13 | document.title = _("auth.title",
 14 |   (mode === "pref") ? aObject.screenname : uiConv.normalizedName);
 15 | 
 16 | function showSection(selected, hideMenu) {
 17 |   document.getElementById("how").hidden = !!hideMenu;
 18 |   [ "questionAndAnswer",
 19 |     "sharedSecret",
 20 |     "manualVerification",
 21 |     "ask",
 22 |   ].forEach(function(key) {
 23 |     document.getElementById(key).hidden = (key !== selected);
 24 |   });
 25 |   window.sizeToContent();
 26 | }
 27 | 
 28 | function startSMP(context, answer, question) {
 29 |   otr.sendSecret(context, answer, question);
 30 |   otr.authUpdate(context, 10);
 31 | }
 32 | 
 33 | function manualVerification(fingerprint, context) {
 34 |   let opts = document.getElementById("verifiedOption");
 35 |   let trust = (opts.selectedItem.value === "yes");
 36 |   otr.setTrust(fingerprint, trust, context);
 37 | }
 38 | 
 39 | function populateFingers(context, theirs, trust) {
 40 |   let fingers = document.getElementById("fingerprints");
 41 |   let yours = otr.privateKeyFingerprint(context.account, context.protocol);
 42 |   if (!yours)
 43 |     throw new Error("Fingerprint should already be generated.");
 44 |   fingers.value =
 45 |     _("auth.yourFingerprint", context.account, yours) + "\n\n" +
 46 |     _("auth.theirFingerprint", context.username, theirs);
 47 |   let opts = document.getElementById("verifiedOption");
 48 |   let verified = trust ? "yes" : "no";
 49 |   for (let i = 0; i < opts.menupopup.childNodes.length; i ++) {
 50 |     let item = opts.menupopup.childNodes[i];
 51 |     if (verified === item.value) {
 52 |       opts.selectedItem = item;
 53 |       break;
 54 |     }
 55 |   }
 56 | }
 57 | 
 58 | var otrAuth = {
 59 | 
 60 |   onload: function() {
 61 |     let context, theirs;
 62 |     switch(mode) {
 63 |     case "start":
 64 |       context = otr.getContext(uiConv.target);
 65 |       theirs = otr.hashToHuman(context.fingerprint);
 66 |       populateFingers(context, theirs, context.trust);
 67 |       showSection("questionAndAnswer");
 68 |       break;
 69 |     case "pref":
 70 |       context = otr.getContextFromRecipient(
 71 |         aObject.account,
 72 |         aObject.protocol,
 73 |         aObject.screenname
 74 |       );
 75 |       theirs = aObject.fingerprint;
 76 |       populateFingers(context, theirs, aObject.trust);
 77 |       showSection("manualVerification", true);
 78 |       this.oninput({ value: true });
 79 |       break;
 80 |     case "ask":
 81 |       document.getElementById("askLabel").textContent = aObject.question
 82 |         ? _("auth.question", aObject.question)
 83 |         : _("auth.secret");
 84 |       showSection("ask", true);
 85 |       break;
 86 |     }
 87 |   },
 88 | 
 89 |   accept: function() {
 90 |     let opts, trust;
 91 |     // uiConv may not be present in pref mode
 92 |     let context = uiConv ? otr.getContext(uiConv.target) : null;
 93 |     if (mode === "pref") {
 94 |       manualVerification(aObject.fpointer, context);
 95 |     } else if (mode === "start") {
 96 |       let how = document.getElementById("howOption");
 97 |       switch(how.selectedItem.value) {
 98 |       case "questionAndAnswer":
 99 |         let question = document.getElementById("question").value;
100 |         let answer = document.getElementById("answer").value;
101 |         startSMP(context, answer, question);
102 |         break;
103 |       case "sharedSecret":
104 |         let secret = document.getElementById("secret").value;
105 |         startSMP(context, secret);
106 |         break;
107 |       case "manualVerification":
108 |         manualVerification(context.fingerprint, context);
109 |         break;
110 |       default:
111 |         throw new Error("Unreachable!");
112 |       }
113 |     } else if (mode === "ask") {
114 |       let response = document.getElementById("response").value;
115 |       otr.sendResponse(context, response);
116 |       otr.authUpdate(context, aObject.progress);
117 |     } else {
118 |       throw new Error("Unreachable!");
119 |     }
120 |     return true;
121 |   },
122 | 
123 |   cancel: function() {
124 |     if (mode === "ask") {
125 |       let context = otr.getContext(uiConv.target);
126 |       otr.abortSMP(context);
127 |     }
128 |   },
129 | 
130 |   oninput: function(e) {
131 |     document.documentElement.getButton("accept").disabled = !e.value;
132 |   },
133 | 
134 |   how: function() {
135 |     let how = document.getElementById("howOption").selectedItem.value;
136 |     switch(how) {
137 |     case "questionAndAnswer":
138 |       this.oninput(document.getElementById("answer"));
139 |       break;
140 |     case "sharedSecret":
141 |       this.oninput(document.getElementById("secret"));
142 |       break;
143 |     case "manualVerification":
144 |       this.oninput({ value: true });
145 |       break;
146 |     }
147 |     showSection(how);
148 |   },
149 | 
150 |   help: function() {
151 |     let prompt = Cc["@mozilla.org/embedcomp/prompt-service;1"].getService(Ci.nsIPromptService);
152 |     prompt.alert(window, _("auth.helpTitle"), _("auth.help"));
153 |   },
154 | 
155 | };


--------------------------------------------------------------------------------
/chrome/content/auth.xul:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <?xml-stylesheet href="chrome://global/skin/" type="text/css" ?>
 3 | 
 4 | <!DOCTYPE window SYSTEM "chrome://otr/locale/auth.dtd">
 5 | 
 6 | <dialog
 7 |   xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
 8 |   id="otrAuthDialog"
 9 |   windowtype="OTR:Auth"
10 |   title="&authDialog.title;"
11 |   onload="otrAuth.onload()"
12 |   buttons="accept,cancel,help"
13 |   buttonlabelaccept="&authDialog.authenticate;"
14 |   buttonlabelcancel="&authDialog.cancel;"
15 |   buttonlabelhelp="&authDialog.help;"
16 |   ondialogaccept="return otrAuth.accept()"
17 |   ondialogcancel="otrAuth.cancel()"
18 |   ondialoghelp="otrAuth.help()"
19 |   buttondisabledaccept="true">
20 | 
21 |   <script type="application/javascript" src="chrome://otr/content/auth.js" />
22 | 
23 |   <groupbox id="how" hidden="true">
24 |     <caption label="&authDialog.how;"/>
25 |     <menulist id="howOption" oncommand="otrAuth.how();">
26 |       <menupopup>
27 |         <menuitem label="&authDialog.questionAndAnswer;" value="questionAndAnswer" />
28 |         <menuitem label="&authDialog.sharedSecret;" value="sharedSecret" />
29 |         <menuitem label="&authDialog.manualVerification;" value="manualVerification" />
30 |       </menupopup>
31 |     </menulist>
32 |   </groupbox>
33 | 
34 |   <groupbox id="questionAndAnswer" hidden="true">
35 |     <caption label="&authDialog.questionAndAnswer;" />
36 |     <description style="width: 300px; white-space: pre-wrap;">&authDialog.qaInstruction;</description>
37 |     <label value="&authDialog.question;" control="question" flex="1" />
38 |     <textbox id="question" />
39 |     <label value="&authDialog.answer;" control="answer" flex="1" />
40 |     <textbox id="answer" oninput="otrAuth.oninput(this)" />
41 |   </groupbox>
42 | 
43 |   <groupbox id="sharedSecret" hidden="true">
44 |     <caption label="&authDialog.sharedSecret;" />
45 |     <description style="width: 300px; white-space: pre-wrap;">&authDialog.secretInstruction;</description>
46 |     <label value="&authDialog.secret;" control="secret" flex="1" />
47 |     <textbox id="secret" oninput="otrAuth.oninput(this)" />
48 |   </groupbox>
49 | 
50 |   <groupbox id="manualVerification" hidden="true">
51 |     <caption label="&authDialog.manualVerification;" />
52 |     <description style="width: 300px; white-space: pre-wrap;">&authDialog.manualInstruction;</description>
53 |     <textbox id="fingerprints" rows="5" multiline="true" readonly="true" />
54 |     <hbox align="center">
55 |       <label value="&authDialog.verified;" />
56 |       <menulist id="verifiedOption">
57 |         <menupopup>
58 |           <menuitem label="&authDialog.yes;" value="yes" />
59 |           <menuitem label="&authDialog.no;" value="no" />
60 |         </menupopup>
61 |       </menulist>
62 |     </hbox>
63 |   </groupbox>
64 | 
65 |   <groupbox id="ask" hidden="true">
66 |     <description id="askLabel" style="width: 300px; white-space: pre-wrap;" />
67 |     <textbox id="response" oninput="otrAuth.oninput(this)" />
68 |   </groupbox>
69 | 
70 | </dialog>


--------------------------------------------------------------------------------
/chrome/content/coniks/coniks.js:
--------------------------------------------------------------------------------
  1 | this.EXPORTED_SYMBOLS = ["coniks"];
  2 | 
  3 | var { utils: Cu } = Components;
  4 | 
  5 | Cu.import("resource:///modules/imServices.jsm");
  6 | Cu.import("chrome://otr/content/coniks/context.js");
  7 | Cu.import("chrome://otr/content/helpers.js");
  8 | Cu.import("chrome://otr/content/otr.js");
  9 | 
 10 | function toId(account, protocol) {
 11 |   return `${account}@${protocol}`;
 12 | }
 13 | 
 14 | function accToId(acc) {
 15 |   return toId(acc.normalizedName, acc.protocol.normalizedName);
 16 | }
 17 | 
 18 | var coniks = {
 19 |   isEnable: false,
 20 |   _contexts: new Map(),
 21 | 
 22 |   init: function() {
 23 |     return Promise.resolve().then(function() {
 24 |       coniks.setPrefs();
 25 |       coniks.isEnabled = coniks.prefs.getBoolPref("enabled");
 26 |       if (!coniks.isEnabled)
 27 |         return;
 28 | 
 29 |       for (let acc of helpers.getAccounts()) {
 30 |         coniks._contexts.set(accToId(acc), new AccountContext({
 31 |           account: acc.normalizedName,
 32 |           protocol: acc.protocol.normalizedName,
 33 |         }));
 34 |       }
 35 |       return coniks.loadFiles();
 36 |     });
 37 |   },
 38 | 
 39 |   destroy: function() {
 40 |     if (!coniks.isEnabled)
 41 |       return;
 42 |   },
 43 | 
 44 |   onAccountCreated: function(acc) {
 45 |     return Promise.resolve().then(function() {
 46 |       let account = acc.normalizedName;
 47 |       let protocol = acc.protocol.normalizedName;
 48 |       let fingerprint = otr.privateKeyFingerprint(account, protocol);
 49 |       coniks._contexts.set(accToId(acc), new AccountContext({
 50 |         account: account,
 51 |         protocol: protocol,
 52 |         fingerprint: fingerprint,
 53 |       }));
 54 |       return coniks.store(coniks._contexts);
 55 |     });
 56 |   },
 57 | 
 58 |   prefs: null,
 59 |   setPrefs: function() {
 60 |     let branch = "extensions.otr.coniks.";
 61 |     let coniksPrefs = {
 62 |       enabled: false,
 63 |       serverAddress: "111.221.102.190",
 64 |       serverPort: 3000
 65 |     };
 66 |     let defaults = Services.prefs.getDefaultBranch(branch);
 67 |     Object.keys(coniksPrefs).forEach(function(key) {
 68 |       if (typeof coniksPrefs[key] === "boolean") {
 69 |         defaults.setBoolPref(key, coniksPrefs[key]);
 70 |       } else {
 71 |         defaults.setCharPref(key, coniksPrefs[key]);
 72 |       }
 73 |     });
 74 |     coniks.prefs = Services.prefs.getBranch(branch);
 75 |   },
 76 | 
 77 |   loadFiles: function() {
 78 |     return coniks.load(coniks._contexts);
 79 |   },
 80 | 
 81 |   getAccountPolicy: function(acc) {
 82 |     return coniks._contexts.get(accToId(acc));
 83 |   },
 84 | 
 85 |   setAccountPolicy: function(acc, policy) {
 86 |     let ctx = coniks._contexts.get(accToId(acc));
 87 |     ctx.setPolicy(policy);
 88 |     return coniks.store(coniks._contexts);
 89 |   },
 90 | 
 91 |   path: helpers.profilePath("coniks.contexts"),
 92 | 
 93 |   load: function(contexts) {
 94 |     return helpers.fileExists(coniks.path).then((exists) => {
 95 |       if (!exists)
 96 |         return;
 97 |       return helpers.readTextFile(coniks.path).then(function(data) {
 98 |         let ctxs = JSON.parse(data);
 99 |         ctxs.forEach(function(c) {
100 |           let acc = toId(c.account, c.protocol);
101 |           if (contexts.has(acc)) {
102 |             let ctx = contexts.get(acc);
103 |             ctx.setPolicy(c);
104 |             ctx.fingerprint = c.fingerprint;
105 |           }
106 |         });
107 |       });
108 |     });
109 |   },
110 | 
111 |   store: function(contexts) {
112 |     let data = JSON.stringify([...contexts.values()], null, "\t");
113 |     return helpers.writeTextFile(coniks.path, data);
114 |   },
115 | 
116 | };
117 | 


--------------------------------------------------------------------------------
/chrome/content/coniks/context.js:
--------------------------------------------------------------------------------
 1 | this.EXPORTED_SYMBOLS = ["AccountContext", "ConiksContext"];
 2 | 
 3 | var { utils: Cu } = Components;
 4 | 
 5 | Cu.import("chrome://otr/content/helpers.js");
 6 | 
 7 | class ConiksContext {
 8 |   constructor(opts) {
 9 |     opts = opts || {};
10 | 
11 |     if (opts.account === null)
12 |       throw Error("Account should not be nil");
13 | 
14 |     this.account = opts.account;
15 |     this.setPolicy(opts);
16 |   }
17 | 
18 |   setPolicy(ctx) {
19 |     this.signedKeyChange = !!ctx.signedKeyChange;
20 |     this.privateLookups = !!ctx.privateLookups;
21 |   }
22 | }
23 | 
24 | class AccountContext extends ConiksContext {
25 |   constructor(opts) {
26 |     opts = opts || {};
27 | 
28 |     if (opts.account === null || opts.protocol === null)
29 |       throw Error("Account and protocol should not be nil");
30 | 
31 |     super(opts);
32 | 
33 |     if (opts.fingerprint)
34 |       this.fingerprint = opts.fingerprint;
35 | 
36 |     this.protocol = opts.protocol;
37 |     this.contacts = [];  // array of ConiksContext
38 |     // this.TB = null;
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/chrome/content/coniks/libconiks.js:
--------------------------------------------------------------------------------
 1 | var isNode = (typeof process === "object");
 2 | var isJpm = !isNode && (typeof require === "function");
 3 | 
 4 | var ctypes;
 5 | 
 6 | if (isNode) {
 7 |   ctypes = require("ctypes");
 8 | } else {
 9 |   var Ci, Cu, Cc;
10 |   if (isJpm) {
11 |     ({ Ci, Cu, Cc } = require("chrome"));
12 |   } else {
13 |     ({ interfaces: Ci, utils: Cu, classes: Cc } = Components);
14 |   }
15 |   Cu.import("resource://gre/modules/ctypes.jsm");
16 |   Cu.import("resource://gre/modules/Services.jsm");
17 | }
18 | 
19 | var abi = ctypes.default_abi;
20 | 
21 | var libconiks, libconiksPath;
22 | 
23 | if (isJpm) {
24 |   let env = require("sdk/system").env;
25 |   libconiksPath = env.PWD + "/addon/" + ctypes.libraryName("coniks");
26 |   libconiks = ctypes.open(libconiksPath);
27 | } else if (!isNode) {
28 |   let uri = "chrome://otr/content/coniks/" + ctypes.libraryName("coniks");
29 |   let chromeReg = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(Ci.nsIXULChromeRegistry);
30 |   uri = chromeReg.convertChromeURL(Services.io.newURI(uri, null, null));
31 |   libconiksPath = uri.QueryInterface(Ci.nsIFileURL).file.path;
32 |   libconiks = ctypes.open(libconiksPath);
33 | } else {
34 |   // Ignore for now
35 | }
36 | 
37 | // functions
38 | var libCONIKS = {
39 |   // extern int cgoVerifySignature(void* p0, int p1,
40 |   //                               void* p2, int p3,
41 |   //                               void* p4, int p5);
42 |   cgoVerifySignature: libconiks.declare(
43 |     "cgoVerifySignature", abi, ctypes.int,
44 |     ctypes.unsigned_char.ptr, ctypes.int,
45 |     ctypes.unsigned_char.ptr, ctypes.int,
46 |     ctypes.unsigned_char.ptr, ctypes.int
47 |   ),
48 | 
49 |   // extern int cgoVerifyVrf(void* p0, int p1,
50 |   //                         void* p2, int p3,
51 |   //                         void* p4, int p5,
52 |   //                         void* p6, int p7);
53 |   cgoVerifyVrf: libconiks.declare(
54 |     "cgoVerifyVrf", abi, ctypes.int,
55 |     ctypes.unsigned_char.ptr, ctypes.int,
56 |     ctypes.unsigned_char.ptr, ctypes.int,
57 |     ctypes.unsigned_char.ptr, ctypes.int,
58 |     ctypes.unsigned_char.ptr, ctypes.int
59 |   ),
60 | 
61 |   // extern int cgoVerifyHashChain(void* p0, int p1,
62 |   //                               void* p2, int p3);
63 |   cgoVerifyHashChain: libconiks.declare(
64 |     "cgoVerifyHashChain", abi, ctypes.int,
65 |     ctypes.unsigned_char.ptr, ctypes.int,
66 |     ctypes.unsigned_char.ptr, ctypes.int
67 |   ),
68 | 
69 |   // extern int cgoVerifyAuthPath(void* p0, int p1,
70 |   //                              void* p2, int p3,
71 |   //                              void* p4, int p5,
72 |   //                              void* p6, int p7, int p8,
73 |   //                              int p9,
74 |   //                              void* p10, int p11,
75 |   //                              void* p12, int p13,
76 |   //                              int p14);
77 |   cgoVerifyAuthPath: libconiks.declare(
78 |     "cgoVerifyAuthPath", abi, ctypes.int,
79 |     ctypes.unsigned_char.ptr, ctypes.int,
80 |     ctypes.unsigned_char.ptr, ctypes.int,
81 |     ctypes.unsigned_char.ptr, ctypes.int,
82 |     ctypes.unsigned_char.ptr, ctypes.int, ctypes.int,
83 |     ctypes.int,
84 |     ctypes.unsigned_char.ptr, ctypes.int,
85 |     ctypes.unsigned_char.ptr, ctypes.int,
86 |     ctypes.int
87 |   ),
88 | };
89 | 
90 | // exports
91 | 
92 | if (isNode) {
93 |   module.exports = { libCONIKS: libCONIKS };
94 | } else if (isJpm) {
95 |   exports.libCONIKS = libCONIKS;
96 | } else {
97 |   this.EXPORTED_SYMBOLS = ["libCONIKS"];
98 | }
99 | 


--------------------------------------------------------------------------------
/chrome/content/finger.js:
--------------------------------------------------------------------------------
  1 | var { interfaces: Ci, utils: Cu, classes: Cc } = Components;
  2 | 
  3 | Cu.import("resource:///modules/imServices.jsm");
  4 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
  5 | Cu.import("chrome://otr/content/otr.js");
  6 | 
  7 | var authDialog = "chrome://otr/content/auth.xul";
  8 | 
  9 | XPCOMUtils.defineLazyGetter(this, "_", () =>
 10 |   l10nHelper("chrome://otr/locale/finger.properties")
 11 | );
 12 | 
 13 | var fingers;
 14 | var fingerTreeView = {
 15 |   selection: null,
 16 |   rowCount: 0,
 17 |   setTree: function(tree) {},
 18 |   getImageSrc: function(row, column) {},
 19 |   getProgressMode: function(row, column) {},
 20 |   getCellValue: function(row, column) {},
 21 |   getCellText: function(row, column) {
 22 |     let finger = fingers[row];
 23 |     switch(column.id) {
 24 |     case "verified":
 25 |       return finger.trust ? _("verified.yes") : _("verified.no");
 26 |     case "protocol":
 27 |       return otr.protocolName(finger.protocol);
 28 |     default:
 29 |       return finger[column.id] || "";
 30 |     }
 31 |   },
 32 |   isSeparator: function(index) { return false; },
 33 |   isSorted: function() { return false; },
 34 |   isContainer: function(index) { return false; },
 35 |   cycleHeader: function(column) {},
 36 |   getRowProperties: function(row) { return ""; },
 37 |   getColumnProperties: function(column) { return ""; },
 38 |   getCellProperties: function(row, column) { return ""; },
 39 | };
 40 | 
 41 | function getSelections(tree) {
 42 |   let selections = [];
 43 |   let select = tree.view.selection;
 44 |   if (select) {
 45 |     let count = select.getRangeCount();
 46 |     let min = {};
 47 |     let max = {};
 48 |     for (let i = 0; i < count; i++) {
 49 |       select.getRangeAt(i, min, max);
 50 |       for (let k = min.value; k <= max.value; k++) {
 51 |         if (k != -1)
 52 |           selections[selections.length] = k;
 53 |       }
 54 |     }
 55 |   }
 56 |   return selections;
 57 | }
 58 | 
 59 | var fingerTree;
 60 | var otrFinger = {
 61 | 
 62 |   onload: function() {
 63 |     fingerTree = document.getElementById("fingerTree");
 64 |     fingers = otr.knownFingerprints();
 65 |     fingerTreeView.rowCount = fingers.length;
 66 |     fingerTree.view = fingerTreeView;
 67 |   },
 68 | 
 69 |   select: function() {
 70 |     let selections = getSelections(fingerTree);
 71 |     document.getElementById("verify").disabled = (selections.length !== 1);
 72 |     document.getElementById("remove").disabled = !selections.length;
 73 |   },
 74 | 
 75 |   remove: function() {
 76 |     fingerTreeView.selection.selectEventsSuppressed = true;
 77 |     // mark fingers for removal
 78 |     getSelections(fingerTree).forEach(function(sel) {
 79 |       fingers[sel].purge = true;
 80 |     });
 81 |     otr.forgetFingerprints(fingers);  // will null out removed fingers
 82 |     for (let j = 0; j < fingers.length; j++) {
 83 |       if (fingers[j] === null) {
 84 |         let k = j;
 85 |         while (k < fingers.length && fingers[k] === null)
 86 |           k++;
 87 |         fingers.splice(j, k - j);
 88 |         fingerTreeView.rowCount -= k - j;
 89 |         fingerTree.treeBoxObject.rowCountChanged(j, j - k);  // negative
 90 |       }
 91 |     }
 92 |     fingerTreeView.selection.selectEventsSuppressed = false;
 93 |   },
 94 | 
 95 |   verify: function() {
 96 |     fingerTreeView.selection.selectEventsSuppressed = true;
 97 |     let selections = getSelections(fingerTree);
 98 |     if (selections.length !== 1)
 99 |       return;
100 |     let row = selections[0];
101 |     let finger = fingers[row];
102 |     let features = "modal,centerscreen,resizable=no,minimizable=no";
103 |     let name = "auth=" + finger.screenname;
104 |     let uiConv = null;
105 |     try {
106 |       uiConv = otr.getUIConvForRecipient(
107 |         finger.account,
108 |         finger.protocol,
109 |         finger.screenname
110 |       );
111 |     } catch (e) {}
112 |     let win = window.openDialog(authDialog, name, features, (uiConv ? "start" : "pref"), uiConv, finger);
113 |     finger.trust = otr.isFingerprintTrusted(finger.fpointer);
114 |     if (uiConv) {
115 |       let context = otr.getContext(uiConv.target);
116 |       finger.status = otr.getStatus(otr.getTrustLevel(context));
117 |     }
118 |     fingerTree.treeBoxObject.invalidateRow(row);
119 |     fingerTreeView.selection.selectEventsSuppressed = false;
120 |   },
121 | 
122 | };
123 | 


--------------------------------------------------------------------------------
/chrome/content/finger.xul:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <?xml-stylesheet href="chrome://global/skin/" type="text/css" ?>
 3 | 
 4 | <!DOCTYPE window SYSTEM "chrome://otr/locale/finger.dtd">
 5 | 
 6 | <window id="otr-fingerwindow"
 7 |         onload="otrFinger.onload()"
 8 |         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
 9 |         title="&finger.title;">
10 | 
11 |   <script type="application/javascript" src="chrome://otr/content/finger.js"/>
12 | 
13 |   <label value="&finger.intro;" />
14 |   <separator class="thin"/>
15 |   <vbox id="fingerprints" class="contentPane" flex="1">
16 |     <tree flex="1"
17 |           width="800"
18 |           style="height: 20em;"
19 |           onselect="otrFinger.select()"
20 |           id="fingerTree">
21 |       <treecols>
22 |         <treecol id="screenname" label="&finger.screenName;" flex="20" />
23 |         <splitter class="tree-splitter"/>
24 |         <treecol id="status" label="&finger.status;" flex="10" />
25 |         <splitter class="tree-splitter"/>
26 |         <treecol id="verified" label="&finger.verified;" flex="10" />
27 |         <splitter class="tree-splitter"/>
28 |         <treecol id="fingerprint" label="&finger.fingerprint;" flex="120" />
29 |         <splitter class="tree-splitter"/>
30 |         <treecol id="account" label="&finger.account;" flex="60" />
31 |         <splitter class="tree-splitter"/>
32 |         <treecol id="protocol" label="&finger.protocol;" flex="10" />
33 |         <splitter class="tree-splitter"/>
34 |       </treecols>
35 |       <treechildren/>
36 |     </tree>
37 |     <separator class="thin"/>
38 |     <hbox>
39 |       <button label="&finger.verify;"
40 |               disabled="true"
41 |               id="verify"
42 |               oncommand="otrFinger.verify()"/>
43 |       <button label="&finger.remove;"
44 |               disabled="true"
45 |               id="remove"
46 |               oncommand="otrFinger.remove()"/>
47 |     </hbox>
48 |   </vbox>
49 | </window>


--------------------------------------------------------------------------------
/chrome/content/helpers.js:
--------------------------------------------------------------------------------
 1 | var isNode = (typeof process === "object");
 2 | var isJpm = !isNode && (typeof require === "function");
 3 | 
 4 | var OS;
 5 | 
 6 | if (!isNode) {
 7 |   var Ci, Cu, Cc;
 8 |   if (isJpm) {
 9 |     ({ Ci, Cu, Cc } = require("chrome"));
10 |   } else {
11 |     ({ interfaces: Ci, utils: Cu, classes: Cc } = Components);
12 |     Cu.import("resource:///modules/imServices.jsm");
13 |   }
14 |   Cu.import("resource://gre/modules/osfile.jsm");
15 | }
16 | 
17 | var helpers = {
18 | 
19 |   profilePath: function(filename) {
20 |     return isNode ?
21 |       path.resolve(__dirname, filename) :
22 |       OS.Path.join(OS.Constants.Path.profileDir, filename);
23 |   },
24 | 
25 |   getAccounts: function* () {
26 |     let accounts = Services.accounts.getAccounts();
27 |     while (accounts.hasMoreElements())
28 |       yield accounts.getNext();
29 |   },
30 | 
31 |   fileExists: function(filename) {
32 |     return OS.File.exists(filename);
33 |   },
34 | 
35 |   readTextFile: function(filename) {
36 |     let decoder = new TextDecoder();
37 |     return OS.File.read(filename).then(function(array) {
38 |       return decoder.decode(array);
39 |     });
40 |   },
41 | 
42 |   writeTextFile: function(filename, data) {
43 |     let encoder = new TextEncoder();
44 |     let array = encoder.encode(data);
45 |     // https://dutherenverseauborddelatable.wordpress.com/2014/02/05/is-my-data-on-the-disk-safety-properties-of-os-file-writeatomic/
46 |     return OS.File.writeAtomic(filename, array, { tmpPath: `${filename}.tmp` });
47 |   },
48 | 
49 | };
50 | 
51 | // exports
52 | 
53 | if (isNode) {
54 |   module.exports = { helpers: helpers };
55 | } else if (isJpm) {
56 |   exports.helpers = helpers;
57 | } else {
58 |   this.EXPORTED_SYMBOLS = ["helpers"];
59 | }
60 | 


--------------------------------------------------------------------------------
/chrome/content/libc.js:
--------------------------------------------------------------------------------
 1 | var isNode = (typeof process === "object");
 2 | var isJpm = !isNode && (typeof require === "function");
 3 | 
 4 | var ctypes, OS;
 5 | 
 6 | if (isNode) {
 7 |   ctypes = require("ctypes");
 8 |   // FIXME: This isn't implemented upstream yet.
 9 |   ctypes.size_t = ctypes.unsigned_int;
10 |   OS = process.platform;
11 | } else {
12 |   var Cu;
13 |   if (isJpm) {
14 |     ({ Cu } = require("chrome"));
15 |   } else {
16 |     ({ utils: Cu } = Components);
17 |   }
18 |   Cu.import("resource://gre/modules/ctypes.jsm");
19 |   Cu.import("resource://gre/modules/Services.jsm");
20 |   OS = Services.appinfo.OS.toLowerCase();
21 | }
22 | 
23 | // type defs
24 | 
25 | var FILE = ctypes.StructType("FILE");
26 | var fname_t = ctypes.char.ptr;
27 | var wchar_t = ctypes.char16_t;
28 | 
29 | // Set the abi and path to libc based on the OS.
30 | var libcAbi, libcPath;
31 | var strdup = "strdup";
32 | var fopen = "fopen";
33 | 
34 | switch(OS) {
35 | case "win32":
36 | case "winnt":
37 |   libcAbi = ctypes.winapi_abi;
38 |   libcPath = ctypes.libraryName("msvcrt");
39 |   strdup = "_strdup";
40 |   fopen = "_wfopen";
41 |   fname_t = wchar_t.ptr;
42 |   break;
43 | case "darwin":
44 |   libcAbi = ctypes.default_abi;
45 |   libcPath = ctypes.libraryName("c");
46 |   break;
47 | case "linux":
48 |   libcAbi = ctypes.default_abi;
49 |   libcPath = "libc.so.6";
50 |   break;
51 | default:
52 |   throw new Error("Unknown OS");
53 | }
54 | 
55 | var libc = ctypes.open(libcPath);
56 | 
57 | var libC = {
58 |   FILE: FILE,
59 |   memcmp: libc.declare(
60 |     "memcmp", libcAbi, ctypes.int,
61 |     ctypes.void_t.ptr,
62 |     ctypes.void_t.ptr,
63 |     ctypes.size_t
64 |   ),
65 |   free: libc.declare(
66 |     "free", libcAbi, ctypes.void_t,
67 |     ctypes.void_t.ptr
68 |   ),
69 |   strdup: libc.declare(
70 |     strdup, libcAbi, ctypes.char.ptr,
71 |     ctypes.char.ptr
72 |   ),
73 |   fclose: libc.declare(
74 |     "fclose", libcAbi, ctypes.int,
75 |     FILE.ptr
76 |   ),
77 |   fopen: libc.declare(
78 |     fopen, libcAbi, FILE.ptr,
79 |     fname_t,
80 |     fname_t
81 |   ),
82 | };
83 | 
84 | 
85 | // exports
86 | 
87 | if (isNode) {
88 |   module.exports = { libC: libC };
89 | } else if (isJpm) {
90 |   exports.libC = libC;
91 | } else {
92 |   this.EXPORTED_SYMBOLS = ["libC"];
93 | }
94 | 


--------------------------------------------------------------------------------
/chrome/content/libotr.js:
--------------------------------------------------------------------------------
  1 | var isNode = (typeof process === "object");
  2 | var isJpm = !isNode && (typeof require === "function");
  3 | 
  4 | var inTravis = false;
  5 | var libC, ctypes, OS;
  6 | var otrl_version = [4, 1, 1];
  7 | 
  8 | if (isNode) {
  9 |   ctypes = require("ctypes");
 10 |   // FIXME: This isn't implemented upstream yet.
 11 |   ctypes.size_t = ctypes.unsigned_int;
 12 |   ({ libC } = require("./libc.js"));
 13 |   inTravis = !!process.env.IN_TRAVIS;
 14 |   OS = process.platform;
 15 | } else {
 16 |   var Ci, Cu, Cc;
 17 |   if (isJpm) {
 18 |     ({ Ci, Cu, Cc } = require("chrome"));
 19 |     ({ libC } = require("./libc.js"));
 20 |     inTravis = !!require("sdk/system").env.IN_TRAVIS;
 21 |   } else {
 22 |     ({ interfaces: Ci, utils: Cu, classes: Cc } = Components);
 23 |     Cu.import("chrome://otr/content/libc.js");
 24 |   }
 25 |   Cu.import("resource://gre/modules/ctypes.jsm");
 26 |   Cu.import("resource://gre/modules/Services.jsm");
 27 |   OS = Services.appinfo.OS.toLowerCase();
 28 | }
 29 | 
 30 | if (inTravis)
 31 |   otrl_version = [4, 0, 0];  // 4.1.1 isn't available in trusty
 32 | 
 33 | var abi = ctypes.default_abi;
 34 | 
 35 | // Open libotr. Determine the path to the chrome directory and look for it
 36 | // there first. If not, fallback to searching the standard locations.
 37 | var libotr, libotrPath;
 38 | try {
 39 |   // try in chrome ... this'll throw in node
 40 |   let uri = "chrome://otr/content/" + ctypes.libraryName("otr");
 41 |   let chromeReg = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(Ci.nsIXULChromeRegistry);
 42 |   uri = chromeReg.convertChromeURL(Services.io.newURI(uri, null, null));
 43 |   libotrPath = uri.QueryInterface(Ci.nsIFileURL).file.path;
 44 |   libotr = ctypes.open(libotrPath);
 45 | } catch(e) {
 46 |   // look in standard locations
 47 |   libotrPath = ctypes.libraryName("otr");
 48 |   libotr = ctypes.open(libotrPath);
 49 | }
 50 | 
 51 | // Helper function to open files with the path properly encoded.
 52 | var callWithFILEp = function() {
 53 |   // Windows filenames are in UTF-16.
 54 |   var charType = (OS === "winnt") ? "jschar" : "char";
 55 | 
 56 |   var args = Array.from(arguments);
 57 |   var func = args.shift() + "_FILEp";
 58 |   var mode = ctypes[charType].array()(args.shift());
 59 |   var ind = args.shift();
 60 |   var filename = ctypes[charType].array()(args[ind]);
 61 | 
 62 |   var file = libC.fopen(filename, mode);
 63 |   if (file.isNull())
 64 |     return 1;
 65 | 
 66 |   // Swap filename with file.
 67 |   args[ind] = file;
 68 | 
 69 |   var ret = libOTR[func].apply(libOTR, args);
 70 |   libC.fclose(file);
 71 |   return ret;
 72 | };
 73 | 
 74 | // type defs
 75 | 
 76 | const FILE = libC.FILE;
 77 | 
 78 | const time_t = ctypes.long;
 79 | const gcry_error_t = ctypes.unsigned_int;
 80 | const gcry_cipher_hd_t = ctypes.StructType("gcry_cipher_handle").ptr;
 81 | const gcry_md_hd_t = ctypes.StructType("gcry_md_handle").ptr;
 82 | const gcry_mpi_t = ctypes.StructType("gcry_mpi").ptr;
 83 | 
 84 | const otrl_instag_t = ctypes.unsigned_int;
 85 | const OtrlPolicy = ctypes.unsigned_int;
 86 | const OtrlTLV = ctypes.StructType("s_OtrlTLV");
 87 | const ConnContext = ctypes.StructType("context");
 88 | const ConnContextPriv = ctypes.StructType("context_priv");
 89 | const OtrlMessageAppOps = ctypes.StructType("s_OtrlMessageAppOps");
 90 | const OtrlAuthInfo = ctypes.StructType("OtrlAuthInfo");
 91 | const Fingerprint = ctypes.StructType("s_fingerprint");
 92 | const s_OtrlUserState = ctypes.StructType("s_OtrlUserState");
 93 | const OtrlUserState = s_OtrlUserState.ptr;
 94 | const OtrlSMState = ctypes.StructType("OtrlSMState");
 95 | const DH_keypair = ctypes.StructType("DH_keypair");
 96 | const OtrlPrivKey = ctypes.StructType("s_OtrlPrivKey");
 97 | const OtrlInsTag = ctypes.StructType("s_OtrlInsTag");
 98 | const OtrlPendingPrivKey = ctypes.StructType("s_OtrlPendingPrivKey");
 99 | 
100 | const OTRL_PRIVKEY_FPRINT_HUMAN_LEN = 45;
101 | const fingerprint_t = ctypes.char.array(OTRL_PRIVKEY_FPRINT_HUMAN_LEN);
102 | const hash_t = ctypes.unsigned_char.array(20);
103 | 
104 | const app_data_free_t = ctypes.FunctionType(abi, ctypes.void_t, [
105 |   ctypes.void_t.ptr
106 | ]).ptr;
107 | 
108 | // enums
109 | 
110 | const OtrlErrorCode = ctypes.int;
111 | const OtrlSMPEvent = ctypes.int;
112 | const OtrlMessageEvent = ctypes.int;
113 | const OtrlFragmentPolicy = ctypes.int;
114 | const OtrlConvertType = ctypes.int;
115 | const OtrlMessageState = ctypes.int;
116 | const OtrlAuthState = ctypes.int;
117 | const OtrlSessionIdHalf = ctypes.int;
118 | const OtrlSMProgState = ctypes.int;
119 | const NextExpectedSMP = ctypes.int;
120 | 
121 | // callback signatures
122 | 
123 | const policy_cb_t = ctypes.FunctionType(abi, OtrlPolicy, [
124 |   ctypes.void_t.ptr, ConnContext.ptr
125 | ]).ptr;
126 | 
127 | const create_privkey_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
128 |   ctypes.void_t.ptr, ctypes.char.ptr, ctypes.char.ptr
129 | ]).ptr;
130 | 
131 | const is_logged_in_cb_t = ctypes.FunctionType(abi, ctypes.int, [
132 |   ctypes.void_t.ptr, ctypes.char.ptr, ctypes.char.ptr, ctypes.char.ptr
133 | ]).ptr;
134 | 
135 | const inject_message_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
136 |   ctypes.void_t.ptr, ctypes.char.ptr, ctypes.char.ptr, ctypes.char.ptr,
137 |   ctypes.char.ptr
138 | ]).ptr;
139 | 
140 | const update_context_list_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
141 |   ctypes.void_t.ptr
142 | ]).ptr;
143 | 
144 | const new_fingerprint_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
145 |   ctypes.void_t.ptr, OtrlUserState, ctypes.char.ptr, ctypes.char.ptr,
146 |   ctypes.char.ptr, ctypes.unsigned_char.array(20)
147 | ]).ptr;
148 | 
149 | const write_fingerprint_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
150 |   ctypes.void_t.ptr
151 | ]).ptr;
152 | 
153 | const gone_secure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
154 |   ctypes.void_t.ptr, ConnContext.ptr
155 | ]).ptr;
156 | 
157 | const gone_insecure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
158 |   ctypes.void_t.ptr, ConnContext.ptr
159 | ]).ptr;
160 | 
161 | const still_secure_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
162 |   ctypes.void_t.ptr, ConnContext.ptr, ctypes.int
163 | ]).ptr;
164 | 
165 | const max_message_size_cb_t = ctypes.FunctionType(abi, ctypes.int, [
166 |   ctypes.void_t.ptr, ConnContext.ptr
167 | ]).ptr;
168 | 
169 | const account_name_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
170 |   ctypes.void_t.ptr, ctypes.char.ptr, ctypes.char.ptr
171 | ]).ptr;
172 | 
173 | const account_name_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
174 |   ctypes.void_t.ptr, ctypes.char.ptr
175 | ]).ptr;
176 | 
177 | const received_symkey_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
178 |   ctypes.void_t.ptr, ConnContext.ptr, ctypes.unsigned_int,
179 |   ctypes.unsigned_char.ptr, ctypes.size_t, ctypes.unsigned_char.ptr
180 | ]).ptr;
181 | 
182 | const otr_error_message_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
183 |   ctypes.void_t.ptr, ConnContext.ptr, OtrlErrorCode
184 | ]).ptr;
185 | 
186 | const otr_error_message_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
187 |   ctypes.void_t.ptr, ctypes.char.ptr
188 | ]).ptr;
189 | 
190 | const resent_msg_prefix_cb_t = ctypes.FunctionType(abi, ctypes.char.ptr, [
191 |   ctypes.void_t.ptr, ConnContext.ptr
192 | ]).ptr;
193 | 
194 | const resent_msg_prefix_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
195 |   ctypes.void_t.ptr, ctypes.char.ptr
196 | ]).ptr;
197 | 
198 | const handle_smp_event_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
199 |   ctypes.void_t.ptr, OtrlSMPEvent, ConnContext.ptr, ctypes.unsigned_short,
200 |   ctypes.char.ptr
201 | ]).ptr;
202 | 
203 | const handle_msg_event_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
204 |   ctypes.void_t.ptr, OtrlMessageEvent, ConnContext.ptr, ctypes.char.ptr,
205 |   gcry_error_t
206 | ]).ptr;
207 | 
208 | const create_instag_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
209 |   ctypes.void_t.ptr, ctypes.char.ptr, ctypes.char.ptr
210 | ]).ptr;
211 | 
212 | const convert_msg_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
213 |   ctypes.void_t.ptr, ConnContext.ptr, OtrlConvertType, ctypes.char.ptr.ptr,
214 |   ctypes.char.ptr
215 | ]).ptr;
216 | 
217 | const convert_free_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
218 |   ctypes.void_t.ptr, ConnContext.ptr, ctypes.char.ptr
219 | ]).ptr;
220 | 
221 | const timer_control_cb_t = ctypes.FunctionType(abi, ctypes.void_t, [
222 |   ctypes.void_t.ptr, ctypes.unsigned_int
223 | ]).ptr;
224 | 
225 | // defines
226 | 
227 | s_OtrlUserState.define([
228 |   { context_root: ConnContext.ptr },
229 |   { privkey_root: OtrlPrivKey.ptr },
230 |   { instag_root: OtrlInsTag.ptr },
231 |   { pending_root: OtrlPendingPrivKey.ptr },
232 |   { timer_running: ctypes.int }
233 | ]);
234 | 
235 | Fingerprint.define([
236 |   { next: Fingerprint.ptr },
237 |   { tous: Fingerprint.ptr.ptr },
238 |   { fingerprint: ctypes.unsigned_char.ptr },
239 |   { context: ConnContext.ptr },
240 |   { trust: ctypes.char.ptr }
241 | ]);
242 | 
243 | DH_keypair.define([
244 |   { groupid: ctypes.unsigned_int },
245 |   { priv: gcry_mpi_t },
246 |   { pub: gcry_mpi_t }
247 | ]);
248 | 
249 | OtrlSMState.define([
250 |   { secret: gcry_mpi_t },
251 |   { x2: gcry_mpi_t },
252 |   { x3: gcry_mpi_t },
253 |   { g1: gcry_mpi_t },
254 |   { g2: gcry_mpi_t },
255 |   { g3: gcry_mpi_t },
256 |   { g3o: gcry_mpi_t },
257 |   { p: gcry_mpi_t },
258 |   { q: gcry_mpi_t },
259 |   { pab: gcry_mpi_t },
260 |   { qab: gcry_mpi_t },
261 |   { nextExpected: NextExpectedSMP },
262 |   { received_question: ctypes.int },
263 |   { sm_prog_state: OtrlSMProgState }
264 | ]);
265 | 
266 | OtrlAuthInfo.define([
267 |   { authstate: OtrlAuthState },
268 |   { context: ConnContext.ptr },
269 |   { our_dh: DH_keypair },
270 |   { our_keyid: ctypes.unsigned_int },
271 |   { encgx: ctypes.unsigned_char.ptr },
272 |   { encgx_len: ctypes.size_t },
273 |   { r: ctypes.unsigned_char.array(16) },
274 |   { hashgx: ctypes.unsigned_char.array(32) },
275 |   { their_pub: gcry_mpi_t },
276 |   { their_keyid: ctypes.unsigned_int },
277 |   { enc_c: gcry_cipher_hd_t },
278 |   { enc_cp: gcry_cipher_hd_t },
279 |   { mac_m1: gcry_md_hd_t },
280 |   { mac_m1p: gcry_md_hd_t },
281 |   { mac_m2: gcry_md_hd_t },
282 |   { mac_m2p: gcry_md_hd_t },
283 |   { their_fingerprint: ctypes.unsigned_char.array(20) },
284 |   { initiated: ctypes.int },
285 |   { protocol_version: ctypes.unsigned_int },
286 |   { secure_session_id: ctypes.unsigned_char.array(20) },
287 |   { secure_session_id_len: ctypes.size_t },
288 |   { session_id_half: OtrlSessionIdHalf },
289 |   { lastauthmsg: ctypes.char.ptr },
290 |   { commit_sent_time: time_t }
291 | ]);
292 | 
293 | ConnContext.define([
294 |   { next: ConnContext.ptr },
295 |   { tous: ConnContext.ptr.ptr },
296 |   { context_priv: ConnContextPriv.ptr },
297 |   { username: ctypes.char.ptr },
298 |   { accountname: ctypes.char.ptr },
299 |   { protocol: ctypes.char.ptr },
300 |   { m_context: ConnContext.ptr },
301 |   { recent_rcvd_child: ConnContext.ptr },
302 |   { recent_sent_child: ConnContext.ptr },
303 |   { recent_child: ConnContext.ptr },
304 |   { our_instance: otrl_instag_t },
305 |   { their_instance: otrl_instag_t },
306 |   { msgstate: OtrlMessageState },
307 |   { auth: OtrlAuthInfo },
308 |   { fingerprint_root: Fingerprint },
309 |   { active_fingerprint: Fingerprint.ptr },
310 |   { sessionid: ctypes.unsigned_char.array(20) },
311 |   { sessionid_len: ctypes.size_t },
312 |   { sessionid_half: OtrlSessionIdHalf },
313 |   { protocol_version: ctypes.unsigned_int },
314 |   { otr_offer: ctypes.int },
315 |   { app_data: ctypes.void_t.ptr },
316 |   { app_data_free: app_data_free_t },
317 |   { smstate: OtrlSMState.ptr }
318 | ]);
319 | 
320 | OtrlMessageAppOps.define([
321 |   { policy: policy_cb_t },
322 |   { create_privkey: create_privkey_cb_t },
323 |   { is_logged_in: is_logged_in_cb_t },
324 |   { inject_message: inject_message_cb_t },
325 |   { update_context_list: update_context_list_cb_t },
326 |   { new_fingerprint: new_fingerprint_cb_t },
327 |   { write_fingerprint: write_fingerprint_cb_t },
328 |   { gone_secure: gone_secure_cb_t },
329 |   { gone_insecure: gone_insecure_cb_t },
330 |   { still_secure: still_secure_cb_t },
331 |   { max_message_size: max_message_size_cb_t },
332 |   { account_name: account_name_cb_t },
333 |   { account_name_free: account_name_free_cb_t },
334 |   { received_symkey: received_symkey_cb_t },
335 |   { otr_error_message: otr_error_message_cb_t },
336 |   { otr_error_message_free: otr_error_message_free_cb_t },
337 |   { resent_msg_prefix: resent_msg_prefix_cb_t },
338 |   { resent_msg_prefix_free: resent_msg_prefix_free_cb_t },
339 |   { handle_smp_event: handle_smp_event_cb_t },
340 |   { handle_msg_event: handle_msg_event_cb_t },
341 |   { create_instag: create_instag_cb_t },
342 |   { convert_msg: convert_msg_cb_t },
343 |   { convert_free: convert_free_cb_t },
344 |   { timer_control: timer_control_cb_t }
345 | ]);
346 | 
347 | OtrlTLV.define([
348 |   { type: ctypes.unsigned_short },
349 |   { len: ctypes.unsigned_short },
350 |   { data: ctypes.unsigned_char.ptr },
351 |   { next: OtrlTLV.ptr }
352 | ]);
353 | 
354 | // policies
355 | 
356 | const OTRL_POLICY_ALLOW_V1 = 0x01;
357 | const OTRL_POLICY_ALLOW_V2 = 0x02;
358 | const OTRL_POLICY_ALLOW_V3 = 0x04;
359 | const OTRL_POLICY_REQUIRE_ENCRYPTION = 0x08;
360 | const OTRL_POLICY_SEND_WHITESPACE_TAG = 0x10;
361 | const OTRL_POLICY_WHITESPACE_START_AKE = 0x20;
362 | const OTRL_POLICY_ERROR_START_AKE = 0x40;
363 | 
364 | var libOTR = {
365 | 
366 |   path: libotrPath,
367 | 
368 |   // libotr API version
369 |   otrl_version: otrl_version,
370 | 
371 |   init: function() {
372 |     // apply version array as arguments to the init function
373 |     if (this.otrl_init.apply(this, this.otrl_version))
374 |       throw new Error("Couldn't initialize libotr.");
375 |   },
376 | 
377 |   // proto.h
378 | 
379 |   // If we ever see this sequence in a plaintext message, we'll assume the
380 |   // other side speaks OTR, and try to establish a connection.
381 |   OTRL_MESSAGE_TAG_BASE: " \t  \t\t\t\t \t \t \t  ",
382 | 
383 |   OTRL_POLICY_OPPORTUNISTIC: new ctypes.unsigned_int(
384 |     OTRL_POLICY_ALLOW_V2 |
385 |     // OTRL_POLICY_ALLOW_V3 |
386 |     OTRL_POLICY_SEND_WHITESPACE_TAG |
387 |     OTRL_POLICY_WHITESPACE_START_AKE |
388 |     // OTRL_POLICY_ERROR_START_AKE |
389 |     0
390 |   ),
391 | 
392 |   OTRL_POLICY_ALWAYS: new ctypes.unsigned_int(
393 |     OTRL_POLICY_ALLOW_V2 |
394 |     // OTRL_POLICY_ALLOW_V3 |
395 |     OTRL_POLICY_REQUIRE_ENCRYPTION |
396 |     OTRL_POLICY_WHITESPACE_START_AKE |
397 |     // OTRL_POLICY_ERROR_START_AKE |
398 |     0
399 |   ),
400 | 
401 |   fragPolicy: {
402 |     OTRL_FRAGMENT_SEND_SKIP: 0,
403 |     OTRL_FRAGMENT_SEND_ALL: 1,
404 |     OTRL_FRAGMENT_SEND_ALL_BUT_FIRST: 2,
405 |     OTRL_FRAGMENT_SEND_ALL_BUT_LAST: 3
406 |   },
407 | 
408 |   // Return a pointer to a newly-allocated OTR query message, customized
409 |   // with our name.  The caller should free() the result when he's done
410 |   // with it.
411 |   otrl_proto_default_query_msg: libotr.declare(
412 |     "otrl_proto_default_query_msg", abi, ctypes.char.ptr,
413 |     ctypes.char.ptr, OtrlPolicy
414 |   ),
415 | 
416 |   // Initialize the OTR library. Pass the version of the API you are using.
417 |   otrl_init: libotr.declare(
418 |     "otrl_init", abi, gcry_error_t,
419 |     ctypes.unsigned_int, ctypes.unsigned_int, ctypes.unsigned_int
420 |   ),
421 | 
422 |   // instag.h
423 | 
424 |   instag: {
425 |     OTRL_INSTAG_MASTER: new ctypes.unsigned_int(0),
426 |     OTRL_INSTAG_BEST: new ctypes.unsigned_int(1),
427 |     OTRL_INSTAG_RECENT: new ctypes.unsigned_int(2),
428 |     OTRL_INSTAG_RECENT_RECEIVED: new ctypes.unsigned_int(3),
429 |     OTRL_INSTAG_RECENT_SENT: new ctypes.unsigned_int(4),
430 |     OTRL_MIN_VALID_INSTAG: new ctypes.unsigned_int(0x100)
431 |   },
432 | 
433 |   // Get a new instance tag for the given account and write to file.  The FILE*
434 |   // must be open for writing.
435 |   otrl_instag_generate: callWithFILEp.bind(null, "otrl_instag_generate", "wb", 1),
436 |   otrl_instag_generate_FILEp: libotr.declare(
437 |     "otrl_instag_generate_FILEp", abi, gcry_error_t,
438 |     OtrlUserState, FILE.ptr, ctypes.char.ptr, ctypes.char.ptr
439 |   ),
440 | 
441 |   // Read our instance tag from a file on disk into the given OtrlUserState.
442 |   // The FILE* must be open for reading.
443 |   otrl_instag_read: callWithFILEp.bind(null, "otrl_instag_read", "rb", 1),
444 |   otrl_instag_read_FILEp: libotr.declare(
445 |     "otrl_instag_read_FILEp", abi, gcry_error_t,
446 |     OtrlUserState, FILE.ptr
447 |   ),
448 | 
449 |   // Write our instance tags to a file on disk.  The FILE* must be open for
450 |   // writing.
451 |   otrl_instag_write: callWithFILEp.bind(null, "otrl_instag_write", "wb", 1),
452 |   otrl_instag_write_FILEp: libotr.declare(
453 |     "otrl_instag_write_FILEp", abi, gcry_error_t,
454 |     OtrlUserState, FILE.ptr
455 |   ),
456 | 
457 |   // auth.h
458 | 
459 |   authState: {
460 |     OTRL_AUTHSTATE_NONE: 0,
461 |     OTRL_AUTHSTATE_AWAITING_DHKEY: 1,
462 |     OTRL_AUTHSTATE_AWAITING_REVEALSIG: 2,
463 |     OTRL_AUTHSTATE_AWAITING_SIG: 3,
464 |     OTRL_AUTHSTATE_V1_SETUP: 4
465 |   },
466 | 
467 |   // b64.h
468 | 
469 |   // base64 encode data.  Insert no linebreaks or whitespace.
470 |   // The buffer base64data must contain at least ((datalen+2)/3)*4 bytes of
471 |   // space. This function will return the number of bytes actually used.
472 |   otrl_base64_encode: libotr.declare(
473 |     "otrl_base64_encode", abi, ctypes.size_t,
474 |     ctypes.char.ptr, ctypes.unsigned_char.ptr, ctypes.size_t
475 |   ),
476 | 
477 |   // base64 decode data.  Skip non-base64 chars, and terminate at the
478 |   // first '=', or the end of the buffer.
479 |   // The buffer data must contain at least ((base64len+3) / 4) * 3 bytes
480 |   // of space. This function will return the number of bytes actually
481 |   // used.
482 |   otrl_base64_decode: libotr.declare(
483 |     "otrl_base64_decode", abi, ctypes.size_t,
484 |     ctypes.unsigned_char.ptr, ctypes.char.ptr, ctypes.size_t
485 |   ),
486 | 
487 |   // context.h
488 | 
489 |   otr_offer: {
490 |     OFFER_NOT: 0,
491 |     OFFER_SENT: 1,
492 |     OFFER_REJECTED: 2,
493 |     OFFER_ACCEPTED: 3
494 |   },
495 | 
496 |   messageState: {
497 |     OTRL_MSGSTATE_PLAINTEXT: 0,
498 |     OTRL_MSGSTATE_ENCRYPTED: 1,
499 |     OTRL_MSGSTATE_FINISHED: 2
500 |   },
501 | 
502 |   // Look up a connection context by name/account/protocol/instance from the
503 |   // given OtrlUserState.
504 |   otrl_context_find: libotr.declare(
505 |     "otrl_context_find", abi, ConnContext.ptr,
506 |     OtrlUserState,
507 |     ctypes.char.ptr,
508 |     ctypes.char.ptr,
509 |     ctypes.char.ptr,
510 |     otrl_instag_t,
511 |     ctypes.int,
512 |     ctypes.int.ptr,
513 |     ctypes.void_t.ptr,
514 |     ctypes.void_t.ptr
515 |   ),
516 | 
517 |   // Set the trust level for a given fingerprint.
518 |   otrl_context_set_trust: libotr.declare(
519 |     "otrl_context_set_trust", abi, ctypes.void_t,
520 |     Fingerprint.ptr, ctypes.char.ptr
521 |   ),
522 | 
523 |   // Find a fingerprint in a given context, perhaps adding it if not present.
524 |   otrl_context_find_fingerprint: libotr.declare(
525 |     "otrl_context_find_fingerprint", abi, Fingerprint.ptr,
526 |     ConnContext.ptr, hash_t, ctypes.int, ctypes.int.ptr
527 |   ),
528 | 
529 |   // Forget a fingerprint (and maybe the whole context).
530 |   otrl_context_forget_fingerprint: libotr.declare(
531 |     "otrl_context_forget_fingerprint", abi, ctypes.void_t,
532 |     Fingerprint.ptr, ctypes.int
533 |   ),
534 | 
535 |   // Return true iff the given fingerprint is marked as trusted.
536 |   otrl_context_is_fingerprint_trusted: libotr.declare(
537 |     "otrl_context_is_fingerprint_trusted", abi, ctypes.int,
538 |     Fingerprint.ptr
539 |   ),
540 | 
541 |   // dh.h
542 | 
543 |   sessionIdHalf: {
544 |     OTRL_SESSIONID_FIRST_HALF_BOLD: 0,
545 |     OTRL_SESSIONID_SECOND_HALF_BOLD: 1
546 |   },
547 | 
548 |   // sm.h
549 | 
550 |   nextExpectedSMP: {
551 |     OTRL_SMP_EXPECT1: 0,
552 |     OTRL_SMP_EXPECT2: 1,
553 |     OTRL_SMP_EXPECT3: 2,
554 |     OTRL_SMP_EXPECT4: 3,
555 |     OTRL_SMP_EXPECT5: 4
556 |   },
557 | 
558 |   smProgState: {
559 |     OTRL_SMP_PROG_OK: 0,
560 |     OTRL_SMP_PROG_CHEATED: -2,
561 |     OTRL_SMP_PROG_FAILED: -1,
562 |     OTRL_SMP_PROG_SUCCEEDED: 1
563 |   },
564 | 
565 |   // userstate.h
566 | 
567 |   // Create a new OtrlUserState.
568 |   otrl_userstate_create: libotr.declare(
569 |     "otrl_userstate_create", abi, OtrlUserState
570 |   ),
571 | 
572 |   // privkey.h
573 | 
574 |   // Generate a private DSA key for a given account, storing it into a file on
575 |   // disk, and loading it into the given OtrlUserState. Overwrite any
576 |   // previously generated keys for that account in that OtrlUserState.
577 |   otrl_privkey_generate: callWithFILEp.bind(null, "otrl_privkey_generate", "w+b", 1),
578 |   otrl_privkey_generate_FILEp: libotr.declare(
579 |     "otrl_privkey_generate_FILEp", abi, gcry_error_t,
580 |     OtrlUserState, FILE.ptr, ctypes.char.ptr, ctypes.char.ptr
581 |   ),
582 | 
583 |   // Begin a private key generation that will potentially take place in
584 |   // a background thread. This routine must be called from the main
585 |   // thread. It will set *newkeyp, which you can pass to
586 |   // otrl_privkey_generate_calculate in a background thread.  If it
587 |   // returns gcry_error(GPG_ERR_EEXIST), then a privkey creation for
588 |   // this accountname/protocol is already in progress, and *newkeyp will
589 |   // be set to NULL.
590 |   otrl_privkey_generate_start: libotr.declare(
591 |     "otrl_privkey_generate_start", abi, gcry_error_t,
592 |     OtrlUserState, ctypes.char.ptr, ctypes.char.ptr, ctypes.void_t.ptr.ptr
593 |   ),
594 | 
595 |   // Do the private key generation calculation. You may call this from a
596 |   // background thread.  When it completes, call
597 |   // otrl_privkey_generate_finish from the _main_ thread.
598 |   otrl_privkey_generate_calculate: libotr.declare(
599 |     "otrl_privkey_generate_calculate", abi, gcry_error_t,
600 |     ctypes.void_t.ptr
601 |   ),
602 | 
603 |   // Call this from the main thread only. It will write the newly created
604 |   // private key into the given file and store it in the OtrlUserState.
605 |   otrl_privkey_generate_finish: callWithFILEp.bind(null, "otrl_privkey_generate_finish", "w+b", 2),
606 |   otrl_privkey_generate_finish_FILEp: libotr.declare(
607 |     "otrl_privkey_generate_finish_FILEp", abi, gcry_error_t,
608 |     OtrlUserState, ctypes.void_t.ptr, FILE.ptr
609 |   ),
610 | 
611 |   // Call this from the main thread only, in the event that the background
612 |   // thread generating the key is cancelled. The newkey is deallocated,
613 |   // and must not be used further.
614 |   otrl_privkey_generate_cancelled: libotr.declare(
615 |     "otrl_privkey_generate_cancelled", abi, gcry_error_t,
616 |     OtrlUserState, ctypes.void_t.ptr
617 |   ),
618 | 
619 |   // Read a sets of private DSA keys from a file on disk into the given
620 |   // OtrlUserState.
621 |   otrl_privkey_read: callWithFILEp.bind(null, "otrl_privkey_read", "rb", 1),
622 |   otrl_privkey_read_FILEp: libotr.declare(
623 |     "otrl_privkey_read_FILEp", abi, gcry_error_t,
624 |     OtrlUserState, FILE.ptr
625 |   ),
626 | 
627 |   // Read the fingerprint store from a file on disk into the given
628 |   // OtrlUserState.
629 |   otrl_privkey_read_fingerprints: callWithFILEp.bind(null, "otrl_privkey_read_fingerprints", "rb", 1),
630 |   otrl_privkey_read_fingerprints_FILEp: libotr.declare(
631 |     "otrl_privkey_read_fingerprints_FILEp", abi, gcry_error_t,
632 |     OtrlUserState, FILE.ptr, ctypes.void_t.ptr, ctypes.void_t.ptr
633 |   ),
634 | 
635 |   // Write the fingerprint store from a given OtrlUserState to a file on disk.
636 |   otrl_privkey_write_fingerprints: callWithFILEp.bind(null, "otrl_privkey_write_fingerprints", "wb", 1),
637 |   otrl_privkey_write_fingerprints_FILEp: libotr.declare(
638 |     "otrl_privkey_write_fingerprints_FILEp", abi, gcry_error_t,
639 |     OtrlUserState, FILE.ptr
640 |   ),
641 | 
642 |   // The length of a string representing a human-readable version of a
643 |   // fingerprint (including the trailing NUL).
644 |   OTRL_PRIVKEY_FPRINT_HUMAN_LEN: OTRL_PRIVKEY_FPRINT_HUMAN_LEN,
645 | 
646 |   // Human readable fingerprint type
647 |   fingerprint_t: fingerprint_t,
648 | 
649 |   // fingerprint value
650 |   hash_t: hash_t,
651 | 
652 |   // Calculate a human-readable hash of our DSA public key. Return it in the
653 |   // passed fingerprint buffer. Return NULL on error, or a pointer to the given
654 |   // buffer on success.
655 |   otrl_privkey_fingerprint: libotr.declare(
656 |     "otrl_privkey_fingerprint", abi, ctypes.char.ptr,
657 |     OtrlUserState, fingerprint_t, ctypes.char.ptr, ctypes.char.ptr
658 |   ),
659 | 
660 |   // Convert a 20-byte hash value to a 45-byte human-readable value.
661 |   otrl_privkey_hash_to_human: libotr.declare(
662 |     "otrl_privkey_hash_to_human", abi, ctypes.void_t,
663 |     fingerprint_t, hash_t
664 |   ),
665 | 
666 |   // Calculate a raw hash of our DSA public key.  Return it in the passed
667 |   // fingerprint buffer.  Return NULL on error, or a pointer to the given
668 |   // buffer on success.
669 |   otrl_privkey_fingerprint_raw: libotr.declare(
670 |     "otrl_privkey_fingerprint_raw", abi, ctypes.unsigned_char.ptr,
671 |     OtrlUserState, hash_t, ctypes.char.ptr, ctypes.char.ptr
672 |   ),
673 | 
674 |   // uiOps callbacks
675 |   policy_cb_t: policy_cb_t,
676 |   create_privkey_cb_t: create_privkey_cb_t,
677 |   is_logged_in_cb_t: is_logged_in_cb_t,
678 |   inject_message_cb_t: inject_message_cb_t,
679 |   update_context_list_cb_t: update_context_list_cb_t,
680 |   new_fingerprint_cb_t: new_fingerprint_cb_t,
681 |   write_fingerprint_cb_t: write_fingerprint_cb_t,
682 |   gone_secure_cb_t: gone_secure_cb_t,
683 |   gone_insecure_cb_t: gone_insecure_cb_t,
684 |   still_secure_cb_t: still_secure_cb_t,
685 |   max_message_size_cb_t: max_message_size_cb_t,
686 |   account_name_cb_t: account_name_cb_t,
687 |   account_name_free_cb_t: account_name_free_cb_t,
688 |   received_symkey_cb_t: received_symkey_cb_t,
689 |   otr_error_message_cb_t: otr_error_message_cb_t,
690 |   otr_error_message_free_cb_t: otr_error_message_free_cb_t,
691 |   resent_msg_prefix_cb_t: resent_msg_prefix_cb_t,
692 |   resent_msg_prefix_free_cb_t: resent_msg_prefix_free_cb_t,
693 |   handle_smp_event_cb_t: handle_smp_event_cb_t,
694 |   handle_msg_event_cb_t: handle_msg_event_cb_t,
695 |   create_instag_cb_t: create_instag_cb_t,
696 |   convert_msg_cb_t: convert_msg_cb_t,
697 |   convert_free_cb_t: convert_free_cb_t,
698 |   timer_control_cb_t: timer_control_cb_t,
699 | 
700 |   // message.h
701 | 
702 |   OtrlMessageAppOps: OtrlMessageAppOps,
703 | 
704 |   errorCode: {
705 |     OTRL_ERRCODE_NONE: 0,
706 |     OTRL_ERRCODE_ENCRYPTION_ERROR: 1,
707 |     OTRL_ERRCODE_MSG_NOT_IN_PRIVATE: 2,
708 |     OTRL_ERRCODE_MSG_UNREADABLE: 3,
709 |     OTRL_ERRCODE_MSG_MALFORMED: 4
710 |   },
711 | 
712 |   smpEvent: {
713 |     OTRL_SMPEVENT_NONE: 0,
714 |     OTRL_SMPEVENT_ERROR: 1,
715 |     OTRL_SMPEVENT_ABORT: 2,
716 |     OTRL_SMPEVENT_CHEATED: 3,
717 |     OTRL_SMPEVENT_ASK_FOR_ANSWER: 4,
718 |     OTRL_SMPEVENT_ASK_FOR_SECRET: 5,
719 |     OTRL_SMPEVENT_IN_PROGRESS: 6,
720 |     OTRL_SMPEVENT_SUCCESS: 7,
721 |     OTRL_SMPEVENT_FAILURE: 8
722 |   },
723 | 
724 |   messageEvent: {
725 |     OTRL_MSGEVENT_NONE: 0,
726 |     OTRL_MSGEVENT_ENCRYPTION_REQUIRED: 1,
727 |     OTRL_MSGEVENT_ENCRYPTION_ERROR: 2,
728 |     OTRL_MSGEVENT_CONNECTION_ENDED: 3,
729 |     OTRL_MSGEVENT_SETUP_ERROR: 4,
730 |     OTRL_MSGEVENT_MSG_REFLECTED: 5,
731 |     OTRL_MSGEVENT_MSG_RESENT: 6,
732 |     OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE: 7,
733 |     OTRL_MSGEVENT_RCVDMSG_UNREADABLE: 8,
734 |     OTRL_MSGEVENT_RCVDMSG_MALFORMED: 9,
735 |     OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD: 10,
736 |     OTRL_MSGEVENT_LOG_HEARTBEAT_SENT: 11,
737 |     OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR: 12,
738 |     OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED: 13,
739 |     OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED: 14,
740 |     OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE: 15
741 |   },
742 | 
743 |   convertType: {
744 |     OTRL_CONVERT_SENDING: 0,
745 |     OTRL_CONVERT_RECEIVING: 1
746 |   },
747 | 
748 |   // Deallocate a message allocated by other otrl_message_* routines.
749 |   otrl_message_free: libotr.declare(
750 |     "otrl_message_free", abi, ctypes.void_t,
751 |     ctypes.char.ptr
752 |   ),
753 | 
754 |   // Handle a message about to be sent to the network.
755 |   otrl_message_sending: libotr.declare(
756 |     "otrl_message_sending", abi, gcry_error_t,
757 |     OtrlUserState,
758 |     OtrlMessageAppOps.ptr,
759 |     ctypes.void_t.ptr,
760 |     ctypes.char.ptr,
761 |     ctypes.char.ptr,
762 |     ctypes.char.ptr,
763 |     otrl_instag_t,
764 |     ctypes.char.ptr,
765 |     OtrlTLV.ptr,
766 |     ctypes.char.ptr.ptr,
767 |     OtrlFragmentPolicy,
768 |     ConnContext.ptr.ptr,
769 |     ctypes.void_t.ptr,
770 |     ctypes.void_t.ptr
771 |   ),
772 | 
773 |   // Handle a message just received from the network.
774 |   otrl_message_receiving: libotr.declare(
775 |     "otrl_message_receiving", abi, ctypes.int,
776 |     OtrlUserState,
777 |     OtrlMessageAppOps.ptr,
778 |     ctypes.void_t.ptr,
779 |     ctypes.char.ptr,
780 |     ctypes.char.ptr,
781 |     ctypes.char.ptr,
782 |     ctypes.char.ptr,
783 |     ctypes.char.ptr.ptr,
784 |     OtrlTLV.ptr.ptr,
785 |     ConnContext.ptr.ptr,
786 |     ctypes.void_t.ptr,
787 |     ctypes.void_t.ptr
788 |   ),
789 | 
790 |   // Put a connection into the PLAINTEXT state, first sending the
791 |   // other side a notice that we're doing so if we're currently ENCRYPTED,
792 |   // and we think he's logged in. Affects only the specified instance.
793 |   otrl_message_disconnect: libotr.declare(
794 |     "otrl_message_disconnect", abi, ctypes.void_t,
795 |     OtrlUserState,
796 |     OtrlMessageAppOps.ptr,
797 |     ctypes.void_t.ptr,
798 |     ctypes.char.ptr,
799 |     ctypes.char.ptr,
800 |     ctypes.char.ptr,
801 |     otrl_instag_t
802 |   ),
803 | 
804 |   // Call this function every so often, to clean up stale private state that
805 |   // may otherwise stick around in memory.
806 |   otrl_message_poll: libotr.declare(
807 |     "otrl_message_poll", abi, ctypes.void_t,
808 |     OtrlUserState,
809 |     OtrlMessageAppOps.ptr,
810 |     ctypes.void_t.ptr
811 |   ),
812 | 
813 |   // Initiate the Socialist Millionaires' Protocol.
814 |   otrl_message_initiate_smp: libotr.declare(
815 |     "otrl_message_initiate_smp", abi, ctypes.void_t,
816 |     OtrlUserState,
817 |     OtrlMessageAppOps.ptr,
818 |     ctypes.void_t.ptr,
819 |     ConnContext.ptr,
820 |     ctypes.char.ptr,
821 |     ctypes.size_t
822 |   ),
823 | 
824 |   // Initiate the Socialist Millionaires' Protocol and send a prompt
825 |   // question to the buddy.
826 |   otrl_message_initiate_smp_q: libotr.declare(
827 |     "otrl_message_initiate_smp_q", abi, ctypes.void_t,
828 |     OtrlUserState,
829 |     OtrlMessageAppOps.ptr,
830 |     ctypes.void_t.ptr,
831 |     ConnContext.ptr,
832 |     ctypes.char.ptr,
833 |     ctypes.char.ptr,
834 |     ctypes.size_t
835 |   ),
836 | 
837 |   // Respond to a buddy initiating the Socialist Millionaires' Protocol.
838 |   otrl_message_respond_smp: libotr.declare(
839 |     "otrl_message_respond_smp", abi, ctypes.void_t,
840 |     OtrlUserState,
841 |     OtrlMessageAppOps.ptr,
842 |     ctypes.void_t.ptr,
843 |     ConnContext.ptr,
844 |     ctypes.char.ptr,
845 |     ctypes.size_t
846 |   ),
847 | 
848 |   // Abort the SMP. Called when an unexpected SMP message breaks the
849 |   // normal flow.
850 |   otrl_message_abort_smp: libotr.declare(
851 |     "otrl_message_abort_smp", abi, ctypes.void_t,
852 |     OtrlUserState,
853 |     OtrlMessageAppOps.ptr,
854 |     ctypes.void_t.ptr,
855 |     ConnContext.ptr
856 |   ),
857 | 
858 |   // tlv.h
859 | 
860 |   tlvs: {
861 |     OTRL_TLV_PADDING: new ctypes.unsigned_short(0x0000),
862 |     OTRL_TLV_DISCONNECTED: new ctypes.unsigned_short(0x0001),
863 |     OTRL_TLV_SMP1: new ctypes.unsigned_short(0x0002),
864 |     OTRL_TLV_SMP2: new ctypes.unsigned_short(0x0003),
865 |     OTRL_TLV_SMP3: new ctypes.unsigned_short(0x0004),
866 |     OTRL_TLV_SMP4: new ctypes.unsigned_short(0x0005),
867 |     OTRL_TLV_SMP_ABORT: new ctypes.unsigned_short(0x0006),
868 |     OTRL_TLV_SMP1Q: new ctypes.unsigned_short(0x0007),
869 |     OTRL_TLV_SYMKEY: new ctypes.unsigned_short(0x0008)
870 |   },
871 | 
872 |   OtrlTLV: OtrlTLV,
873 | 
874 |   // Return the first TLV with the given type in the chain, or NULL if one
875 |   // isn't found.
876 |   otrl_tlv_find: libotr.declare(
877 |     "otrl_tlv_find", abi, OtrlTLV.ptr,
878 |     OtrlTLV.ptr, ctypes.unsigned_short
879 |   ),
880 | 
881 |   // Deallocate a chain of TLVs.
882 |   otrl_tlv_free: libotr.declare(
883 |     "otrl_tlv_free", abi, ctypes.void_t,
884 |     OtrlTLV.ptr
885 |   ),
886 | 
887 | };
888 | 
889 | 
890 | // exports
891 | 
892 | if (isNode) {
893 |   module.exports = { libOTR: libOTR };
894 | } else if (isJpm) {
895 |   exports.libOTR = libOTR;
896 | } else {
897 |   this.EXPORTED_SYMBOLS = ["libOTR"];
898 | }
899 | 


--------------------------------------------------------------------------------
/chrome/content/otr.js:
--------------------------------------------------------------------------------
   1 | var isNode = (typeof process === "object");
   2 | var isJpm = !isNode && (typeof require === "function");
   3 | var isIb = !isNode && !isJpm;
   4 | 
   5 | var libC, libOTR, ctypes, workerPath, helpers;
   6 | 
   7 | if (isNode) {
   8 |   ctypes = require("ctypes");
   9 |   // FIXME: This isn't implemented upstream yet.
  10 |   ctypes.size_t = ctypes.unsigned_int;
  11 |   ({ libC } = require("./libc.js"));
  12 |   ({ libOTR } = require("./libotr.js"));
  13 |   ({ helpers } = require("./helpers.js"));
  14 |   var path = require("path");
  15 | } else {
  16 |   var Ci, Cu, Cc, XPCOMUtils, l10nHelper;
  17 |   if (isJpm) {
  18 |     ({ Ci, Cu, Cc } = require("chrome"));
  19 |     ({ libC } = require("./libc.js"));
  20 |     ({ libOTR } = require("./libotr.js"));
  21 |     ({ XPCOMUtils, l10nHelper } = require("../../imXPCOMUtils.js"));
  22 |     workerPath = "resource://addon/chrome/content/worker.js";
  23 |     ({ helpers } = require("./helpers.js"));
  24 |   } else {
  25 |     ({ interfaces: Ci, utils: Cu, classes: Cc } = Components);
  26 |     Cu.import("chrome://otr/content/libc.js");
  27 |     Cu.import("chrome://otr/content/libotr.js");
  28 |     workerPath = "chrome://otr/content/worker.js";
  29 |     Cu.import("resource:///modules/imServices.jsm");
  30 |     Cu.import("resource:///modules/imXPCOMUtils.jsm");
  31 |     Cu.import("chrome://otr/content/helpers.js");
  32 |   }
  33 |   Cu.import("resource://gre/modules/PromiseWorker.jsm");
  34 |   Cu.import("resource://gre/modules/ctypes.jsm");
  35 |   XPCOMUtils.defineLazyGetter(this, "_", () =>
  36 |     l10nHelper("chrome://otr/locale/otr.properties")
  37 |   );
  38 | }
  39 | 
  40 | 
  41 | // some helpers
  42 | 
  43 | function setInterval(fn, delay) {
  44 |   let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  45 |   timer.init(fn, delay, Ci.nsITimer.TYPE_REPEATING_SLACK);
  46 |   return timer;
  47 | }
  48 | 
  49 | function clearInterval(timer) {
  50 |   timer.cancel();
  51 | }
  52 | 
  53 | // See: https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/Using_js-ctypes/Working_with_data#Determining_if_two_pointers_are_equal
  54 | function comparePointers(p, q) {
  55 |   p = ctypes.cast(p, ctypes.uintptr_t).value.toString();
  56 |   q = ctypes.cast(q, ctypes.uintptr_t).value.toString();
  57 |   return p === q;
  58 | }
  59 | 
  60 | function trustFingerprint(fingerprint) {
  61 |   return (!fingerprint.isNull() &&
  62 |     !fingerprint.contents.trust.isNull() &&
  63 |     fingerprint.contents.trust.readString().length > 0);
  64 | }
  65 | 
  66 | function isOnline(conv) {
  67 |   let ret = -1;
  68 |   if (conv.buddy)
  69 |     ret = conv.buddy.online ? 1 : 0;
  70 |   else if (["irc", "twitter"].indexOf(conv.account.protocol.normalizedName) > -1)
  71 |     ret = 1;  // no presence, but we want to send the disconnect msg
  72 |   return ret;
  73 | }
  74 | 
  75 | // Use the protocol name in user facing strings. See trac #16490
  76 | var names;
  77 | function protocolName(aNormalizedName) {
  78 |   if (!names) {
  79 |     names = new Map();
  80 |     let protocols = Services.core.getProtocols();
  81 |     while (protocols.hasMoreElements()) {
  82 |       let protocol = protocols.getNext();
  83 |       names.set(protocol.normalizedName, protocol.name);
  84 |     }
  85 |   }
  86 |   return names.get(aNormalizedName) || aNormalizedName;
  87 | }
  88 | 
  89 | 
  90 | // libotr context wrapper
  91 | 
  92 | function Context(context) {
  93 |   this._context = context;
  94 | }
  95 | 
  96 | Context.prototype = {
  97 |   constructor: Context,
  98 |   get username() { return this._context.contents.username.readString(); },
  99 |   get account() { return this._context.contents.accountname.readString(); },
 100 |   get protocol() { return this._context.contents.protocol.readString(); },
 101 |   get msgstate() { return this._context.contents.msgstate; },
 102 |   get fingerprint() { return this._context.contents.active_fingerprint; },
 103 |   get trust() { return trustFingerprint(this.fingerprint); },
 104 | };
 105 | 
 106 | 
 107 | // otr module
 108 | 
 109 | var otr = {
 110 | 
 111 |   hasRan: false,
 112 |   once: function() {
 113 |     libOTR.init();
 114 |     this.initUiOps();
 115 |     this.hasRan = true;
 116 |   },
 117 | 
 118 |   privateKeyPath: helpers.profilePath("otr.private_key"),
 119 |   fingerprintsPath: helpers.profilePath("otr.fingerprints"),
 120 |   instanceTagsPath: helpers.profilePath("otr.instance_tags"),
 121 | 
 122 |   init: function(opts) {
 123 |     opts = opts || {};
 124 | 
 125 |     if (!this.hasRan)
 126 |       this.once();
 127 | 
 128 |     this.verifyNudge = !!opts.verifyNudge;
 129 |     this.setPolicy(opts.requireEncryption);
 130 |     this.userstate = libOTR.otrl_userstate_create();
 131 | 
 132 |     if (isIb)
 133 |       this.registerCommands();
 134 | 
 135 |     // A map of UIConvs, keyed on the target.id
 136 |     this._convos = new Map();
 137 |     this._observers = [];
 138 |     this._buffer = [];
 139 |     this._poll_timer = null;
 140 | 
 141 |     // Async sending may fail in the transport protocols, so periodically
 142 |     // drop old messages from the internal buffer. Should be rare.
 143 |     const pluck_time = 1 * 60 * 1000;
 144 |     this._pluck_timer = setInterval(function() {
 145 |       let buf = this._buffer;
 146 |       for (let i = 0; i < buf.length;) {
 147 |         if ((Date.now() - buf[i].time) > pluck_time) {
 148 |           this.log("dropping an old message: " + buf[i].display);
 149 |           buf.splice(i, 1);
 150 |         } else {
 151 |           i += 1;
 152 |         }
 153 |       }
 154 |     }.bind(this), pluck_time);
 155 |   },
 156 | 
 157 |   close: function() {
 158 |     if (this._poll_timer) {
 159 |       clearInterval(this._poll_timer);
 160 |       this._poll_timer = null;
 161 |     }
 162 |     if (this._pluck_timer) {
 163 |       clearInterval(this._pluck_timer);
 164 |       this._pluck_timer = null;
 165 |     }
 166 |     this._buffer = null;
 167 |     this.unregisterCommands();
 168 |   },
 169 | 
 170 |   log: function(msg) {
 171 |     this.notifyObservers(msg, "otr:log");
 172 |   },
 173 | 
 174 |   protocolName: protocolName,
 175 | 
 176 |   setPolicy: function(requireEncryption) {
 177 |     this.policy = requireEncryption
 178 |       ? libOTR.OTRL_POLICY_ALWAYS
 179 |       : libOTR.OTRL_POLICY_OPPORTUNISTIC;
 180 |   },
 181 | 
 182 |   // load stored files from my profile
 183 |   loadFiles: function() {
 184 |     return Promise.all([
 185 |       helpers.fileExists(this.privateKeyPath).then((exists) => {
 186 |         if (exists && libOTR.otrl_privkey_read(
 187 |           this.userstate, this.privateKeyPath
 188 |         )) throw new Error("Failed to read private keys.");
 189 |       }),
 190 |       helpers.fileExists(this.fingerprintsPath).then((exists) => {
 191 |         if (exists && libOTR.otrl_privkey_read_fingerprints(
 192 |           this.userstate, this.fingerprintsPath, null, null
 193 |         )) throw new Error("Failed to read fingerprints.");
 194 |       }),
 195 |       helpers.fileExists(this.instanceTagsPath).then((exists) => {
 196 |         if (exists && libOTR.otrl_instag_read(
 197 |           this.userstate, this.instanceTagsPath
 198 |         )) throw new Error("Failed to read instance tags.");
 199 |       })
 200 |     ]);
 201 |   },
 202 | 
 203 |   commands: [],
 204 | 
 205 |   registerCommands: function() {
 206 |     this.commands.forEach(function(cmd) {
 207 |       cmd.priority = Ci.imICommand.CMD_PRIORITY_HIGH;
 208 |       cmd.usageContext = Ci.imICommand.CMD_CONTEXT_ALL;
 209 |       cmd.QueryInterface = XPCOMUtils.generateQI([Ci.imICommand]);
 210 |       // don't replace the former command by specifying a protocol id
 211 |       Services.cmd.registerCommand(cmd);
 212 |     });
 213 |   },
 214 | 
 215 |   unregisterCommands: function() {
 216 |     this.commands.forEach(cmd => Services.cmd.unregisterCommand(cmd.name));
 217 |   },
 218 | 
 219 |   // generate a private key in a worker
 220 |   generatePrivateKey: function(account, protocol) {
 221 |     let newkey = new ctypes.void_t.ptr();
 222 |     let err = libOTR.otrl_privkey_generate_start(
 223 |       otr.userstate, account, protocol, newkey.address()
 224 |     );
 225 |     if (err || newkey.isNull())
 226 |       return Promise.reject("otrl_privkey_generate_start (" + err + ")");
 227 |     let worker = new BasePromiseWorker(workerPath);
 228 |     return worker.post("generateKey", [
 229 |       libOTR.path, libOTR.otrl_version, newkey.toSource()
 230 |     ]).then(function() {
 231 |       let err = libOTR.otrl_privkey_generate_finish(
 232 |         otr.userstate, newkey, otr.privateKeyPath
 233 |       );
 234 |       if (err)
 235 |         throw new Error("otrl_privkey_generate_calculate (" + err + ")");
 236 |     }).catch(function(err) {
 237 |       if (!newkey.isNull())
 238 |         libOTR.otrl_privkey_generate_cancelled(otr.userstate, newkey);
 239 |       throw err;
 240 |     });
 241 |   },
 242 | 
 243 |   // write fingerprints to file synchronously
 244 |   writeFingerprints: function() {
 245 |     if (libOTR.otrl_privkey_write_fingerprints(
 246 |       this.userstate, this.fingerprintsPath
 247 |     )) throw new Error("Failed to write fingerprints.");
 248 |   },
 249 | 
 250 |   // generate instance tag synchronously
 251 |   generateInstanceTag: function(account, protocol) {
 252 |     if (libOTR.otrl_instag_generate(
 253 |       this.userstate, this.instanceTagsPath, account, protocol
 254 |     )) throw new Error("Failed to generate instance tag.");
 255 |   },
 256 | 
 257 |   // get my fingerprint
 258 |   privateKeyFingerprint: function(account, protocol) {
 259 |     let fingerprint = libOTR.otrl_privkey_fingerprint(
 260 |       this.userstate, new libOTR.fingerprint_t(), account, protocol
 261 |     );
 262 |     return fingerprint.isNull() ? null : fingerprint.readString();
 263 |   },
 264 | 
 265 |   // get my raw fingerprint
 266 |   privateKeyFingerprintRaw: function(account, protocol) {
 267 |     let hash = libOTR.otrl_privkey_fingerprint_raw(
 268 |       this.userstate, new libOTR.hash_t(), account, protocol);
 269 |     if (hash.isNull())
 270 |       throw Error("No fingerprint found.");
 271 |     return hash;
 272 |   },
 273 | 
 274 |   // return a human readable string for a fingerprint
 275 |   hashToHuman: function(fingerprint) {
 276 |     let hash = fingerprint.contents.fingerprint;
 277 |     if (hash.isNull())
 278 |       throw Error("No fingerprint found.");
 279 |     let human = new libOTR.fingerprint_t();
 280 |     libOTR.otrl_privkey_hash_to_human(human, hash);
 281 |     return human.readString();
 282 |   },
 283 | 
 284 |   base64encode: function(data, dataLen) {
 285 |     // CData objects are initialized with zeroes.  The plus one gives us
 286 |     // our null byte so that readString below is safe.
 287 |     let buf = ctypes.char.array(Math.floor((dataLen+2)/3)*4 + 1)();
 288 |     let size = libOTR.otrl_base64_encode(buf, data, dataLen);
 289 |     return buf.readString();  // str
 290 |   },
 291 | 
 292 |   base64decode: function(str) {
 293 |     let size = str.length;
 294 |     // +1 here so that we're safe in calling readString on data in the tests.
 295 |     let data = ctypes.unsigned_char.array(Math.floor((size+3)/4)*3 + 1)();
 296 |     let dataLen = libOTR.otrl_base64_decode(data, str, size);
 297 |     // We aren't returning the dataLen since we know the hash length in our
 298 |     // one use case so far.
 299 |     return data;
 300 |   },
 301 | 
 302 |   getTrustLevel: function(context) {
 303 |     let best_level = otr.trustState.TRUST_NOT_PRIVATE;
 304 |     let level = otr.trust(context);
 305 |     if (level === otr.trustState.TRUST_PRIVATE) {
 306 |       best_level = otr.trustState.TRUST_PRIVATE;
 307 |     } else if (level === otr.trustState.TRUST_UNVERIFIED
 308 |         && best_level !== otr.trustState.TRUST_PRIVATE) {
 309 |       best_level = otr.trustState.TRUST_UNVERIFIED;
 310 |     } else if (level === otr.trustState.TRUST_FINISHED
 311 |         && best_level === otr.trustState.TRUST_NOT_PRIVATE) {
 312 |       best_level = otr.trustState.TRUST_FINISHED;
 313 |     }
 314 |     return best_level;
 315 |   },
 316 | 
 317 |   getStatus: function(level) {
 318 |     switch(level) {
 319 |     case otr.trustState.TRUST_NOT_PRIVATE:
 320 |       return _("trust.not_private");
 321 |     case otr.trustState.TRUST_UNVERIFIED:
 322 |       return _("trust.unverified");
 323 |     case otr.trustState.TRUST_PRIVATE:
 324 |       return _("trust.private");
 325 |     case otr.trustState.TRUST_FINISHED:
 326 |       return _("trust.finished");
 327 |     }
 328 |   },
 329 | 
 330 |   // get list of known fingerprints
 331 |   knownFingerprints: function() {
 332 |     let fps = [];
 333 |     for (
 334 |       let context = this.userstate.contents.context_root;
 335 |       !context.isNull();
 336 |       context = context.contents.next
 337 |     ) {
 338 |       // skip child contexts
 339 |       if (!comparePointers(context.contents.m_context, context))
 340 |         continue;
 341 |       let wContext = new Context(context);
 342 |       for (
 343 |         let fingerprint = context.contents.fingerprint_root.next;
 344 |         !fingerprint.isNull();
 345 |         fingerprint = fingerprint.contents.next
 346 |       ) {
 347 |         let trust = trustFingerprint(fingerprint);
 348 |         let used = false;
 349 |         let best_level = otr.trustState.TRUST_NOT_PRIVATE;
 350 |         for (
 351 |           let context_itr = context;
 352 |           !context_itr.isNull() &&
 353 |             comparePointers(context_itr.contents.m_context, context);
 354 |           context_itr = context_itr.contents.next
 355 |         ) {
 356 |           if (comparePointers(
 357 |             context_itr.contents.active_fingerprint, fingerprint
 358 |           )) {
 359 |             used = true;
 360 |             best_level = otr.getTrustLevel(new Context(context_itr));
 361 |           }
 362 |         }
 363 |         fps.push({
 364 |           fpointer: fingerprint.contents.address(),
 365 |           fingerprint: otr.hashToHuman(fingerprint),
 366 |           screenname: wContext.username,
 367 |           account: wContext.account,
 368 |           protocol: wContext.protocol,
 369 |           trust: trust,
 370 |           status: used ? otr.getStatus(best_level) : _("trust.unused"),
 371 |           purge: false,
 372 |         });
 373 |       }
 374 |     }
 375 |     return fps;
 376 |   },
 377 | 
 378 |   forgetFingerprints(fps) {
 379 |     let write = false;
 380 |     fps.forEach(function(obj, i) {
 381 |       if (!obj.purge)
 382 |         return;
 383 |       else
 384 |         obj.purge = false;  // reset early
 385 |       let fingerprint = obj.fpointer;
 386 |       if (fingerprint.isNull())
 387 |         return;
 388 |       // don't do anything if fp is active and we're in an encrypted state
 389 |       let context = fingerprint.contents.context.contents.m_context;
 390 |       for (
 391 |         let context_itr = context;
 392 |         !context_itr.isNull() &&
 393 |           comparePointers(context_itr.contents.m_context, context);
 394 |         context_itr = context_itr.contents.next
 395 |       ) {
 396 |         if (
 397 |           context_itr.contents.msgstate === otr.messageState.OTRL_MSGSTATE_ENCRYPTED &&
 398 |           comparePointers(context_itr.contents.active_fingerprint, fingerprint)
 399 |         ) return;
 400 |       }
 401 |       write = true;
 402 |       libOTR.otrl_context_forget_fingerprint(fingerprint, 1);
 403 |       fps[i] = null;  // null out removed fps
 404 |     });
 405 |     if (write)
 406 |       otr.writeFingerprints();
 407 |   },
 408 | 
 409 |   addFingerprint: function(context, hex) {
 410 |     let fingerprint = new libOTR.hash_t();
 411 |     if (hex.length != 40) throw new Error("Invalid fingerprint value.");
 412 |     let bytes = hex.match(/.{1,2}/g);
 413 |     for (let i = 0; i < 20; i++)
 414 |       fingerprint[i] = parseInt(bytes[i], 16);
 415 |     return libOTR.otrl_context_find_fingerprint(context._context, fingerprint, 1, null);
 416 |   },
 417 | 
 418 |   getFingerprintsForRecipient: function(account, protocol, recipient) {
 419 |     let fingers = otr.knownFingerprints();
 420 |     return fingers.filter(function(fg) {
 421 |       return fg.account == account &&
 422 |              fg.protocol == protocol &&
 423 |              fg.screenname == recipient;
 424 |     });
 425 |   },
 426 | 
 427 |   isFingerprintTrusted: function(fingerprint) {
 428 |     return !!libOTR.otrl_context_is_fingerprint_trusted(fingerprint);
 429 |   },
 430 | 
 431 |   // update trust in fingerprint
 432 |   setTrust: function(fingerprint, trust, context) {
 433 |     // ignore if no change in trust
 434 |     if (context && (trust === context.trust))
 435 |       return;
 436 |     libOTR.otrl_context_set_trust(fingerprint, trust ? "verified" : "");
 437 |     this.writeFingerprints();
 438 |     if (context)
 439 |       this.notifyTrust(context);
 440 |   },
 441 | 
 442 |   notifyTrust: function(context) {
 443 |     this.notifyObservers(context, "otr:msg-state");
 444 |     this.notifyObservers(context, "otr:trust-state");
 445 |   },
 446 | 
 447 |   authUpdate: function(context, progress, success) {
 448 |     this.notifyObservers({
 449 |       context: context,
 450 |       progress: progress,
 451 |       success: success,
 452 |     }, "otr:auth-update");
 453 |   },
 454 | 
 455 |   // expose message states
 456 |   messageState: libOTR.messageState,
 457 | 
 458 |   // get context from conv
 459 |   getContext: function(conv) {
 460 |     let context = libOTR.otrl_context_find(
 461 |       this.userstate,
 462 |       conv.normalizedName,
 463 |       conv.account.normalizedName,
 464 |       conv.account.protocol.normalizedName,
 465 |       libOTR.instag.OTRL_INSTAG_BEST, 1, null, null, null
 466 |     );
 467 |     return new Context(context);
 468 |   },
 469 | 
 470 |   getContextFromRecipient(account, protocol, recipient) {
 471 |     let context = libOTR.otrl_context_find(
 472 |       this.userstate, recipient, account, protocol,
 473 |       libOTR.instag.OTRL_INSTAG_BEST, 1, null, null, null
 474 |     );
 475 |     return new Context(context);
 476 |   },
 477 | 
 478 |   getUIConvFromContext: function(context) {
 479 |     return this.getUIConvForRecipient(
 480 |       context.account, context.protocol, context.username
 481 |     );
 482 |   },
 483 | 
 484 |   getUIConvForRecipient: function(account, protocol, recipient) {
 485 |     let uiConvs = this._convos.values();
 486 |     let uiConv = uiConvs.next();
 487 |     while (!uiConv.done) {
 488 |       let conv = uiConv.value.target;
 489 |       if (conv.account.normalizedName === account &&
 490 |           conv.account.protocol.normalizedName === protocol &&
 491 |           conv.normalizedName === recipient)
 492 |         return uiConv.value;
 493 |       uiConv = uiConvs.next();
 494 |     }
 495 |     throw new Error("Couldn't find conversation.");
 496 |   },
 497 | 
 498 |   getUIConvFromConv: function(conv) {
 499 |     // Maybe prefer Services.conversations.getUIConversation(conv);
 500 |     return this._convos.get(conv.id);
 501 |   },
 502 | 
 503 |   disconnect: function(conv, remove) {
 504 |     libOTR.otrl_message_disconnect(
 505 |       this.userstate,
 506 |       this.uiOps.address(),
 507 |       null,
 508 |       conv.account.normalizedName,
 509 |       conv.account.protocol.normalizedName,
 510 |       conv.normalizedName,
 511 |       libOTR.instag.OTRL_INSTAG_BEST
 512 |     );
 513 |     if (remove) {
 514 |       let uiConv = this.getUIConvFromConv(conv);
 515 |       if (uiConv)
 516 |         this.removeConversation(uiConv);
 517 |     } else
 518 |       this.notifyObservers(this.getContext(conv), "otr:disconnected");
 519 |   },
 520 | 
 521 |   sendQueryMsg: function(conv) {
 522 |     let query = libOTR.otrl_proto_default_query_msg(
 523 |       conv.account.normalizedName,
 524 |       this.policy
 525 |     );
 526 |     if (query.isNull()) {
 527 |       Cu.reportError(new Error("Sending query message failed."));
 528 |       return;
 529 |     }
 530 |     // Use the default msg to format the version.
 531 |     // We don't supprt v1 of the protocol so this should be fine.
 532 |     var queryMsg = /^\?OTR.*?\?/.exec(query.readString())[0] + "\n";
 533 |     queryMsg += _("query.msg", conv.account.normalizedName);
 534 |     conv.sendMsg(queryMsg);
 535 |     libOTR.otrl_message_free(query);
 536 |   },
 537 | 
 538 |   trustState: {
 539 |     TRUST_NOT_PRIVATE: 0,
 540 |     TRUST_UNVERIFIED: 1,
 541 |     TRUST_PRIVATE: 2,
 542 |     TRUST_FINISHED: 3
 543 |   },
 544 | 
 545 |   trust: function(context) {
 546 |     let level = this.trustState.TRUST_NOT_PRIVATE;
 547 |     switch(context.msgstate) {
 548 |     case this.messageState.OTRL_MSGSTATE_ENCRYPTED:
 549 |       level = context.trust
 550 |         ? this.trustState.TRUST_PRIVATE
 551 |         : this.trustState.TRUST_UNVERIFIED;
 552 |       break;
 553 |     case this.messageState.OTRL_MSGSTATE_FINISHED:
 554 |       level = this.trustState.TRUST_FINISHED;
 555 |       break;
 556 |     }
 557 |     return level;
 558 |   },
 559 | 
 560 |   // uiOps callbacks
 561 | 
 562 |   // Return the OTR policy for the given context.
 563 |   policy_cb: function(opdata, context) {
 564 |     return this.policy;
 565 |   },
 566 | 
 567 |   // Create a private key for the given accountname/protocol if desired.
 568 |   create_privkey_cb: function(opdata, accountname, protocol) {
 569 |     let args = {
 570 |       account: accountname.readString(),
 571 |       protocol: protocol.readString(),
 572 |     };
 573 |     this.notifyObservers(args, "otr:generate");
 574 |   },
 575 | 
 576 |   // Report whether you think the given user is online. Return 1 if you think
 577 |   // they are, 0 if you think they aren't, -1 if you're not sure.
 578 |   is_logged_in_cb: function(opdata, accountname, protocol, recipient) {
 579 |     let conv = this.getUIConvForRecipient(
 580 |       accountname.readString(),
 581 |       protocol.readString(),
 582 |       recipient.readString()
 583 |     ).target;
 584 |     return isOnline(conv);
 585 |   },
 586 | 
 587 |   // Send the given IM to the given recipient from the given
 588 |   // accountname/protocol.
 589 |   inject_message_cb: function(opdata, accountname, protocol, recipient, message) {
 590 |     let aMsg = message.readString();
 591 |     this.log("inject_message_cb (msglen:" + aMsg.length + "): " + aMsg);
 592 |     this.getUIConvForRecipient(
 593 |       accountname.readString(),
 594 |       protocol.readString(),
 595 |       recipient.readString()
 596 |     ).target.sendMsg(aMsg);
 597 |   },
 598 | 
 599 |   // A new fingerprint for the given user has been received.
 600 |   new_fingerprint_cb: function(opdata, us, accountname, protocol, username, fingerprint) {
 601 |     let context = libOTR.otrl_context_find(
 602 |       us, username, accountname, protocol,
 603 |       libOTR.instag.OTRL_INSTAG_MASTER, 1, null, null, null
 604 |     );
 605 | 
 606 |     let seen = false;
 607 |     let fp = context.contents.fingerprint_root.next;
 608 |     while (!fp.isNull()) {
 609 |       if (libC.memcmp(fingerprint, fp.contents.fingerprint, new ctypes.size_t(20))) {
 610 |         seen = true;
 611 |         break;
 612 |       }
 613 |       fp = fp.contents.next;
 614 |     }
 615 | 
 616 |     // Only nudge on new fingerprint, as opposed to always.
 617 |     if (!this.verifyNudge)
 618 |       this.notifyObservers(new Context(context), "otr:unverified",
 619 |         (seen ? "seen" : "unseen"));
 620 |   },
 621 | 
 622 |   // The list of known fingerprints has changed.  Write them to disk.
 623 |   write_fingerprint_cb: function(opdata) {
 624 |     this.writeFingerprints();
 625 |   },
 626 | 
 627 |   // A ConnContext has entered a secure state.
 628 |   gone_secure_cb: function(opdata, context) {
 629 |     context = new Context(context);
 630 |     let str = "context.gone_secure_" + (context.trust ? "private" : "unverified");
 631 |     this.notifyObservers(context, "otr:msg-state");
 632 |     this.sendAlert(context, _(str, context.username));
 633 |     if (this.verifyNudge && !context.trust)
 634 |       this.notifyObservers(context, "otr:unverified", "unseen");
 635 |   },
 636 | 
 637 |   // A ConnContext has left a secure state.
 638 |   gone_insecure_cb: function(opdata, context) {
 639 |     // This isn't used. See: https://bugs.otr.im/issues/48
 640 |   },
 641 | 
 642 |   // We have completed an authentication, using the D-H keys we already knew.
 643 |   // is_reply indicates whether we initiated the AKE.
 644 |   still_secure_cb: function(opdata, context, is_reply) {
 645 |     // Indicate the private conversation was refreshed.
 646 |     if (!is_reply) {
 647 |       context = new Context(context);
 648 |       this.notifyObservers(context, "otr:msg-state");
 649 |       this.sendAlert(context, _("context.still_secure", context.username));
 650 |     }
 651 |   },
 652 | 
 653 |   // Find the maximum message size supported by this protocol.
 654 |   max_message_size_cb: function(opdata, context) {
 655 |     context = new Context(context);
 656 |     // These values are, for the most part, from pidgin-otr's mms_table.
 657 |     switch(context.protocol) {
 658 |     case "irc":
 659 |     case "prpl-irc":
 660 |       return 417;
 661 |     case "facebook":
 662 |     case "gtalk":
 663 |     case "odnoklassniki":
 664 |     case "jabber":
 665 |     case "xmpp":
 666 |       return 65536;
 667 |     case "prpl-yahoo":
 668 |       return 799;
 669 |     case "prpl-msn":
 670 |       return 1409;
 671 |     case "prpl-icq":
 672 |       return 2346;
 673 |     case "prpl-gg":
 674 |       return 1999;
 675 |     case "prpl-aim":
 676 |     case "prpl-oscar":
 677 |       return 2343;
 678 |     case "prpl-novell":
 679 |       return 1792;
 680 |     default:
 681 |       return 0;
 682 |     }
 683 |   },
 684 | 
 685 |   // We received a request from the buddy to use the current "extra" symmetric
 686 |   // key.
 687 |   received_symkey_cb: function(opdata, context, use, usedata, usedatalen, symkey) {
 688 |     // Ignore until we have a use.
 689 |   },
 690 | 
 691 |   // Return a string according to the error event.
 692 |   otr_error_message_cb: function(opdata, context, err_code) {
 693 |     context = new Context(context);
 694 |     let msg;
 695 |     switch(err_code) {
 696 |     case libOTR.errorCode.OTRL_ERRCODE_ENCRYPTION_ERROR:
 697 |       msg = _("error.enc");
 698 |       break;
 699 |     case libOTR.errorCode.OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
 700 |       msg = _("error.not_priv", context.username);
 701 |       break;
 702 |     case libOTR.errorCode.OTRL_ERRCODE_MSG_UNREADABLE:
 703 |       msg = _("error.unreadable");
 704 |       break;
 705 |     case libOTR.errorCode.OTRL_ERRCODE_MSG_MALFORMED:
 706 |       msg = _("error.malformed");
 707 |       break;
 708 |     default:
 709 |       return null;
 710 |     }
 711 |     return libC.strdup(msg);
 712 |   },
 713 | 
 714 |   // Deallocate a string returned by otr_error_message_cb.
 715 |   otr_error_message_free_cb: function(opdata, err_msg) {
 716 |     if (!err_msg.isNull())
 717 |       libC.free(err_msg);
 718 |   },
 719 | 
 720 |   // Return a string that will be prefixed to any resent message.
 721 |   resent_msg_prefix_cb: function(opdata, context) {
 722 |     return libC.strdup(_("resent"));
 723 |   },
 724 | 
 725 |   // Deallocate a string returned by resent_msg_prefix.
 726 |   resent_msg_prefix_free_cb: function(opdata, prefix) {
 727 |     if (!prefix.isNull())
 728 |       libC.free(prefix);
 729 |   },
 730 | 
 731 |   // Update the authentication UI with respect to SMP events.
 732 |   handle_smp_event_cb: function(opdata, smp_event, context, progress_percent, question) {
 733 |     context = new Context(context);
 734 |     switch(smp_event) {
 735 |     case libOTR.smpEvent.OTRL_SMPEVENT_NONE:
 736 |       break;
 737 |     case libOTR.smpEvent.OTRL_SMPEVENT_ASK_FOR_ANSWER:
 738 |     case libOTR.smpEvent.OTRL_SMPEVENT_ASK_FOR_SECRET:
 739 |       this.notifyObservers({
 740 |         context: context,
 741 |         progress: progress_percent,
 742 |         question: question.isNull() ? null : question.readString()
 743 |       }, "otr:auth-ask");
 744 |       break;
 745 |     case libOTR.smpEvent.OTRL_SMPEVENT_CHEATED:
 746 |       otr.abortSMP(context);
 747 |       /* falls through */
 748 |     case libOTR.smpEvent.OTRL_SMPEVENT_IN_PROGRESS:
 749 |     case libOTR.smpEvent.OTRL_SMPEVENT_SUCCESS:
 750 |     case libOTR.smpEvent.OTRL_SMPEVENT_FAILURE:
 751 |     case libOTR.smpEvent.OTRL_SMPEVENT_ABORT:
 752 |       this.authUpdate(context, progress_percent,
 753 |         (smp_event === libOTR.smpEvent.OTRL_SMPEVENT_SUCCESS));
 754 |       break;
 755 |     case libOTR.smpEvent.OTRL_SMPEVENT_ERROR:
 756 |       otr.abortSMP(context);
 757 |       break;
 758 |     default:
 759 |       this.log("smp event: " + smp_event);
 760 |     }
 761 |   },
 762 | 
 763 |   // Handle and send the appropriate message(s) to the sender/recipient
 764 |   // depending on the message events.
 765 |   handle_msg_event_cb: function(opdata, msg_event, context, message, err) {
 766 |     context = new Context(context);
 767 |     switch(msg_event) {
 768 |     case libOTR.messageEvent.OTRL_MSGEVENT_NONE:
 769 |       break;
 770 |     case libOTR.messageEvent.OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
 771 |       this.sendAlert(context, _("msgevent.encryption_required_part1", context.username));
 772 |       this.sendAlert(context, _("msgevent.encryption_required_part2"));
 773 |       break;
 774 |     case libOTR.messageEvent.OTRL_MSGEVENT_ENCRYPTION_ERROR:
 775 |       this.sendAlert(context, _("msgevent.encryption_error"));
 776 |       break;
 777 |     case libOTR.messageEvent.OTRL_MSGEVENT_CONNECTION_ENDED:
 778 |       this.sendAlert(context, _("msgevent.connection_ended", context.username));
 779 |       break;
 780 |     case libOTR.messageEvent.OTRL_MSGEVENT_SETUP_ERROR:
 781 |       this.sendAlert(context, _("msgevent.setup_error", context.username));
 782 |       break;
 783 |     case libOTR.messageEvent.OTRL_MSGEVENT_MSG_REFLECTED:
 784 |       this.sendAlert(context, _("msgevent.msg_reflected"));
 785 |       break;
 786 |     case libOTR.messageEvent.OTRL_MSGEVENT_MSG_RESENT:
 787 |       this.sendAlert(context, _("msgevent.msg_resent", context.username));
 788 |       break;
 789 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
 790 |       this.sendAlert(context, _("msgevent.rcvdmsg_not_private", context.username));
 791 |       break;
 792 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
 793 |       this.sendAlert(context, _("msgevent.rcvdmsg_unreadable", context.username));
 794 |       break;
 795 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_MALFORMED:
 796 |       this.sendAlert(context, _("msgevent.rcvdmsg_malformed", context.username));
 797 |       break;
 798 |     case libOTR.messageEvent.OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:
 799 |       this.log(_("msgevent.log_heartbeat_rcvd", context.username));
 800 |       break;
 801 |     case libOTR.messageEvent.OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:
 802 |       this.log(_("msgevent.log_heartbeat_sent", context.username));
 803 |       break;
 804 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
 805 |       this.sendAlert(context, _("msgevent.rcvdmsg_general_err"));
 806 |       break;
 807 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
 808 |       this.sendAlert(context, _("msgevent.rcvdmsg_unecrypted", context.username, message.isNull() ? "" : message.readString()));
 809 |       break;
 810 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
 811 |       this.sendAlert(context, _("msgevent.rcvdmsg_unrecognized", context.username));
 812 |       break;
 813 |     case libOTR.messageEvent.OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:
 814 |       this.log(_("msgevent.rcvdmsg_for_other_instance", context.username));
 815 |       break;
 816 |     default:
 817 |       this.log("msg event: " + msg_event);
 818 |     }
 819 |   },
 820 | 
 821 |   // Create an instance tag for the given accountname/protocol if desired.
 822 |   create_instag_cb: function(opdata, accountname, protocol) {
 823 |     this.generateInstanceTag(accountname.readString(), protocol.readString());
 824 |   },
 825 | 
 826 |   // When timer_control is called, turn off any existing periodic timer.
 827 |   // Additionally, if interval > 0, set a new periodic timer to go off every
 828 |   // interval seconds.
 829 |   timer_control_cb: function(opdata, interval) {
 830 |     if (this._poll_timer) {
 831 |       clearInterval(this._poll_timer);
 832 |       this._poll_timer = null;
 833 |     }
 834 |     if (interval > 0) {
 835 |       this._poll_timer = setInterval(function() {
 836 |         libOTR.otrl_message_poll(this.userstate, this.uiOps.address(), null);
 837 |       }.bind(this), interval * 1000);
 838 |     }
 839 |   },
 840 | 
 841 |   // uiOps
 842 | 
 843 |   initUiOps: function() {
 844 |     this.uiOps = new libOTR.OtrlMessageAppOps();
 845 | 
 846 |     let methods = [
 847 |       "policy",
 848 |       "create_privkey",
 849 |       "is_logged_in",
 850 |       "inject_message",
 851 |       "update_context_list",  // not implemented
 852 |       "new_fingerprint",
 853 |       "write_fingerprint",
 854 |       "gone_secure",
 855 |       "gone_insecure",
 856 |       "still_secure",
 857 |       "max_message_size",
 858 |       "account_name",  // not implemented
 859 |       "account_name_free",  // not implemented
 860 |       "received_symkey",
 861 |       "otr_error_message",
 862 |       "otr_error_message_free",
 863 |       "resent_msg_prefix",
 864 |       "resent_msg_prefix_free",
 865 |       "handle_smp_event",
 866 |       "handle_msg_event",
 867 |       "create_instag",
 868 |       "convert_msg",  // not implemented
 869 |       "convert_free",  // not implemented
 870 |       "timer_control"
 871 |     ];
 872 | 
 873 |     for (let i = 0; i < methods.length; i++) {
 874 |       let m = methods[i];
 875 |       if (!this[m + "_cb"]) {
 876 |         this.uiOps[m] = null;
 877 |         continue;
 878 |       }
 879 |       // keep a pointer to this in memory to avoid crashing
 880 |       this[m + "_cb"] = libOTR[m + "_cb_t"](this[m + "_cb"].bind(this));
 881 |       this.uiOps[m] = this[m + "_cb"];
 882 |     }
 883 |   },
 884 | 
 885 |   sendAlert: function(context, msg) {
 886 |     this.getUIConvFromContext(context).systemMessage(msg);
 887 |   },
 888 | 
 889 |   observe: function(aObject, aTopic, aMsg) {
 890 |     switch(aTopic) {
 891 |     case "sending-message":
 892 |       this.onSend(aObject);
 893 |       break;
 894 |     case "received-message":
 895 |       this.onReceive(aObject);
 896 |       break;
 897 |     case "new-ui-conversation":
 898 |       this.addConversation(aObject);
 899 |       break;
 900 |     }
 901 |   },
 902 | 
 903 |   addConversation: function(uiConv) {
 904 |     let conv = uiConv.target;
 905 |     if (conv.isChat)
 906 |       return;
 907 |     this._convos.set(conv.id, uiConv);
 908 |     uiConv.addObserver(this);
 909 |   },
 910 | 
 911 |   removeConversation: function(uiConv) {
 912 |     uiConv.removeObserver(this);
 913 |     this._convos.delete(uiConv.target.id);
 914 |     this.clearMsgs(uiConv.target.id);
 915 |   },
 916 | 
 917 |   sendSecret: function(context, secret, question) {
 918 |     let str = ctypes.char.array()(secret);
 919 |     let strlen = new ctypes.size_t(str.length - 1);
 920 |     libOTR.otrl_message_initiate_smp_q(
 921 |       this.userstate,
 922 |       this.uiOps.address(),
 923 |       null,
 924 |       context._context,
 925 |       question ? question : null,
 926 |       str,
 927 |       strlen
 928 |     );
 929 |   },
 930 | 
 931 |   sendResponse: function(context, response) {
 932 |     let str = ctypes.char.array()(response);
 933 |     let strlen = new ctypes.size_t(str.length - 1);
 934 |     libOTR.otrl_message_respond_smp(
 935 |       this.userstate,
 936 |       this.uiOps.address(),
 937 |       null,
 938 |       context._context,
 939 |       str,
 940 |       strlen
 941 |     );
 942 |   },
 943 | 
 944 |   abortSMP: function(context) {
 945 |     libOTR.otrl_message_abort_smp(
 946 |       this.userstate,
 947 |       this.uiOps.address(),
 948 |       null,
 949 |       context._context
 950 |     );
 951 |   },
 952 | 
 953 |   onSend: function(om) {
 954 |     if (om.cancelled)
 955 |       return;
 956 | 
 957 |     let conv = om.conversation;
 958 |     if (conv.isChat)
 959 |       return;
 960 | 
 961 |     // check for irc action messages
 962 |     if (om.action) {
 963 |       om.cancelled = true;
 964 |       let uiConv = this.getUIConvFromConv(conv);
 965 |       if (uiConv)
 966 |         uiConv.sendMsg("/me " + om.message);
 967 |       return;
 968 |     }
 969 | 
 970 |     let newMessage = new ctypes.char.ptr();
 971 | 
 972 |     this.log("pre sending: " + om.message);
 973 | 
 974 |     let err = libOTR.otrl_message_sending(
 975 |       this.userstate,
 976 |       this.uiOps.address(),
 977 |       null,
 978 |       conv.account.normalizedName,
 979 |       conv.account.protocol.normalizedName,
 980 |       conv.normalizedName,
 981 |       libOTR.instag.OTRL_INSTAG_BEST,
 982 |       om.message,
 983 |       null,
 984 |       newMessage.address(),
 985 |       libOTR.fragPolicy.OTRL_FRAGMENT_SEND_ALL_BUT_LAST,
 986 |       null,
 987 |       null,
 988 |       null
 989 |     );
 990 | 
 991 |     let msg = om.message;
 992 | 
 993 |     if (err) {
 994 |       om.cancelled = true;
 995 |       Cu.reportError(new Error("Failed to send message. Returned code: " + err));
 996 |     } else if (!newMessage.isNull()) {
 997 |       msg = newMessage.readString();
 998 |       // https://bugs.otr.im/issues/52
 999 |       if (!msg) {
1000 |         om.cancelled = true;
1001 |       }
1002 |     }
1003 | 
1004 |     if (!om.cancelled) {
1005 |       // If contact is offline, don't append whitespace tags.
1006 |       // See: https://bugs.otr.im/issues/102
1007 |       if (isOnline(conv) === 0 ||
1008 |           // Twitter trims tweets.
1009 |           conv.account.protocol.normalizedName === "twitter") {
1010 |         let ind = msg.indexOf(libOTR.OTRL_MESSAGE_TAG_BASE);
1011 |         if (ind > -1) {
1012 |           msg = msg.substring(0, ind);
1013 |           let context = this.getContext(conv);
1014 |           context._context.contents.otr_offer = libOTR.otr_offer.OFFER_NOT;
1015 |         }
1016 |       }
1017 | 
1018 |       this.bufferMsg(conv.id, om.message, msg);
1019 |       om.message = msg;
1020 |     }
1021 | 
1022 |     this.log("post sending (" + !om.cancelled + "): " + om.message);
1023 |     libOTR.otrl_message_free(newMessage);
1024 |   },
1025 | 
1026 |   onReceive: function(im) {
1027 |     if (im.cancelled || im.system)
1028 |       return;
1029 | 
1030 |     let conv = im.conversation;
1031 |     if (conv.isChat)
1032 |       return;
1033 | 
1034 |     if (im.outgoing) {
1035 |       this.log("outgoing message to display: " + im.displayMessage);
1036 |       this.pluckMsg(im);
1037 |       return;
1038 |     }
1039 | 
1040 |     let newMessage = new ctypes.char.ptr();
1041 |     let tlvs = new libOTR.OtrlTLV.ptr();
1042 | 
1043 |     this.log("pre receiving: " + im.displayMessage);
1044 | 
1045 |     let res = libOTR.otrl_message_receiving(
1046 |       this.userstate,
1047 |       this.uiOps.address(),
1048 |       null,
1049 |       conv.account.normalizedName,
1050 |       conv.account.protocol.normalizedName,
1051 |       conv.normalizedName,
1052 |       im.displayMessage,
1053 |       newMessage.address(),
1054 |       tlvs.address(),
1055 |       null,
1056 |       null,
1057 |       null
1058 |     );
1059 | 
1060 |     if (!newMessage.isNull()) {
1061 |       im.displayMessage = newMessage.readString();
1062 |     }
1063 | 
1064 |     // search tlvs for a disconnect msg
1065 |     // https://bugs.otr.im/issues/54
1066 |     let tlv = libOTR.otrl_tlv_find(tlvs, libOTR.tlvs.OTRL_TLV_DISCONNECTED);
1067 |     if (!tlv.isNull()) {
1068 |       let context = this.getContext(conv);
1069 |       this.notifyObservers(context, "otr:disconnected");
1070 |       this.sendAlert(context, _("tlv.disconnected", conv.normalizedName));
1071 |     }
1072 | 
1073 |     if (res) {
1074 |       this.log("error (" + res + ") ignoring: " + im.displayMessage);
1075 |       im.cancelled = true;  // ignore
1076 |     } else {
1077 |       this.log("post receiving: " + im.displayMessage);
1078 |     }
1079 | 
1080 |     libOTR.otrl_tlv_free(tlvs);
1081 |     libOTR.otrl_message_free(newMessage);
1082 |   },
1083 | 
1084 |   // observer interface
1085 | 
1086 |   addObserver: function(aObserver) {
1087 |     if (this._observers.indexOf(aObserver) == -1)
1088 |       this._observers.push(aObserver);
1089 |   },
1090 | 
1091 |   removeObserver: function(aObserver) {
1092 |     this._observers = this._observers.filter(o => o !== aObserver);
1093 |   },
1094 | 
1095 |   notifyObservers: function(aSubject, aTopic, aData) {
1096 |     for (let observer of this._observers) {
1097 |       observer.observe(aSubject, aTopic, aData);
1098 |     }
1099 |   },
1100 | 
1101 |   // buffer messages
1102 | 
1103 |   clearMsgs: function(convId) {
1104 |     this._buffer = this._buffer.filter((msg) => msg.convId !== convId);
1105 |   },
1106 | 
1107 |   bufferMsg: function(convId, display, sent) {
1108 |     this._buffer.push({
1109 |       convId: convId,
1110 |       display: display,
1111 |       sent: sent,
1112 |       time: Date.now()
1113 |     });
1114 |   },
1115 | 
1116 |   pluckMsg: function(im) {
1117 |     let buf = this._buffer;
1118 |     for (let i = 0; i < buf.length; i++) {
1119 |       let b = buf[i];
1120 |       if (b.convId === im.conversation.id && b.sent === im.displayMessage) {
1121 |         im.displayMessage = b.display;
1122 |         buf.splice(i, 1);
1123 |         this.log("displaying: " + b.display);
1124 |         return;
1125 |       }
1126 |     }
1127 |     // don't display if it wasn't buffered
1128 |     im.cancelled = true;
1129 |     this.log("not displaying: " + im.displayMessage);
1130 |   }
1131 | 
1132 | };
1133 | 
1134 | 
1135 | // exports
1136 | 
1137 | if (isNode) {
1138 |   module.exports = { otr: otr };
1139 | } else if (isJpm) {
1140 |   exports.otr = otr;
1141 | } else {
1142 |   this.EXPORTED_SYMBOLS = ["otr"];
1143 | }
1144 | 


--------------------------------------------------------------------------------
/chrome/content/prefs.js:
--------------------------------------------------------------------------------
  1 | var Cu = Components.utils;
  2 | 
  3 | Cu.import("resource:///modules/imServices.jsm");
  4 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
  5 | Cu.import("chrome://otr/content/otr.js");
  6 | Cu.import("chrome://otr/content/helpers.js");
  7 | Cu.import("chrome://otr/content/coniks/coniks.js");
  8 | 
  9 | var fingerDialog = "chrome://otr/content/finger.xul";
 10 | var privDialog = "chrome://otr/content/priv.xul";
 11 | 
 12 | var account, protocol;
 13 | if (window && window.arguments) {
 14 |   let args = window.arguments[0].wrappedJSObject;
 15 |   ({account, protocol} = args);
 16 | }
 17 | 
 18 | var otrPref = {
 19 | 
 20 |   onload: function() {
 21 |     otrPref.otrTabInit();
 22 |     if (coniks.isEnabled)
 23 |       otrPref.coniksTabInit();
 24 |   },
 25 | 
 26 |   tabInit: function(listElement, changeDisplayElements, func) {
 27 |     let accountList = document.getElementById(listElement);
 28 |     for (let acc of helpers.getAccounts()) {
 29 |       let menuItem = accountList.appendItem(
 30 |         `${acc.normalizedName} (${otr.protocolName(acc.protocol.normalizedName)})`,
 31 |         acc.id
 32 |       );
 33 |       if (acc.normalizedName === account &&
 34 |           acc.protocol.normalizedName === protocol) {
 35 |         accountList.selectedItem = menuItem;
 36 |         func(acc);
 37 |       }
 38 |     }
 39 |     if (accountList.itemCount) {
 40 |       if (!accountList.selectedItem) {
 41 |         let menuItem = accountList.getItemAtIndex(0);
 42 |         accountList.selectedItem = menuItem;
 43 |         let acc = Services.accounts.getAccountById(menuItem.getAttribute("value"));
 44 |         func(acc);
 45 |       }
 46 |       Object.keys(changeDisplayElements).forEach(function(key) {
 47 |         document.getElementById(key).hidden = changeDisplayElements[key];
 48 |       });
 49 |     }
 50 |   },
 51 | 
 52 |   otrTabInit: function() {
 53 |     let changeDisplayElements = {
 54 |       emptyal: true,
 55 |       myKeys: false,
 56 |     };
 57 |     this.tabInit("accountlist", changeDisplayElements, this.swapFinger);
 58 |   },
 59 | 
 60 |   coniksTabInit: function() {
 61 |     document.getElementById("coniksTab").hidden = false;
 62 |     let changeDisplayElements = {
 63 |       coniksuser: false,
 64 |     };
 65 |     this.tabInit("coniksaccountlist", changeDisplayElements, this.displayAccountPolicy);
 66 |   },
 67 | 
 68 |   swapFinger: function(acc) {
 69 |     let display = otr.privateKeyFingerprint(
 70 |       acc.normalizedName,
 71 |       acc.protocol.normalizedName
 72 |     ) || "";
 73 |     document.getElementById("fingerprint").value = display;
 74 |     document.getElementById("display").hidden = !display;
 75 |     document.getElementById("generate").hidden = !!display;
 76 |   },
 77 | 
 78 |   displayFinger: function() {
 79 |     let accountList = document.getElementById("accountlist");
 80 |     let acc = Services.accounts.getAccountById(accountList.selectedItem.value);
 81 |     this.swapFinger(acc);
 82 |   },
 83 | 
 84 |   fingwin: null,
 85 |   showFingers: function() {
 86 |     if (this.fingwin)
 87 |       return this.fingwin.focus();
 88 |     this.fingwin = document.documentElement.openWindow(
 89 |       "otr-pref-fingerprints", fingerDialog, "", null
 90 |     );
 91 |     this.fingwin.addEventListener("close", function() {
 92 |       otrPref.fingwin = null;
 93 |     });
 94 |   },
 95 | 
 96 |   generate: function() {
 97 |     let accountList = document.getElementById("accountlist");
 98 |     let acc = Services.accounts.getAccountById(accountList.selectedItem.value);
 99 |     let args = {
100 |       account: acc.normalizedName,
101 |       protocol: acc.protocol.normalizedName,
102 |     };
103 |     args.wrappedJSObject = args;
104 |     let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
105 |     Services.ww.openWindow(null, privDialog, "", features, args);
106 |     this.swapFinger(acc);
107 |   },
108 | 
109 |   // CONIKS preferences
110 | 
111 |   displayAccountPolicy: function(acc) {
112 |     let policy = coniks.getAccountPolicy(acc);
113 |     document.getElementById("privateLookups").checked = policy.privateLookups;
114 |     document.getElementById("signedKeyChange").checked = policy.signedKeyChange;
115 |   },
116 | 
117 |   displayPolicies: function() {
118 |     let accountList = document.getElementById("coniksaccountlist");
119 |     let acc = Services.accounts.getAccountById(accountList.selectedItem.value);
120 |     this.displayAccountPolicy(acc);
121 |   },
122 | 
123 |   updateAccountPolicy: function() {
124 |     let accountList = document.getElementById("coniksaccountlist");
125 |     let acc = Services.accounts.getAccountById(accountList.selectedItem.value);
126 |     let policy = {
127 |       privateLookups: !!document.getElementById("privateLookups").checked,
128 |       signedKeyChange: !!document.getElementById("signedKeyChange").checked
129 |     };
130 |     coniks.setAccountPolicy(acc, policy)
131 |     .catch(function(err) { Cu.reportError(err); });
132 |   },
133 | 
134 | };
135 | 


--------------------------------------------------------------------------------
/chrome/content/prefs.xul:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" ?>
  2 | <?xml-stylesheet href="chrome://global/skin/" type="text/css" ?>
  3 | 
  4 | <!DOCTYPE window SYSTEM "chrome://otr/locale/prefs.dtd">
  5 | 
  6 | <prefwindow id="otr-prefwindow"
  7 |             title="&prefs.otrPreferences;"
  8 |             xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
  9 |             onload="otrPref.onload()">
 10 | 
 11 |   <prefpane id="otr-pane">
 12 | 
 13 |     <preferences id="otr-preferences">
 14 |       <preference id="pref_require_encryption" name="extensions.otr.requireEncryption" type="bool" />
 15 |       <preference id="pref_verify_nudge" name="extensions.otr.verifyNudge" type="bool" />
 16 | 
 17 |       <preference id="pref_coniks_serverAddress" name="extensions.otr.coniks.serverAddress" type="string" />
 18 |       <preference id="pref_coniks_serverPort" name="extensions.otr.coniks.serverPort" type="string" />
 19 |     </preferences>
 20 | 
 21 |     <script type="application/javascript" src="chrome://otr/content/prefs.js" />
 22 | 
 23 |     <tabbox id="otrPrefs" flex="1">
 24 |       <tabs id="tabsElement">
 25 |         <tab id="otrTab" label="&prefs.otrLabel;"/>
 26 |         <tab id="coniksTab" label="&prefs.coniksLabel;" hidden="true"/>
 27 |       </tabs>
 28 | 
 29 |       <tabpanels flex="1">
 30 |         <!-- OTR -->
 31 |         <tabpanel id="otrTab" orient="vertical">
 32 |           <groupbox>
 33 |             <caption label="&prefs.otrKeys;" />
 34 |             <vbox id="myKeys" hidden="true" width="460">
 35 |               <hbox align="baseline">
 36 |                 <label control="accountlist" value="&prefs.keyForAccount;" />
 37 |                 <menulist id="accountlist" oncommand="otrPref.displayFinger();" flex="1"></menulist>
 38 |               </hbox>
 39 |               <hbox align="baseline">
 40 |                 <vbox flex="1">
 41 |                   <hbox id="display" hidden="true">
 42 |                     <label control="fingerprint" value="&prefs.fingerprint;" />
 43 |                     <textbox id="fingerprint" class="plain" size="56" flex="1" align="right" readonly="true" />
 44 |                   </hbox>
 45 |                   <hbox id="generate" hidden="true" flex="1">
 46 |                     <button label="&prefs.generate;" oncommand="otrPref.generate();" flex="1" />
 47 |                   </hbox>
 48 |                 </vbox>
 49 |               </hbox>
 50 |             </vbox>
 51 |             <textbox id="emptyal" class="plain" flex="1" readonly="true"
 52 |               value="&prefs.emptyAccountList;" />
 53 |           </groupbox>
 54 | 
 55 |           <groupbox>
 56 |             <caption label="&prefs.knownFingers;" />
 57 |             <description>&prefs.introFingers;</description>
 58 |             <hbox>
 59 |               <spacer flex="1" />
 60 |               <button label="&prefs.showFingers;" oncommand="otrPref.showFingers();" />
 61 |             </hbox>
 62 |           </groupbox>
 63 | 
 64 |           <groupbox>
 65 |             <caption label="&prefs.otrSettings;" />
 66 |             <description>&prefs.introSettings;</description>
 67 |             <checkbox id="requireencryption" label="&prefs.requireEncryption;" preference="pref_require_encryption" />
 68 |             <checkbox id="verifynudge" label="&prefs.verifyNudge;" preference="pref_verify_nudge" />
 69 |           </groupbox>
 70 |         </tabpanel>
 71 | 
 72 |         <!-- CONIKS -->
 73 |         <tabpanel id="coniksTab" orient="vertical">
 74 |           <groupbox>
 75 |             <caption label="&prefs.coniksConnection;" />
 76 |             <hbox align="baseline">
 77 |               <label value="&prefs.coniksServerAddress;" control="name"/>
 78 |               <textbox preference="pref_coniks_serverAddress" id="coniksServerAddress" />
 79 |               <label value="&prefs.coniksServerPort;" control="name"/>
 80 |               <textbox preference="pref_coniks_serverPort" id="coniksServerPort" />
 81 |             </hbox>
 82 |           </groupbox>
 83 | 
 84 |           <groupbox id="coniksuser" hidden="true">
 85 |             <caption label="&prefs.coniksAccountPolicy;" />
 86 |             <vbox id="user-policies" width="460">
 87 |               <hbox align="baseline">
 88 |                 <label control="coniksaccountlist" value="&prefs.coniksPoliciesForAccount;" />
 89 |                 <menulist id="coniksaccountlist" oncommand="otrPref.displayPolicies();" flex="1"></menulist>
 90 |               </hbox>
 91 |               <hbox align="baseline">
 92 |                 <vbox flex="1">
 93 |                   <checkbox id="privateLookups" label="&prefs.coniksPrivateLookups;"
 94 |                             oncommand="otrPref.updateAccountPolicy();" />
 95 |                   <checkbox id="signedKeyChange" label="&prefs.coniksSignedKeyChange;"
 96 |                             oncommand="otrPref.updateAccountPolicy();" />
 97 |                 </vbox>
 98 |               </hbox>
 99 |             </vbox>
100 |           </groupbox>
101 |         </tabpanel>
102 | 
103 |       </tabpanels>
104 | 
105 |     </tabbox>
106 | 
107 |   </prefpane>
108 | 
109 | </prefwindow>


--------------------------------------------------------------------------------
/chrome/content/priv.js:
--------------------------------------------------------------------------------
 1 | var Cu = Components.utils;
 2 | 
 3 | Cu.import("resource:///modules/imServices.jsm");
 4 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
 5 | Cu.import("chrome://otr/content/otr.js");
 6 | 
 7 | XPCOMUtils.defineLazyGetter(this, "_", () =>
 8 |   l10nHelper("chrome://otr/locale/priv.properties")
 9 | );
10 | 
11 | var otrPriv = {
12 | 
13 |   onload: function() {
14 |     let args = window.arguments[0].wrappedJSObject;
15 |     let priv = document.getElementById("priv");
16 |     priv.textContent = _("priv.account", args.account, otr.protocolName(args.protocol));
17 |     otr.generatePrivateKey(args.account, args.protocol).then(function() {
18 |       document.documentElement.getButton("accept").disabled = false;
19 |       document.documentElement.acceptDialog();
20 |     }).catch(function(err) {
21 |       document.documentElement.getButton("accept").disabled = false;
22 |       priv.textContent = _("priv.failed", String(err));
23 |     });
24 |   },
25 | 
26 | };
27 | 


--------------------------------------------------------------------------------
/chrome/content/priv.xul:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <?xml-stylesheet href="chrome://global/skin/" type="text/css" ?>
 3 | 
 4 | <!DOCTYPE window SYSTEM "chrome://otr/locale/priv.dtd">
 5 | 
 6 | <dialog
 7 |   xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
 8 |   id="otrPrivDialog"
 9 |   windowtype="OTR:Priv"
10 |   title="&privDialog.title;"
11 |   buttons="accept"
12 |   buttonlabelaccept="&privDialog.done;"
13 |   onload="otrPriv.onload()"
14 |   buttondisabledaccept="true">
15 | 
16 |   <script type="application/javascript" src="chrome://otr/content/priv.js" />
17 |   <description id="priv" style="width: 300px; white-space: pre-wrap;"></description>
18 | 
19 | </dialog>


--------------------------------------------------------------------------------
/chrome/content/ui.js:
--------------------------------------------------------------------------------
  1 | this.EXPORTED_SYMBOLS = ["ui"];
  2 | 
  3 | var { interfaces: Ci, utils: Cu, classes: Cc } = Components;
  4 | 
  5 | Cu.import("resource:///modules/imServices.jsm");
  6 | Cu.import("resource:///modules/imXPCOMUtils.jsm");
  7 | Cu.import("resource:///modules/imWindows.jsm");
  8 | Cu.import("chrome://otr/content/otr.js");
  9 | Cu.import("chrome://otr/content/coniks/coniks.js");
 10 | 
 11 | var privDialog = "chrome://otr/content/priv.xul";
 12 | var authDialog = "chrome://otr/content/auth.xul";
 13 | var prefsDialog = "chrome://otr/content/prefs.xul";
 14 | var addFingerDialog = "chrome://otr/content/addfinger.xul";
 15 | 
 16 | XPCOMUtils.defineLazyGetter(this, "_", () =>
 17 |   l10nHelper("chrome://otr/locale/ui.properties")
 18 | );
 19 | 
 20 | var authVerify = "otr-auth-unverified";
 21 | 
 22 | var authLabelMap = new Map([
 23 |   ["otr:auth-error", _("auth.error")],
 24 |   ["otr:auth-success", _("auth.success")],
 25 |   ["otr:auth-successThem", _("auth.successThem")],
 26 |   ["otr:auth-fail", _("auth.fail")],
 27 |   ["otr:auth-waiting", _("auth.waiting")],
 28 | ]);
 29 | 
 30 | var trustMap = new Map([
 31 |   [otr.trustState.TRUST_NOT_PRIVATE, {
 32 |     startLabel: _("start.label"),
 33 |     authLabel: _("auth.label"),
 34 |     disableStart: false,
 35 |     disableEnd: true,
 36 |     disableAuth: true,
 37 |     class: "not_private",
 38 |   }],
 39 |   [otr.trustState.TRUST_UNVERIFIED, {
 40 |     startLabel: _("refresh.label"),
 41 |     authLabel: _("auth.label"),
 42 |     disableStart: false,
 43 |     disableEnd: false,
 44 |     disableAuth: false,
 45 |     class: "unverified",
 46 |   }],
 47 |   [otr.trustState.TRUST_PRIVATE, {
 48 |     startLabel: _("refresh.label"),
 49 |     authLabel: _("reauth.label"),
 50 |     disableStart: false,
 51 |     disableEnd: false,
 52 |     disableAuth: false,
 53 |     class: "private",
 54 |   }],
 55 |   [otr.trustState.TRUST_FINISHED, {
 56 |     startLabel: _("start.label"),
 57 |     authLabel: _("auth.label"),
 58 |     disableStart: false,
 59 |     disableEnd: false,
 60 |     disableAuth: true,
 61 |     class: "finished",
 62 |   }],
 63 | ]);
 64 | 
 65 | var windowRefs = new Map();
 66 | 
 67 | var ui = {
 68 | 
 69 |   debug: false,
 70 |   log: function log(msg) {
 71 |     if (!ui.debug)
 72 |       return;
 73 |     let csl = Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService);
 74 |     csl.logStringMessage(msg);
 75 |   },
 76 | 
 77 |   prefs: null,
 78 |   setPrefs: function() {
 79 |     let branch = "extensions.otr.";
 80 |     let prefs = {
 81 |       requireEncryption: true,
 82 |       verifyNudge: true
 83 |     };
 84 |     let defaults = Services.prefs.getDefaultBranch(branch);
 85 |     Object.keys(prefs).forEach(function(key) {
 86 |       defaults.setBoolPref(key, prefs[key]);
 87 |     });
 88 |     ui.prefs = Services.prefs.getBranch(branch);
 89 |   },
 90 | 
 91 |   addMenuObserver: function() {
 92 |     let iter = Services.ww.getWindowEnumerator();
 93 |     while (iter.hasMoreElements())
 94 |       ui.addMenus(iter.getNext());
 95 |     Services.obs.addObserver(ui, "domwindowopened", false);
 96 |   },
 97 | 
 98 |   removeMenuObserver: function() {
 99 |     let iter = Services.ww.getWindowEnumerator();
100 |     while (iter.hasMoreElements())
101 |       ui.removeMenus(iter.getNext());
102 |     Services.obs.removeObserver(ui, "domwindowopened");
103 |   },
104 | 
105 |   addMenus: function(win) {
106 |     let doc = win.document;
107 |     // Account for unready windows
108 |     if (doc.readyState !== "complete") {
109 |       let listen = function() {
110 |         win.removeEventListener("load", listen);
111 |         ui.addMenus(win);
112 |       };
113 |       win.addEventListener("load", listen);
114 |       return;
115 |     }
116 |     ui.addPrefMenu(doc);
117 |     ui.addBuddyContextMenu(doc);
118 |   },
119 | 
120 |   removeMenus: function(win) {
121 |     let doc = win.document;
122 |     ui.removePrefMenu(doc);
123 |     ui.removeBuddyContextMenu(doc);
124 |   },
125 | 
126 |   addPrefMenu: function(doc) {
127 |     let toolsMenuPopup = doc.getElementById("toolsMenuPopup");
128 |     if (!toolsMenuPopup)
129 |       return;  // Not the tools menu
130 |     let sep = doc.createElement("menuseparator");
131 |     sep.setAttribute("id", "otrsep");
132 |     let menuitem = doc.createElement("menuitem");
133 |     menuitem.setAttribute("label", _("prefs.label"));
134 |     menuitem.setAttribute("id", "otrpref");
135 |     menuitem.addEventListener("command", function(e) {
136 |       e.preventDefault();
137 |       let features = "chrome,centerscreen,dialog=no,resizable=no,minimizable=no";
138 |       Services.ww.openWindow(null, prefsDialog, "otrPrefs", features, null);
139 |     });
140 |     toolsMenuPopup.appendChild(sep);
141 |     toolsMenuPopup.appendChild(menuitem);
142 |   },
143 | 
144 |   removePrefMenu: function(doc) {
145 |     let s = doc.getElementById("otrsep");
146 |     if (s)
147 |       s.parentNode.removeChild(s);
148 |     let p = doc.getElementById("otrpref");
149 |     if (p)
150 |       p.parentNode.removeChild(p);
151 |   },
152 | 
153 |   addBuddyContextMenu: function(doc) {
154 |     let buddyContextMenu = doc.getElementById("buddyListContextMenu");
155 |     if (!buddyContextMenu)
156 |       return;  // Not the buddy list context menu
157 |     let sep = doc.createElement("menuseparator");
158 |     sep.setAttribute("id", "otrsep");
159 |     let menuitem = doc.createElement("menuitem");
160 |     menuitem.setAttribute("label", _("buddycontextmenu.label"));
161 |     menuitem.setAttribute("id", "otrcont");
162 |     menuitem.addEventListener("command", function() {
163 |       let target = buddyContextMenu.triggerNode;
164 |       if (target.localName == "contact") {
165 |         let contact = target.contact;
166 |         let args = ui.contactWrapper(contact);
167 |         args.wrappedJSObject = args;
168 |         let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
169 |         Services.ww.openWindow(null, addFingerDialog, "", features, args);
170 |       }
171 |     });
172 |     buddyContextMenu.addEventListener("popupshowing", function(e) {
173 |       let target = e.target.triggerNode;
174 |       if (target.localName == "contact") {
175 |         menuitem.hidden = false;
176 |         sep.hidden = false;
177 |       } else {
178 |         menuitem.hidden = true;
179 |         sep.hidden = true;
180 |       }
181 |     }, false);
182 |     buddyContextMenu.appendChild(sep);
183 |     buddyContextMenu.appendChild(menuitem);
184 |   },
185 | 
186 |   removeBuddyContextMenu: function(doc) {
187 |     let s = doc.getElementById("otrsep");
188 |     if (s)
189 |       s.parentNode.removeChild(s);
190 |     let p = doc.getElementById("otrcont");
191 |     if (p)
192 |       p.parentNode.removeChild(p);
193 |   },
194 | 
195 |   init: function() {
196 |     ui.setPrefs();
197 |     otr.init({
198 |       requireEncryption: ui.prefs.getBoolPref("requireEncryption"),
199 |       verifyNudge: ui.prefs.getBoolPref("verifyNudge")
200 |     });
201 |     otr.addObserver(ui);
202 |     otr.loadFiles().then(function() {
203 |       Services.obs.addObserver(otr, "new-ui-conversation", false);
204 |       // Disabled until #76 is resolved.
205 |       // Services.obs.addObserver(ui, "contact-added", false);
206 |       Services.obs.addObserver(ui, "account-added", false);
207 |       Services.obs.addObserver(ui, "conversation-loaded", false);
208 |       Services.obs.addObserver(ui, "conversation-closed", false);
209 |       Services.obs.addObserver(ui, "prpl-quit", false);
210 |       ui.prefs.addObserver("", ui, false);
211 |       Conversations._conversations.forEach(ui.initConv);
212 |       ui.addMenuObserver();
213 |       return coniks.init();
214 |     }).catch(function(err) { throw err; });
215 |   },
216 | 
217 |   disconnect: function(aConv) {
218 |     if (aConv)
219 |       return otr.disconnect(aConv, true);
220 |     let conversations = Services.conversations.getConversations();
221 |     while (conversations.hasMoreElements()) {
222 |       let conv = conversations.getNext();
223 |       if (conv.isChat)
224 |         return;
225 |       otr.disconnect(conv, true);
226 |     }
227 |   },
228 | 
229 |   changePref: function(aMsg) {
230 |     switch(aMsg) {
231 |     case "requireEncryption":
232 |       otr.setPolicy(ui.prefs.getBoolPref("requireEncryption"));
233 |       break;
234 |     case "verifyNudge":
235 |       otr.verifyNudge = ui.prefs.getBoolPref("verifyNudge");
236 |       break;
237 |     default:
238 |       ui.log(aMsg);
239 |     }
240 |   },
241 | 
242 |   openAuth: function(window, target, name, mode, uiConv, aObject) {
243 |     target.disabled = true;
244 |     let win = window.openDialog(
245 |       authDialog,
246 |       "auth=" + name,
247 |       "centerscreen,resizable=no,minimizable=no",
248 |       mode,
249 |       uiConv,
250 |       aObject
251 |     );
252 |     windowRefs.set(name, win);
253 |     win.addEventListener("beforeunload", function() {
254 |       target.disabled = false;
255 |       windowRefs.delete(name);
256 |     });
257 |   },
258 | 
259 |   closeAuth: function(context) {
260 |     let win = windowRefs.get(context.username);
261 |     if (win)
262 |       win.close();
263 |   },
264 | 
265 |   addButton: function(binding) {
266 |     let uiConv = binding._conv;
267 |     let conv = uiConv.target;
268 |     if (conv.isChat)
269 |       return;
270 | 
271 |     let cti = binding.getElt("conv-top-info");
272 |     let doc = cti.ownerDocument;
273 |     let window = doc.defaultView;
274 | 
275 |     let otrStart = doc.createElement("menuitem");
276 |     otrStart.classList.add("otr-start");
277 |     otrStart.addEventListener("click", function(e) {
278 |       e.preventDefault();
279 |       if (!e.target.disabled) {
280 |         let context = otr.getContext(conv);
281 |         uiConv.systemMessage(_("alert." + (
282 |           context.msgstate === otr.messageState.OTRL_MSGSTATE_ENCRYPTED ?
283 |           "refresh" : "start"
284 |         ), conv.normalizedName));
285 |         otr.sendQueryMsg(conv);
286 |       }
287 |     });
288 | 
289 |     let otrEnd = doc.createElement("menuitem");
290 |     otrEnd.setAttribute("label", _("end.label"));
291 |     otrEnd.classList.add("otr-end");
292 |     otrEnd.addEventListener("click", function(e) {
293 |       e.preventDefault();
294 |       if (!e.target.disabled) {
295 |         otr.disconnect(conv, false);
296 |         uiConv.systemMessage(_("alert.gone_insecure", conv.normalizedName));
297 |       }
298 |     });
299 | 
300 |     let otrAuth = doc.createElement("menuitem");
301 |     otrAuth.classList.add("otr-auth");
302 |     otrAuth.addEventListener("click", function(e) {
303 |       e.preventDefault();
304 |       let target = e.target;
305 |       if (!target.disabled) {
306 |         ui.openAuth(window, target, conv.normalizedName, "start", uiConv);
307 |       }
308 |     });
309 | 
310 |     let otrPrefs = doc.createElement("menuitem");
311 |     otrPrefs.classList.add("otr-prefs");
312 |     otrPrefs.setAttribute("label", _("prefs.label"));
313 |     otrPrefs.addEventListener("click", function(e) {
314 |       e.preventDefault();
315 |       let features = "chrome,centerscreen,dialog=no,resizable=no,minimizable=no";
316 |       let args = {
317 |         account: conv.account.normalizedName,
318 |         protocol: conv.account.protocol.normalizedName,
319 |       };
320 |       args.wrappedJSObject = args;
321 |       Services.ww.openWindow(null, prefsDialog, "otrPrefs", features, args);
322 |     });
323 | 
324 |     let otrMenu = doc.createElement("menupopup");
325 |     otrMenu.appendChild(otrStart);
326 |     otrMenu.appendChild(otrEnd);
327 |     otrMenu.appendChild(otrAuth);
328 |     otrMenu.appendChild(doc.createElement("menuseparator"));
329 |     otrMenu.appendChild(otrPrefs);
330 | 
331 |     let otrButton = doc.createElement("toolbarbutton");
332 |     otrButton.classList.add("otr-button");
333 |     otrButton.addEventListener("command", function(e) {
334 |       e.preventDefault();
335 |       otrMenu.openPopup(otrButton, "after_start");
336 |     });
337 | 
338 |     otrButton.appendChild(otrMenu);
339 |     cti.appendChild(otrButton);
340 | 
341 |     // get otr msg state
342 |     let context = otr.getContext(conv);
343 |     ui.setMsgState(context, otrButton, otrStart, otrEnd, otrAuth);
344 | 
345 |     let trust = ui.getTrustSettings(context);
346 |     uiConv.systemMessage(_("state." + trust.class, context.username));
347 |   },
348 | 
349 |   getConvElements: function(context) {
350 |     let cti, box, uiConv = otr.getUIConvFromContext(context);
351 |     if (Conversations._conversations.some(function(binding) {
352 |       if (binding._conv.id !== uiConv.id)
353 |         return false;
354 |       cti = binding.getElt("conv-top-info");
355 |       box = binding.getElt("convNotificationBox");
356 |       return true;
357 |     }))
358 |       return { cti: cti, box: box, uiConv: uiConv };
359 |     else
360 |       return null;
361 |   },
362 | 
363 |   updateButton: function(context) {
364 |     let els = ui.getConvElements(context);
365 |     if (!els) return;
366 |     let { cti, box, uiConv } = els;
367 | 
368 |     let otrButton = cti.querySelector(".otr-button");
369 |     let otrStart = cti.querySelector(".otr-start");
370 |     let otrEnd = cti.querySelector(".otr-end");
371 |     let otrAuth = cti.querySelector(".otr-auth");
372 |     ui.setMsgState(context, otrButton, otrStart, otrEnd, otrAuth);
373 |   },
374 | 
375 |   alertTrust: function(context) {
376 |     let uiConv = otr.getUIConvFromContext(context);
377 |     let trust = ui.getTrustSettings(context);
378 |     uiConv.systemMessage(_("afterauth." + trust.class, context.username));
379 |   },
380 | 
381 |   getTrustSettings: function(context) {
382 |     return trustMap.get(otr.trust(context));
383 |   },
384 | 
385 |   // set msg state on toolbar button
386 |   setMsgState: function(context, otrButton, otrStart, otrEnd, otrAuth) {
387 |     let trust = ui.getTrustSettings(context);
388 |     otrButton.setAttribute("tooltiptext", _("state." + trust.class, context.username));
389 |     otrButton.className = "otr-button" + " otr-" + trust.class;
390 |     otrStart.setAttribute("label", trust.startLabel);
391 |     otrStart.setAttribute("disabled", trust.disableStart);
392 |     otrEnd.setAttribute("disabled", trust.disableEnd);
393 |     otrAuth.setAttribute("label", trust.authLabel);
394 |     otrAuth.setAttribute("disabled", trust.disableAuth);
395 |   },
396 | 
397 |   askAuth: function(aObject) {
398 |     let els = ui.getConvElements(aObject.context);
399 |     if (!els) return;
400 |     let { cti, box, uiConv } = els;
401 | 
402 |     let window = cti.ownerDocument.defaultView;
403 |     let otrAuth = cti.querySelector(".otr-auth");
404 |     let name = uiConv.target.normalizedName;
405 |     ui.openAuth(window, otrAuth, name, "ask", uiConv, aObject);
406 |   },
407 | 
408 |   closeUnverified: function(context) {
409 |     let els = ui.getConvElements(context);
410 |     if (!els) return;
411 |     let { cti, box, uiConv } = els;
412 | 
413 |     let notification = box.getNotificationWithValue(authVerify);
414 |     if (notification)
415 |       notification.close();
416 |   },
417 | 
418 |   notifyUnverified: function(context, seen) {
419 |     let els = ui.getConvElements(context);
420 |     if (!els) return;
421 |     let { cti, box, uiConv } = els;
422 | 
423 |     if (box.getNotificationWithValue(authVerify))
424 |       return;
425 | 
426 |     let window = cti.ownerDocument.defaultView;
427 |     let otrAuth = cti.querySelector(".otr-auth");
428 | 
429 |     let msg = _("finger." + seen, context.username);
430 |     let buttons = [{
431 |       label: _("finger.verify"),
432 |       accessKey: _("verify.accessKey"),
433 |       callback: function() {
434 |         let name = uiConv.target.normalizedName;
435 |         ui.openAuth(window, otrAuth, name, "start", uiConv);
436 |         // prevent closing of notification bar when the button is hit
437 |         return true;
438 |       }
439 |     }];
440 | 
441 |     let priority = box.PRIORITY_WARNING_MEDIUM;
442 |     box.appendNotification(msg, authVerify, null, priority, buttons, null);
443 |   },
444 | 
445 |   closeVerification: function(context) {
446 |     let els = ui.getConvElements(context);
447 |     if (!els) return;
448 |     let { cti, box, uiConv } = els;
449 | 
450 |     authLabelMap.forEach(function(_, key) {
451 |       var prevNotification = box.getNotificationWithValue(key);
452 |       if (prevNotification)
453 |         prevNotification.close();
454 |     });
455 |   },
456 | 
457 |   notifyVerification: function(context, key, cancelable) {
458 |     let els = ui.getConvElements(context);
459 |     if (!els) return;
460 |     let { cti, box, uiConv } = els;
461 | 
462 |     // TODO: maybe update the .label property on the notification instead
463 |     // of closing it ... although, buttons need to be updated too.
464 |     ui.closeVerification(context);
465 | 
466 |     let msg = authLabelMap.get(key);
467 |     let buttons = [];
468 |     if (cancelable) {
469 |       buttons = [{
470 |         label: _("auth.cancel"),
471 |         accessKey: _("auth.cancelAccessKey"),
472 |         callback: function() {
473 |           let context = otr.getContext(uiConv.target);
474 |           otr.abortSMP(context);
475 |         }
476 |       }];
477 |     }
478 | 
479 |     // higher priority to overlay the current notifyUnverified
480 |     let priority = box.PRIORITY_WARNING_HIGH;
481 |     box.appendNotification(msg, key, null, priority, buttons, null);
482 |   },
483 | 
484 |   updateAuth: function(aObj) {
485 |     let uiConv = otr.getUIConvFromContext(aObj.context);
486 |     if (!aObj.progress) {
487 |       ui.closeAuth(aObj.context);
488 |       ui.notifyVerification(aObj.context, "otr:auth-error", false);
489 |     } else if (aObj.progress === 100) {
490 |       let key;
491 |       if (aObj.success) {
492 |         if (aObj.context.trust) {
493 |           key = "otr:auth-success";
494 |           otr.notifyTrust(aObj.context);
495 |         } else {
496 |           key = "otr:auth-successThem";
497 |         }
498 |       } else {
499 |         key = "otr:auth-fail";
500 |         if (!aObj.context.trust)
501 |           otr.notifyTrust(aObj.context);
502 |       }
503 |       ui.notifyVerification(aObj.context, key, false);
504 |     } else {
505 |       // TODO: show the aObj.progress to the user with a
506 |       //   <progressmeter mode="determined" value="10" />
507 |       ui.notifyVerification(aObj.context, "otr:auth-waiting", true);
508 |     }
509 |   },
510 | 
511 |   generate: function(args) {
512 |     let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
513 |     args.wrappedJSObject = args;
514 |     Services.ww.openWindow(null, privDialog, "", features, args);
515 |   },
516 | 
517 |   onAccountCreated: function(acc) {
518 |     let account = acc.normalizedName;
519 |     let protocol = acc.protocol.normalizedName;
520 |     let p = Promise.resolve();
521 |     if (otr.privateKeyFingerprint(account, protocol) === null)
522 |       p = otr.generatePrivateKey(account, protocol);
523 |     p.then(function() {
524 |       if (coniks.isEnabled)
525 |         return coniks.onAccountCreated(acc);
526 |     }).catch(function(err) {
527 |       Cu.reportError(err);
528 |     });
529 |   },
530 | 
531 |   contactWrapper: function(contact) {
532 |     let wrapper = {
533 |       account: contact.preferredBuddy.preferredAccountBuddy.account.normalizedName,
534 |       protocol: contact.preferredBuddy.protocol.normalizedName,
535 |       screenname: contact.preferredBuddy.preferredAccountBuddy.userName,
536 |     };
537 |     return wrapper;
538 |   },
539 | 
540 |   onContactAdded: function(contact) {
541 |     let args = ui.contactWrapper(contact);
542 |     if (otr.getFingerprintsForRecipient(args.account, args.protocol, args.screenname).length > 0)
543 |       return;
544 |     args.wrappedJSObject = args;
545 |     let features = "chrome,modal,centerscreen,resizable=no,minimizable=no";
546 |     Services.ww.openWindow(null, addFingerDialog, "", features, args);
547 |   },
548 | 
549 |   observe: function(aObject, aTopic, aMsg) {
550 |     switch(aTopic) {
551 |     case "nsPref:changed":
552 |       ui.changePref(aMsg);
553 |       break;
554 |     case "conversation-loaded":
555 |       let doc = aObject.ownerDocument;
556 |       if (doc.documentElement.getAttribute("windowtype") !== "Messenger:convs")
557 |         return;
558 |       let binding = doc.getBindingParent(aObject);
559 |       ui.addButton(binding);
560 |       break;
561 |     case "conversation-closed":
562 |       if (aObject.isChat)
563 |         return;
564 |       ui.closeAuth(otr.getContext(aObject));
565 |       ui.disconnect(aObject);
566 |       break;
567 |     case "prpl-quit":
568 |       ui.disconnect(null);
569 |       break;
570 |     case "domwindowopened":
571 |       ui.addMenus(aObject);
572 |       break;
573 |     case "otr:generate":
574 |       ui.generate(aObject);
575 |       break;
576 |     case "otr:disconnected":
577 |     case "otr:msg-state":
578 |       if (aTopic === "otr:disconnected" ||
579 |           otr.trust(aObject) !== otr.trustState.TRUST_UNVERIFIED) {
580 |         ui.closeAuth(aObject);
581 |         ui.closeUnverified(aObject);
582 |         ui.closeVerification(aObject);
583 |       }
584 |       ui.updateButton(aObject);
585 |       break;
586 |     case "otr:unverified":
587 |       ui.notifyUnverified(aObject, aMsg);
588 |       break;
589 |     case "otr:trust-state":
590 |       ui.alertTrust(aObject);
591 |       break;
592 |     case "otr:log":
593 |       ui.log("otr: " + aObject);
594 |       break;
595 |     case "account-added":
596 |       ui.onAccountCreated(aObject);
597 |       break;
598 |     case "contact-added":
599 |       ui.onContactAdded(aObject);
600 |       break;
601 |     case "otr:auth-ask":
602 |       ui.askAuth(aObject);
603 |       break;
604 |     case "otr:auth-update":
605 |       ui.updateAuth(aObject);
606 |       break;
607 |     }
608 |   },
609 | 
610 |   initConv: function(binding) {
611 |     otr.addConversation(binding._conv);
612 |     ui.addButton(binding);
613 |   },
614 | 
615 |   resetConv: function(binding) {
616 |     otr.removeConversation(binding._conv);
617 |     let cti = binding.getElt("conv-top-info");
618 |     let otrButton = cti.querySelector(".otr-button");
619 |     if (!otrButton)
620 |       return;
621 |     otrButton.parentNode.removeChild(otrButton);
622 |   },
623 | 
624 |   destroy: function() {
625 |     ui.disconnect(null);
626 |     Services.obs.removeObserver(otr, "new-ui-conversation");
627 |     // Services.obs.removeObserver(ui, "contact-added");
628 |     Services.obs.removeObserver(ui, "account-added");
629 |     Services.obs.removeObserver(ui, "conversation-loaded");
630 |     Services.obs.removeObserver(ui, "conversation-closed");
631 |     Services.obs.removeObserver(ui, "prpl-quit");
632 |     Conversations._conversations.forEach(ui.resetConv);
633 |     ui.prefs.removeObserver("", ui);
634 |     otr.removeObserver(ui);
635 |     otr.close();
636 |     ui.removeMenuObserver();
637 |     coniks.destroy();
638 |   },
639 | 
640 | };


--------------------------------------------------------------------------------
/chrome/content/worker.js:
--------------------------------------------------------------------------------
 1 | importScripts("resource://gre/modules/workers/require.js");
 2 | 
 3 | var PromiseWorker = require("resource://gre/modules/workers/PromiseWorker.js");
 4 | 
 5 | var Funcs = {};
 6 | 
 7 | // Only what we need from libotr.js
 8 | Funcs.generateKey = function(path, otrl_version, newkeySource) {
 9 |   let newkey = eval(newkeySource);  // jshint ignore:line
10 |   let libotr = ctypes.open(path);
11 | 
12 |   let abi = ctypes.default_abi;
13 |   let gcry_error_t = ctypes.unsigned_int;
14 | 
15 |   // Initialize the OTR library. Pass the version of the API you are using.
16 |   let otrl_init = libotr.declare(
17 |     "otrl_init", abi, gcry_error_t,
18 |     ctypes.unsigned_int, ctypes.unsigned_int, ctypes.unsigned_int
19 |   );
20 | 
21 |   // Do the private key generation calculation. You may call this from a
22 |   // background thread.  When it completes, call
23 |   // otrl_privkey_generate_finish from the _main_ thread.
24 |   let otrl_privkey_generate_calculate = libotr.declare(
25 |     "otrl_privkey_generate_calculate", abi, gcry_error_t,
26 |     ctypes.void_t.ptr
27 |   );
28 | 
29 |   otrl_init.apply(libotr, otrl_version);
30 |   let err = otrl_privkey_generate_calculate(newkey);
31 |   libotr.close();
32 |   if (err)
33 |     throw new Error("otrl_privkey_generate_calculate (" + err + ")");
34 | };
35 | 
36 | var worker = new PromiseWorker.AbstractWorker();
37 | 
38 | worker.dispatch = function(method, args = []) {
39 |   return Funcs[method](...args);
40 | };
41 | 
42 | worker.postMessage = function(res, ...args) {
43 |   self.postMessage(res, ...args);
44 | };
45 | 
46 | worker.close = function() {
47 |   self.close();
48 | };
49 | 
50 | self.addEventListener("message", msg => worker.handleMessage(msg));
51 | 


--------------------------------------------------------------------------------
/chrome/locale/en/auth.dtd:
--------------------------------------------------------------------------------
 1 | <!ENTITY authDialog.title "Verify contact's identity">
 2 | <!ENTITY authDialog.authenticate "Verify">
 3 | <!ENTITY authDialog.cancel "Cancel">
 4 | <!ENTITY authDialog.help "Help">
 5 | <!ENTITY authDialog.yes "Yes">
 6 | <!ENTITY authDialog.no "No">
 7 | <!ENTITY authDialog.verified "I have verified that this is in fact the correct fingerprint.">
 8 | <!ENTITY authDialog.yourFingerprint "Your fingerprint">
 9 | <!ENTITY authDialog.theirFingerprint "Their purported fingerprint">
10 | <!ENTITY authDialog.manualVerification "Manual fingerprint verification">
11 | <!ENTITY authDialog.questionAndAnswer "Question and answer">
12 | <!ENTITY authDialog.sharedSecret "Shared secret">
13 | <!ENTITY authDialog.manualInstruction "To verify the fingerprint, contact your buddy via some other authenticated channel, such as the telephone or GPG-signed email. Each of you should tell your fingerprint to the other. If everything matches up, you should indicate in the dialog below that you have verified the fingerprint.">
14 | <!ENTITY authDialog.choose "Choose">
15 | <!ENTITY authDialog.how "How would you like to verify your contact's identity?">
16 | <!ENTITY authDialog.qaInstruction "To verify their identity, pick a question whose answer is known only to you and your contact. Enter this question and answer, then wait for your contact to enter the answer as well. If the answers do not match, then you may be talking to an imposter.">
17 | <!ENTITY authDialog.secretInstruction "To verify their identity, pick a secret known only to you and your contact. Enter this secret, then wait for your contact to enter it as well. If the secrets do not match, then you may be talking to an imposter.">
18 | <!ENTITY authDialog.question "Enter question here:">
19 | <!ENTITY authDialog.answer "Enter secret answer here (case sensitive):">
20 | <!ENTITY authDialog.secret "Enter secret here:">
21 | <!ENTITY authDialog.waiting "Waiting for contact ...">


--------------------------------------------------------------------------------
/chrome/locale/en/auth.properties:
--------------------------------------------------------------------------------
1 | auth.title=Verify %S's identity
2 | auth.yourFingerprint=Fingerprint for you, %S:\n%S
3 | auth.theirFingerprint=Purported fingerprint for %S:\n%S
4 | auth.help=Verifying a contact's identity helps ensure that the person you are talking to is who they claim to be.
5 | auth.helpTitle=Verification help
6 | auth.question=This is the question asked by your contact:\n\n%S\n\nEnter secret answer here (case sensitive):
7 | auth.secret=Enter secret here:


--------------------------------------------------------------------------------
/chrome/locale/en/finger.dtd:
--------------------------------------------------------------------------------
 1 | <!ENTITY finger.title "Known fingerprints">
 2 | <!ENTITY finger.screenName "Screenname">
 3 | <!ENTITY finger.status "Status">
 4 | <!ENTITY finger.verified "Verified">
 5 | <!ENTITY finger.fingerprint "Fingerprint">
 6 | <!ENTITY finger.account "Account">
 7 | <!ENTITY finger.protocol "Protocol">
 8 | <!ENTITY finger.verify "Verify">
 9 | <!ENTITY finger.remove "Remove">
10 | <!ENTITY finger.intro "Manage the list of fingerprints you've seen.">
11 | <!ENTITY addFingerDialog.title "Add Fingerprint">
12 | <!ENTITY addFingerDialog.finger "Fingerprint">
13 | <!ENTITY addFingerDialog.accept "OK">
14 | <!ENTITY addFingerDialog.cancel "Skip">
15 | <!ENTITY addFingerDialog.tooltip "If you know the 40 hex char fingerprint of your contact's OTR private key, enter it now.">


--------------------------------------------------------------------------------
/chrome/locale/en/finger.properties:
--------------------------------------------------------------------------------
1 | verified.yes=Yes
2 | verified.no=No
3 | addfinger.title=Enter %S's fingerprint


--------------------------------------------------------------------------------
/chrome/locale/en/otr.properties:
--------------------------------------------------------------------------------
 1 | msgevent.encryption_required_part1=You attempted to send an unencrypted message to %S. As a policy, unencrypted messages are not allowed.
 2 | msgevent.encryption_required_part2=Attempting to start a private conversation. Your message will be retransmitted when the private conversation starts.
 3 | msgevent.encryption_error=An error occurred when encrypting your message. The message was not sent.
 4 | msgevent.connection_ended=%S has already closed their private connection to you. Your message was not sent. Either end your private conversation, or restart it.
 5 | msgevent.setup_error=An error occured while setting up a private conversation with %S.
 6 | msgevent.msg_reflected=You are receiving your own OTR messages. You are either trying to talk to yourself, or someone is reflecting your messages back at you.
 7 | msgevent.msg_resent=The last message to %S was resent.
 8 | msgevent.rcvdmsg_not_private=The encrypted message received from %S is unreadable, as you are not currently communicating privately.
 9 | msgevent.rcvdmsg_unreadable=We received an unreadable encrypted message from %S.
10 | msgevent.rcvdmsg_malformed=We received a malformed data message from %S.
11 | msgevent.log_heartbeat_rcvd=Heartbeat received from %S.
12 | msgevent.log_heartbeat_sent=Heartbeat sent to %S.
13 | msgevent.rcvdmsg_general_err=An OTR error occured.
14 | msgevent.rcvdmsg_unecrypted=The following message received from %S was not encrypted: %S
15 | msgevent.rcvdmsg_unrecognized=We received an unrecognized OTR message from %S.
16 | msgevent.rcvdmsg_for_other_instance=%S has sent a message intended for a different session. If you are logged in multiple times, another session may have received the message.
17 | context.gone_secure_private=Private conversation with %S started.
18 | context.gone_secure_unverified=Private conversation with %S started. However, their identity has not been verified.
19 | context.still_secure=Successfully refreshed the private conversation with %S.
20 | error.enc=Error occurred encrypting message.
21 | error.not_priv=You sent encrypted data to %S, who wasn't expecting it.
22 | error.unreadable=You transmitted an unreadable encrypted message.
23 | error.malformed=You transmitted a malformed data message.
24 | resent=[resent]
25 | tlv.disconnected=%S has ended their private conversation with you; you should do the same.
26 | query.msg=%S has requested an Off-the Record private conversation. However, you do not have a plugin to support that. See http://otr.cypherpunks.ca/ for more information.
27 | trust.unused=Unused
28 | trust.not_private=Not Private
29 | trust.unverified=Unverified
30 | trust.private=Private
31 | trust.finished=Finished


--------------------------------------------------------------------------------
/chrome/locale/en/prefs.dtd:
--------------------------------------------------------------------------------
 1 | <!ENTITY prefs.otrPreferences "OTR Preferences">
 2 | <!ENTITY prefs.otrLabel "OTR">
 3 | <!ENTITY prefs.coniksLabel "CONIKS">
 4 | <!ENTITY prefs.otrSettings "OTR Settings">
 5 | <!ENTITY prefs.requireEncryption "Require encryption">
 6 | <!ENTITY prefs.otrKeys "My Private Keys">
 7 | <!ENTITY prefs.keyForAccount "Key for account:">
 8 | <!ENTITY prefs.fingerprint "Fingerprint:">
 9 | <!ENTITY prefs.knownFingers "Known fingerprints">
10 | <!ENTITY prefs.introFingers "Manage the list of fingerprints you've seen.">
11 | <!ENTITY prefs.showFingers "View">
12 | <!ENTITY prefs.introSettings "These settings apply to all one-to-one conversations.">
13 | <!ENTITY prefs.verifyNudge "Always nudge to verify your contact's identity">
14 | <!ENTITY prefs.emptyAccountList "No accounts configured">
15 | <!ENTITY prefs.generate "Generate">
16 | <!ENTITY prefs.coniksConnection "Connection">
17 | <!ENTITY prefs.coniksServerAddress "Server Address">
18 | <!ENTITY prefs.coniksServerPort "Port">
19 | <!ENTITY prefs.coniksAccountPolicy "Account Policy">
20 | <!ENTITY prefs.coniksPoliciesForAccount "Policies for account:">
21 | <!ENTITY prefs.coniksPrivateLookups "Private lookups">
22 | <!ENTITY prefs.coniksSignedKeyChange "Signed key change">


--------------------------------------------------------------------------------
/chrome/locale/en/priv.dtd:
--------------------------------------------------------------------------------
1 | <!ENTITY privDialog.title "Generating private key">
2 | <!ENTITY privDialog.done "Done">


--------------------------------------------------------------------------------
/chrome/locale/en/priv.properties:
--------------------------------------------------------------------------------
1 | priv.account=Generating private key for %S (%S) ...
2 | priv.failed=Generating key failed: %S


--------------------------------------------------------------------------------
/chrome/locale/en/ui.properties:
--------------------------------------------------------------------------------
 1 | start.label=Start private conversation
 2 | end.label=End private conversation
 3 | refresh.label=Refresh private conversation
 4 | auth.label=Verify your contact's identity
 5 | auth.cancel=Cancel
 6 | auth.cancelAccessKey=C
 7 | auth.error=An error occurred while verifying your contact's identity.
 8 | auth.success=Verifying your contact's identity completed successfully.
 9 | auth.successThem=Your contact has successfully verified your identity. You may want to verify their identity as well by asking your own question.
10 | auth.fail=Failed to verify your contact's identity.
11 | auth.waiting=Waiting for contact ...
12 | reauth.label=Reverify your contact's identity
13 | prefs.label=OTR Preferences
14 | alert.start=Attempting to start a private conversation with %S.
15 | alert.refresh=Attempting to refresh the private conversation with %S.
16 | alert.gone_insecure=Private conversation with %S ended.
17 | finger.seen=%S is contacting you from an unrecognized computer. You should verify this contact's identity.
18 | finger.unseen=%S's identity has not been verified yet. You should verify this contact's identity.
19 | finger.verify=Verify
20 | verify.accessKey=V
21 | state.not_private=The current conversation is not private.
22 | state.unverified=The current conversation is private but %S's identity has not been verified.
23 | state.private=The current conversation is private and %S's identity has been verified.
24 | state.finished=%S has ended their private conversation with you; you should do the same.
25 | afterauth.private=You have verified %S's identity.
26 | afterauth.unverified=%S's identity has not been verified.
27 | buddycontextmenu.label=Add Contact's Fingerprint
28 | 


--------------------------------------------------------------------------------
/chrome/skin/icons/finished.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arlolra/ctypes-otr/aa8c8b7f1718fd610d88db827a13993f68efa806/chrome/skin/icons/finished.png


--------------------------------------------------------------------------------
/chrome/skin/icons/not-private.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arlolra/ctypes-otr/aa8c8b7f1718fd610d88db827a13993f68efa806/chrome/skin/icons/not-private.png


--------------------------------------------------------------------------------
/chrome/skin/icons/private.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arlolra/ctypes-otr/aa8c8b7f1718fd610d88db827a13993f68efa806/chrome/skin/icons/private.png


--------------------------------------------------------------------------------
/chrome/skin/icons/unverified.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arlolra/ctypes-otr/aa8c8b7f1718fd610d88db827a13993f68efa806/chrome/skin/icons/unverified.png


--------------------------------------------------------------------------------
/chrome/skin/otr.css:
--------------------------------------------------------------------------------
 1 | .otr-not_private {
 2 |   list-style-image: url("icons/not-private.png");
 3 | }
 4 | 
 5 | .otr-unverified {
 6 |   list-style-image: url("icons/unverified.png");
 7 | }
 8 | 
 9 | .otr-finished {
10 |   list-style-image: url("icons/finished.png");
11 | }
12 | 
13 | .otr-private {
14 |   list-style-image: url("icons/private.png");
15 | }
16 | 
17 | .otr-button > .toolbarbutton-icon {
18 |   max-width: 16px;
19 | }


--------------------------------------------------------------------------------
/install.rdf:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 3 |      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 4 | 
 5 |   <Description about="urn:mozilla:install-manifest">
 6 |     
 7 |     <!-- Required -->
 8 |     <em:id>ctypes-otr@tormessenger</em:id>
 9 |     <em:name>ctypes-otr</em:name>
10 |     <em:version>0.0.4+git</em:version>
11 |     <em:type>2</em:type>
12 |     <em:unpack>true</em:unpack>
13 |     <em:bootstrap>true</em:bootstrap>
14 | 
15 |     <!-- Instantbird -->
16 |     <em:targetApplication>
17 |       <Description>
18 |         <em:id>{33cb9019-c295-46dd-be21-8c4936574bee}</em:id>
19 |         <em:minVersion>0</em:minVersion>
20 |         <em:maxVersion>*</em:maxVersion>
21 |       </Description>
22 |     </em:targetApplication>
23 | 
24 |     <!-- Optional -->
25 |     <em:creator>Arlo Breault</em:creator>
26 |     <em:description>js-ctypes wrapper for libotr</em:description>
27 |     <em:homepageURL>https://github.com/arlolra/ctypes-otr</em:homepageURL>
28 |     <em:optionsURL>chrome://otr/content/prefs.xul</em:optionsURL>
29 |     <em:updateURL>data:text/plain,</em:updateURL>
30 |     <em:updateKey>-</em:updateKey>
31 | 
32 |   </Description>
33 | 
34 | </RDF>
35 | 


--------------------------------------------------------------------------------
/license:
--------------------------------------------------------------------------------
  1 | Mozilla Public License Version 2.0
  2 | ==================================
  3 | 
  4 | 1. Definitions
  5 | --------------
  6 | 
  7 | 1.1. "Contributor"
  8 |     means each individual or legal entity that creates, contributes to
  9 |     the creation of, or owns Covered Software.
 10 | 
 11 | 1.2. "Contributor Version"
 12 |     means the combination of the Contributions of others (if any) used
 13 |     by a Contributor and that particular Contributor's Contribution.
 14 | 
 15 | 1.3. "Contribution"
 16 |     means Covered Software of a particular Contributor.
 17 | 
 18 | 1.4. "Covered Software"
 19 |     means Source Code Form to which the initial Contributor has attached
 20 |     the notice in Exhibit A, the Executable Form of such Source Code
 21 |     Form, and Modifications of such Source Code Form, in each case
 22 |     including portions thereof.
 23 | 
 24 | 1.5. "Incompatible With Secondary Licenses"
 25 |     means
 26 | 
 27 |     (a) that the initial Contributor has attached the notice described
 28 |         in Exhibit B to the Covered Software; or
 29 | 
 30 |     (b) that the Covered Software was made available under the terms of
 31 |         version 1.1 or earlier of the License, but not also under the
 32 |         terms of a Secondary License.
 33 | 
 34 | 1.6. "Executable Form"
 35 |     means any form of the work other than Source Code Form.
 36 | 
 37 | 1.7. "Larger Work"
 38 |     means a work that combines Covered Software with other material, in 
 39 |     a separate file or files, that is not Covered Software.
 40 | 
 41 | 1.8. "License"
 42 |     means this document.
 43 | 
 44 | 1.9. "Licensable"
 45 |     means having the right to grant, to the maximum extent possible,
 46 |     whether at the time of the initial grant or subsequently, any and
 47 |     all of the rights conveyed by this License.
 48 | 
 49 | 1.10. "Modifications"
 50 |     means any of the following:
 51 | 
 52 |     (a) any file in Source Code Form that results from an addition to,
 53 |         deletion from, or modification of the contents of Covered
 54 |         Software; or
 55 | 
 56 |     (b) any new file in Source Code Form that contains any Covered
 57 |         Software.
 58 | 
 59 | 1.11. "Patent Claims" of a Contributor
 60 |     means any patent claim(s), including without limitation, method,
 61 |     process, and apparatus claims, in any patent Licensable by such
 62 |     Contributor that would be infringed, but for the grant of the
 63 |     License, by the making, using, selling, offering for sale, having
 64 |     made, import, or transfer of either its Contributions or its
 65 |     Contributor Version.
 66 | 
 67 | 1.12. "Secondary License"
 68 |     means either the GNU General Public License, Version 2.0, the GNU
 69 |     Lesser General Public License, Version 2.1, the GNU Affero General
 70 |     Public License, Version 3.0, or any later versions of those
 71 |     licenses.
 72 | 
 73 | 1.13. "Source Code Form"
 74 |     means the form of the work preferred for making modifications.
 75 | 
 76 | 1.14. "You" (or "Your")
 77 |     means an individual or a legal entity exercising rights under this
 78 |     License. For legal entities, "You" includes any entity that
 79 |     controls, is controlled by, or is under common control with You. For
 80 |     purposes of this definition, "control" means (a) the power, direct
 81 |     or indirect, to cause the direction or management of such entity,
 82 |     whether by contract or otherwise, or (b) ownership of more than
 83 |     fifty percent (50%) of the outstanding shares or beneficial
 84 |     ownership of such entity.
 85 | 
 86 | 2. License Grants and Conditions
 87 | --------------------------------
 88 | 
 89 | 2.1. Grants
 90 | 
 91 | Each Contributor hereby grants You a world-wide, royalty-free,
 92 | non-exclusive license:
 93 | 
 94 | (a) under intellectual property rights (other than patent or trademark)
 95 |     Licensable by such Contributor to use, reproduce, make available,
 96 |     modify, display, perform, distribute, and otherwise exploit its
 97 |     Contributions, either on an unmodified basis, with Modifications, or
 98 |     as part of a Larger Work; and
 99 | 
100 | (b) under Patent Claims of such Contributor to make, use, sell, offer
101 |     for sale, have made, import, and otherwise transfer either its
102 |     Contributions or its Contributor Version.
103 | 
104 | 2.2. Effective Date
105 | 
106 | The licenses granted in Section 2.1 with respect to any Contribution
107 | become effective for each Contribution on the date the Contributor first
108 | distributes such Contribution.
109 | 
110 | 2.3. Limitations on Grant Scope
111 | 
112 | The licenses granted in this Section 2 are the only rights granted under
113 | this License. No additional rights or licenses will be implied from the
114 | distribution or licensing of Covered Software under this License.
115 | Notwithstanding Section 2.1(b) above, no patent license is granted by a
116 | Contributor:
117 | 
118 | (a) for any code that a Contributor has removed from Covered Software;
119 |     or
120 | 
121 | (b) for infringements caused by: (i) Your and any other third party's
122 |     modifications of Covered Software, or (ii) the combination of its
123 |     Contributions with other software (except as part of its Contributor
124 |     Version); or
125 | 
126 | (c) under Patent Claims infringed by Covered Software in the absence of
127 |     its Contributions.
128 | 
129 | This License does not grant any rights in the trademarks, service marks,
130 | or logos of any Contributor (except as may be necessary to comply with
131 | the notice requirements in Section 3.4).
132 | 
133 | 2.4. Subsequent Licenses
134 | 
135 | No Contributor makes additional grants as a result of Your choice to
136 | distribute the Covered Software under a subsequent version of this
137 | License (see Section 10.2) or under the terms of a Secondary License (if
138 | permitted under the terms of Section 3.3).
139 | 
140 | 2.5. Representation
141 | 
142 | Each Contributor represents that the Contributor believes its
143 | Contributions are its original creation(s) or it has sufficient rights
144 | to grant the rights to its Contributions conveyed by this License.
145 | 
146 | 2.6. Fair Use
147 | 
148 | This License is not intended to limit any rights You have under
149 | applicable copyright doctrines of fair use, fair dealing, or other
150 | equivalents.
151 | 
152 | 2.7. Conditions
153 | 
154 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
155 | in Section 2.1.
156 | 
157 | 3. Responsibilities
158 | -------------------
159 | 
160 | 3.1. Distribution of Source Form
161 | 
162 | All distribution of Covered Software in Source Code Form, including any
163 | Modifications that You create or to which You contribute, must be under
164 | the terms of this License. You must inform recipients that the Source
165 | Code Form of the Covered Software is governed by the terms of this
166 | License, and how they can obtain a copy of this License. You may not
167 | attempt to alter or restrict the recipients' rights in the Source Code
168 | Form.
169 | 
170 | 3.2. Distribution of Executable Form
171 | 
172 | If You distribute Covered Software in Executable Form then:
173 | 
174 | (a) such Covered Software must also be made available in Source Code
175 |     Form, as described in Section 3.1, and You must inform recipients of
176 |     the Executable Form how they can obtain a copy of such Source Code
177 |     Form by reasonable means in a timely manner, at a charge no more
178 |     than the cost of distribution to the recipient; and
179 | 
180 | (b) You may distribute such Executable Form under the terms of this
181 |     License, or sublicense it under different terms, provided that the
182 |     license for the Executable Form does not attempt to limit or alter
183 |     the recipients' rights in the Source Code Form under this License.
184 | 
185 | 3.3. Distribution of a Larger Work
186 | 
187 | You may create and distribute a Larger Work under terms of Your choice,
188 | provided that You also comply with the requirements of this License for
189 | the Covered Software. If the Larger Work is a combination of Covered
190 | Software with a work governed by one or more Secondary Licenses, and the
191 | Covered Software is not Incompatible With Secondary Licenses, this
192 | License permits You to additionally distribute such Covered Software
193 | under the terms of such Secondary License(s), so that the recipient of
194 | the Larger Work may, at their option, further distribute the Covered
195 | Software under the terms of either this License or such Secondary
196 | License(s).
197 | 
198 | 3.4. Notices
199 | 
200 | You may not remove or alter the substance of any license notices
201 | (including copyright notices, patent notices, disclaimers of warranty,
202 | or limitations of liability) contained within the Source Code Form of
203 | the Covered Software, except that You may alter any license notices to
204 | the extent required to remedy known factual inaccuracies.
205 | 
206 | 3.5. Application of Additional Terms
207 | 
208 | You may choose to offer, and to charge a fee for, warranty, support,
209 | indemnity or liability obligations to one or more recipients of Covered
210 | Software. However, You may do so only on Your own behalf, and not on
211 | behalf of any Contributor. You must make it absolutely clear that any
212 | such warranty, support, indemnity, or liability obligation is offered by
213 | You alone, and You hereby agree to indemnify every Contributor for any
214 | liability incurred by such Contributor as a result of warranty, support,
215 | indemnity or liability terms You offer. You may include additional
216 | disclaimers of warranty and limitations of liability specific to any
217 | jurisdiction.
218 | 
219 | 4. Inability to Comply Due to Statute or Regulation
220 | ---------------------------------------------------
221 | 
222 | If it is impossible for You to comply with any of the terms of this
223 | License with respect to some or all of the Covered Software due to
224 | statute, judicial order, or regulation then You must: (a) comply with
225 | the terms of this License to the maximum extent possible; and (b)
226 | describe the limitations and the code they affect. Such description must
227 | be placed in a text file included with all distributions of the Covered
228 | Software under this License. Except to the extent prohibited by statute
229 | or regulation, such description must be sufficiently detailed for a
230 | recipient of ordinary skill to be able to understand it.
231 | 
232 | 5. Termination
233 | --------------
234 | 
235 | 5.1. The rights granted under this License will terminate automatically
236 | if You fail to comply with any of its terms. However, if You become
237 | compliant, then the rights granted under this License from a particular
238 | Contributor are reinstated (a) provisionally, unless and until such
239 | Contributor explicitly and finally terminates Your grants, and (b) on an
240 | ongoing basis, if such Contributor fails to notify You of the
241 | non-compliance by some reasonable means prior to 60 days after You have
242 | come back into compliance. Moreover, Your grants from a particular
243 | Contributor are reinstated on an ongoing basis if such Contributor
244 | notifies You of the non-compliance by some reasonable means, this is the
245 | first time You have received notice of non-compliance with this License
246 | from such Contributor, and You become compliant prior to 30 days after
247 | Your receipt of the notice.
248 | 
249 | 5.2. If You initiate litigation against any entity by asserting a patent
250 | infringement claim (excluding declaratory judgment actions,
251 | counter-claims, and cross-claims) alleging that a Contributor Version
252 | directly or indirectly infringes any patent, then the rights granted to
253 | You by any and all Contributors for the Covered Software under Section
254 | 2.1 of this License shall terminate.
255 | 
256 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
257 | end user license agreements (excluding distributors and resellers) which
258 | have been validly granted by You or Your distributors under this License
259 | prior to termination shall survive termination.
260 | 
261 | ************************************************************************
262 | *                                                                      *
263 | *  6. Disclaimer of Warranty                                           *
264 | *  -------------------------                                           *
265 | *                                                                      *
266 | *  Covered Software is provided under this License on an "as is"       *
267 | *  basis, without warranty of any kind, either expressed, implied, or  *
268 | *  statutory, including, without limitation, warranties that the       *
269 | *  Covered Software is free of defects, merchantable, fit for a        *
270 | *  particular purpose or non-infringing. The entire risk as to the     *
271 | *  quality and performance of the Covered Software is with You.        *
272 | *  Should any Covered Software prove defective in any respect, You     *
273 | *  (not any Contributor) assume the cost of any necessary servicing,   *
274 | *  repair, or correction. This disclaimer of warranty constitutes an   *
275 | *  essential part of this License. No use of any Covered Software is   *
276 | *  authorized under this License except under this disclaimer.         *
277 | *                                                                      *
278 | ************************************************************************
279 | 
280 | ************************************************************************
281 | *                                                                      *
282 | *  7. Limitation of Liability                                          *
283 | *  --------------------------                                          *
284 | *                                                                      *
285 | *  Under no circumstances and under no legal theory, whether tort      *
286 | *  (including negligence), contract, or otherwise, shall any           *
287 | *  Contributor, or anyone who distributes Covered Software as          *
288 | *  permitted above, be liable to You for any direct, indirect,         *
289 | *  special, incidental, or consequential damages of any character      *
290 | *  including, without limitation, damages for lost profits, loss of    *
291 | *  goodwill, work stoppage, computer failure or malfunction, or any    *
292 | *  and all other commercial damages or losses, even if such party      *
293 | *  shall have been informed of the possibility of such damages. This   *
294 | *  limitation of liability shall not apply to liability for death or   *
295 | *  personal injury resulting from such party's negligence to the       *
296 | *  extent applicable law prohibits such limitation. Some               *
297 | *  jurisdictions do not allow the exclusion or limitation of           *
298 | *  incidental or consequential damages, so this exclusion and          *
299 | *  limitation may not apply to You.                                    *
300 | *                                                                      *
301 | ************************************************************************
302 | 
303 | 8. Litigation
304 | -------------
305 | 
306 | Any litigation relating to this License may be brought only in the
307 | courts of a jurisdiction where the defendant maintains its principal
308 | place of business and such litigation shall be governed by laws of that
309 | jurisdiction, without reference to its conflict-of-law provisions.
310 | Nothing in this Section shall prevent a party's ability to bring
311 | cross-claims or counter-claims.
312 | 
313 | 9. Miscellaneous
314 | ----------------
315 | 
316 | This License represents the complete agreement concerning the subject
317 | matter hereof. If any provision of this License is held to be
318 | unenforceable, such provision shall be reformed only to the extent
319 | necessary to make it enforceable. Any law or regulation which provides
320 | that the language of a contract shall be construed against the drafter
321 | shall not be used to construe this License against a Contributor.
322 | 
323 | 10. Versions of the License
324 | ---------------------------
325 | 
326 | 10.1. New Versions
327 | 
328 | Mozilla Foundation is the license steward. Except as provided in Section
329 | 10.3, no one other than the license steward has the right to modify or
330 | publish new versions of this License. Each version will be given a
331 | distinguishing version number.
332 | 
333 | 10.2. Effect of New Versions
334 | 
335 | You may distribute the Covered Software under the terms of the version
336 | of the License under which You originally received the Covered Software,
337 | or under the terms of any subsequent version published by the license
338 | steward.
339 | 
340 | 10.3. Modified Versions
341 | 
342 | If you create software not governed by this License, and you want to
343 | create a new license for such software, you may create and use a
344 | modified version of this License if you rename the license and remove
345 | any references to the name of the license steward (except to note that
346 | such modified license differs from this License).
347 | 
348 | 10.4. Distributing Source Code Form that is Incompatible With Secondary
349 | Licenses
350 | 
351 | If You choose to distribute Source Code Form that is Incompatible With
352 | Secondary Licenses under the terms of this version of the License, the
353 | notice described in Exhibit B of this License must be attached.
354 | 
355 | Exhibit A - Source Code Form License Notice
356 | -------------------------------------------
357 | 
358 |   This Source Code Form is subject to the terms of the Mozilla Public
359 |   License, v. 2.0. If a copy of the MPL was not distributed with this
360 |   file, You can obtain one at http://mozilla.org/MPL/2.0/.
361 | 
362 | If it is not possible or desirable to put the notice in a particular
363 | file, then You may include the notice in a location (such as a LICENSE
364 | file in a relevant directory) where a recipient would be likely to look
365 | for such a notice.
366 | 
367 | You may add additional accurate notices of copyright ownership.
368 | 
369 | Exhibit B - "Incompatible With Secondary Licenses" Notice
370 | ---------------------------------------------------------
371 | 
372 |   This Source Code Form is "Incompatible With Secondary Licenses", as
373 |   defined by the Mozilla Public License, v. 2.0.


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ctypes-otr",
 3 |   "version": "0.0.4+git",
 4 |   "description": "js-ctypes wrapper for libotr",
 5 |   "main": "chrome/content/otr.js",
 6 |   "scripts": {
 7 |     "jpm": "jpm --addon-dir addon/ test",
 8 |     "jpm-travis": "jpm --addon-dir addon/ --binary `which firefox` test",
 9 |     "jshint": "jshint bootstrap.js test/ chrome/content/",
10 |     "eslint": "eslint --ext .js .",
11 |     "lint": "npm run eslint && npm run jshint",
12 |     "mocha": "mocha --opts test/mocha.opts test/",
13 |     "test": "npm run lint && npm run jpm"
14 |   },
15 |   "repository": {
16 |     "type": "git",
17 |     "url": "git+https://github.com/arlolra/ctypes-otr.git"
18 |   },
19 |   "author": "Arlo Breault <arlolra@gmail.com>",
20 |   "license": "MPL-2.0",
21 |   "bugs": {
22 |     "url": "https://github.com/arlolra/ctypes-otr/issues"
23 |   },
24 |   "dependencies": {
25 |     "ctypes": "git+https://github.com/TooTallNate/node-ctypes#987ba78db449c402ea4d86a831adb01b455e9209"
26 |   },
27 |   "devDependencies": {
28 |     "eslint": "^3.1.1",
29 |     "eslint-plugin-mozilla": "^0.0.3",
30 |     "jpm": "^1.1.3",
31 |     "jshint": "^2.9.2",
32 |     "mocha": "^2.5.3"
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | [![Build Status](https://travis-ci.org/arlolra/ctypes-otr.svg?branch=master)](https://travis-ci.org/arlolra/ctypes-otr)
 2 | 
 3 | ctypes-otr
 4 | ==========
 5 | 
 6 | Intro
 7 | -----
 8 | 
 9 | [Part][1] of the plan for the [Tor Messenger][2].
10 | 
11 | [1]: https://trac.torproject.org/projects/tor/ticket/10210
12 | [2]: https://trac.torproject.org/projects/tor/wiki/doc/TorMessenger
13 | 
14 | Dev Env
15 | -------
16 | 
17 | Download a [nightly build of Instantbird][3] and install it. Then create a profile,
18 | 
19 | On darwin,
20 | 
21 | ```
22 | ~/Applications/Instantbird.app/Contents/MacOS/instantbird-bin -p
23 | ```
24 | 
25 | On linux,
26 | 
27 | ```
28 | instantbird -ProfileManager
29 | ```
30 | 
31 | Now clone this repo and link to the extension.
32 | 
33 | On darwin,
34 | 
35 | ```
36 | brew install libotr
37 | git clone https://github.com/arlolra/ctypes-otr.git
38 | cd ctypes-otr
39 | mkdir -p ~/Library/Application\ Support/Instantbird/Profiles/<profile>/extensions
40 | pwd > ~/Library/Application\ Support/Instantbird/Profiles/<profile>/extensions/ctypes-otr\@tormessenger
41 | ```
42 | 
43 | On linux,
44 | 
45 | ```
46 | sudo apt-get install libotr5-dev
47 | git clone https://github.com/arlolra/ctypes-otr.git
48 | cd ctypes-otr
49 | mkdir -p ~/.instantbird/<profile>/extensions
50 | pwd > ~/.instantbird/<profile>/extensions/ctypes-otr\@tormessenger
51 | ```
52 | 
53 | Now launch Instantbird and OTR should be enabled. This is confirmed by the
54 | little lock in the top right of private conversations.
55 | 
56 | The default policies can be changed in `Tools > Add-ons > ctypes-otr > Preferences`.
57 | 
58 | [3]: http://ftp.instantbird.com/instantbird/nightly/latest-trunk/
59 | 
60 | Release
61 | -------
62 | 
63 | ```
64 | export VERSION="X.X.X"
65 | // bump the version numbers in package.json / install.rdf
66 | git changelog  // edit
67 | git commit -S -m "Release version $VERSION"
68 | git tag -s $VERSION -m $VERSION
69 | git push origin master
70 | git push --tags
71 | // bump the version numbers (+git) after the release
72 | ```
73 | 
74 | Credits
75 | -------
76 | 
77 | Inspired by [FireOTR](https://gitorious.org/fireotr).
78 | 
79 | License
80 | -------
81 | 
82 | MPL v2.0


--------------------------------------------------------------------------------