From 1418d39876e71238fbb65bb42fb983b6e6664faf Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Thu, 29 Mar 2018 14:56:20 +0200
Subject: [PATCH 1/6] request symmetric key after pkey exchange

---
 demos/sum/server.js |  2 +-
 lib/jiff-client.js  | 88 ++++++++++++++++++++++++++++++++++++++++++++-
 lib/jiff-server.js  | 32 +++++++++++++++++
 3 files changed, 120 insertions(+), 2 deletions(-)

diff --git a/demos/sum/server.js b/demos/sum/server.js
index f09713178..a3eda7fc9 100644
--- a/demos/sum/server.js
+++ b/demos/sum/server.js
@@ -1,7 +1,7 @@
 var express = require('express');
 var app = express();
 var http = require('http').Server(app);
-var jiff_instance = require('../../lib/jiff-server').make_jiff(http, {logs:true});
+var jiff_instance = require('../../lib/jiff-server').make_jiff(http, {logs:true, encryptionType:'SymmetricKey'});
 
 // Define a computation with id '1' and a maximum of 3 participants.
 jiff_instance.totalparty_map['1'] = 3;
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index f589ac724..fc13f518c 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -110,6 +110,73 @@
     }
   }
 
+  /**
+   * Encrypts a message with a symmetric key and adds a tag for validation (using crypto_aead_xchacha20poly1305_ietf_encrypt).
+   * @memberof jiff.utils
+   * @instance
+   * @param {number/String} message - the message to encrypt.
+   * @param {Uint8Array/Array/String} symmetric_key - the symmetric key to be used for encryption.
+   * @returns {object} - the signed cipher. {cipher:<cipher>,nonce:<nonce>}
+   */
+  function symmetric_key_encrypt(message, symmetric_key) {
+    var generatedNonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+    try {
+      symmetric_key = symmetric_key instanceof Uint8Array ? symmetric_key :
+                      symmetric_key instanceof Array ? new Uint8Array(symmetric_key) :
+                      new Uint8Array(JSON.parse(symmbetric_key))
+    } catch(e) {
+      console.error('error parsing symmetric key');
+      console.error(e);
+      return;
+    }
+
+    var generatedCiphertext = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
+      message,
+      null,
+      null,
+      generatedNonce,
+      symmetric_key
+    );
+    return {"cipher": '['+generatedCiphertext.toString()+']',"nonce": '['+generatedNonce.toString()+']'};
+  }
+
+  /**
+   * Decrypts a message with a symmetric key and verifies it (using crypto_aead_xchacha20poly1305_ietf_decrypt).
+   * @memberof jiff.utils
+   * @instance
+   * @param {Uint8Array/Array/String} ciphertext - the ciphertext to decrypt.
+   * @param {Uint8Array/Array/String} symmetric_key - the symmetric_key to decrypt with.
+   * @param {Uint8Array/Array/String} nonce - the nonce used to decrypt with.
+   * @returns {number/string} the decrypted message.
+   */
+  function symmetric_key_decrypt(ciphertext, symmetric_key, nonce) {
+    try {
+      ciphertext = ciphertext instanceof Uint8Array ? ciphertext :
+                   ciphertext instanceof Array ? new Uint8Array(ciphertext) :
+                   new Uint8Array(JSON.parse(ciphertext));
+      symmetric_key = symmetric_key instanceof Uint8Array ? symmetric_key :
+                      symmetric_key instanceof Array ? new Uint8Array(symmetric_key) :
+                      new Uint8Array(JSON.parse(symmetric_key));
+      nonce = nonce instanceof Uint8Array ? nonce :
+                      nonce instanceof Array ? new Uint8Array(nonce) :
+                      new Uint8Array(JSON.parse(nonce));
+    } catch(e) {
+      console.error('error parsing an input to symmetric_key_decrypt');
+      console.error(e);
+      return;
+    }
+
+    var decryptedText = sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(
+      null,
+      ciphertext,
+      null,
+      nonce,
+      symmetric_key //symmetric_key_map[computation_id][party_id]
+    );
+
+    return decryptedText;
+  }
+
   /**
    * Share given secret to the participating parties.
    * @param {jiff-instance} jiff - the jiff instance.
@@ -1874,6 +1941,8 @@
     if(jiff.hooks.reconstructShare == null) jiff.hooks.reconstructShare = jiff_lagrange;
     if(jiff.hooks.encryptSign == null) jiff.hooks.encryptSign = encrypt_and_sign;
     if(jiff.hooks.decryptSign == null) jiff.hooks.decryptSign = decrypt_and_sign;
+    if(jiff.hooks.symmetricEncrypt == null) jiff.hooks.symmetricEncrypt = symmetric_key_encrypt;
+    if(jiff.hooks.symmetricDecrypt == null) jiff.hooks.symmetricDecrypt = symmetric_key_decrypt;
 
     /**
      * Execute all hooks attached to the given name in order.
@@ -2381,6 +2450,11 @@
 
         // Check if all keys have been received
         if(jiff.keymap["s1"] == null) return;
+
+        // request symmetric key
+        jiff.socket.emit('symmetric_key');
+
+        // Check if all keys have been received
         for(var i = 1; i <= jiff.party_count; i++)
           if(jiff.keymap[i] == null) return;
 
@@ -2393,6 +2467,17 @@
       });
     });
 
+    jiff.socket.on('symmetric_key', function(msg) {
+      var decryptedSymmetricKey = jiff.hooks.decryptSign(
+        msg,
+        jiff.secret_key,
+        jiff.keymap["s1"],
+        'symmetric_key'
+      );
+
+      jiff.serversSymmetricKey = new Uint8Array(JSON.parse(decryptedSymmetricKey));
+    });
+
     // Store sharing and shares counter which keeps track of the count of
     // sharing operations (share and open) and the total number of shares
     // respectively (used to get a unique id for each share operation and
@@ -2571,6 +2656,7 @@
 
   // Exported API
   exports.make_jiff = make_jiff;
-  exports.utils = { 'encrypt_and_sign': encrypt_and_sign, 'decrypt_and_sign': decrypt_and_sign };
+  exports.utils = { 'encrypt_and_sign': encrypt_and_sign, 'decrypt_and_sign': decrypt_and_sign,
+                    'symmetric_key_encrypt': symmetric_key_encrypt, 'symmetric_key_decrypt': symmetric_key_decrypt };
   exports.sharing_schemes = { 'shamir_share': jiff_compute_shares, 'shamir_reconstruct': jiff_lagrange };
 }((typeof exports == 'undefined' ? this.jiff = {} : exports), typeof exports != 'undefined'));
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index bb1eb64a4..0a326d466 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -17,6 +17,9 @@ module.exports = {
     if(options == null) options = {};
     jiff.logs = options.logs !== false;
 
+    // Parse encryption option. Default is 'AsymmetricKeys'
+    jiff.encryptionType = !options.encryptionType ? 'AsymmetricKeys' : options.encryptionType;
+
     // hooks: TODO
 
     // helpers
@@ -64,6 +67,10 @@ module.exports = {
     var secret_key_map = {};
     jiff.secret_key_map = secret_key_map;
 
+    // { computation_id -> { party_id -> symmetric_key}}
+    var symmetric_key_map = {};
+    jiff.symmetric_key_map = symmetric_key_map;
+
     // { comptuation_id -> { party_id -> [ message1, message2, ... ] } }
     // Every party has a mailbox of messages that are not yet sent to it (in order).
     var mailbox = {};
@@ -237,6 +244,7 @@ module.exports = {
           tmp[party_id] = new Uint8Array(JSON.parse(msg));
           key_map[computation_id] = tmp;
 
+
           // add the server public/secret key to any server side computation instance if needed
           computation_instances_deferred[computation_id].then(function() {
             computation_instances_map[computation_id].secret_key = secret_key_map[computation_id];
@@ -268,6 +276,30 @@ module.exports = {
         });
       });
 
+      socket.on('symmetric_key', function(_) {
+        if(jiff.encryptionType == "SymmetricKey") {
+          jiff.sodium_promise.then(function() {
+            var party_id = party_map[socket.id];
+            var computation_id = computation_map[socket.id];
+            var generatedSymmetricKey = jiff.sodium.crypto_aead_xchacha20poly1305_ietf_keygen();
+
+            if(symmetric_key_map[computation_id] == null)
+              symmetric_key_map[computation_id] = {};
+            symmetric_key_map[computation_id][party_id] = generatedSymmetricKey;
+
+            var encryptedSymmetricKey = client.utils.encrypt_and_sign(
+              '[' + generatedSymmetricKey.toString() + ']',
+              key_map[computation_id][party_id],
+              secret_key_map[computation_id],
+              'symmetric_key'
+            );
+            io.to(socket.id).emit('symmetric_key', encryptedSymmetricKey);
+          });
+        } else {
+          //do nothing. public keys should be used.
+        }
+      });
+
       socket.on('disconnect', function() {
         console.log('user disconnected');
       });

From 848d84da131739e4ab7f7178555a01795d087c3c Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Mon, 2 Apr 2018 12:37:29 +0200
Subject: [PATCH 2/6] symmetric key exchange after public key exchange

---
 lib/jiff-client.js | 60 +++++++++++++++++++++++++++++++++-------------
 lib/jiff-server.js | 31 ------------------------
 2 files changed, 44 insertions(+), 47 deletions(-)

diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index fc13f518c..eb2d9fd24 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -1904,6 +1904,14 @@
       jiff.public_key = options.public_key;
     }
 
+    /**
+     * A map from party id to symmetric key. Where key is the party id (number),
+     * and value is the symmetric key (Uint8Array).
+     *
+     * { party_id -> [Symmetric Key] }
+     */
+    jiff.symmetric_key_map = options.symmetric_key_map ? options.symmetric_key_map : {};
+
     if(options.party_count != null)
       /**
        * Total party count in the computation, parties will take ids between 1 to party_count (inclusive).
@@ -2442,18 +2450,35 @@
         jiff.keymap = JSON.parse(msg);
 
         for(var i in jiff.keymap)
-          if(jiff.keymap.hasOwnProperty(i))
+          if(jiff.keymap.hasOwnProperty(i)) {
             jiff.keymap[i] = new Uint8Array(JSON.parse(jiff.keymap[i]));
 
+            // BEGIN generate symmetric keys.
+            // Generate symmetric keys for other parties in the computation.
+            // Members with lower party id generate the key for the higher.
+            if(!jiff.symmetric_key_map[i] && i > jiff.id) {
+              // generate the key
+              jiff.symmetric_key_map[i] = sodium.crypto_aead_xchacha20poly1305_ietf_keygen();
+              // encrypt the key with the receiver's public key
+              var encryptedSymmetricKey = jiff.hooks.encryptSign(
+                '[' + jiff.symmetric_key_map[i] + ']',
+                jiff.keymap[i],
+                jiff.secret_key,
+                'symmetric_key'
+              );
+              // sending the key as a 'share' emit
+              var encryptedSymmetricKeyMessage = { party_id: i, symmetric_key: encryptedSymmetricKey, symmetric_key_msg:true };
+              jiff.socket.safe_emit('share', JSON.stringify(encryptedSymmetricKeyMessage));
+            }
+            // END generate symmetric keys.
+          }
+
         // Resolve any pending waits that have satisfied conditions
         jiff.execute_wait_callbacks();
 
         // Check if all keys have been received
         if(jiff.keymap["s1"] == null) return;
 
-        // request symmetric key
-        jiff.socket.emit('symmetric_key');
-
         // Check if all keys have been received
         for(var i = 1; i <= jiff.party_count; i++)
           if(jiff.keymap[i] == null) return;
@@ -2467,17 +2492,6 @@
       });
     });
 
-    jiff.socket.on('symmetric_key', function(msg) {
-      var decryptedSymmetricKey = jiff.hooks.decryptSign(
-        msg,
-        jiff.secret_key,
-        jiff.keymap["s1"],
-        'symmetric_key'
-      );
-
-      jiff.serversSymmetricKey = new Uint8Array(JSON.parse(decryptedSymmetricKey));
-    });
-
     // Store sharing and shares counter which keeps track of the count of
     // sharing operations (share and open) and the total number of shares
     // respectively (used to get a unique id for each share operation and
@@ -2574,7 +2588,21 @@
       var op_id = json_msg["op_id"];
       var share = json_msg["share"];
 
-      receive_share(jiff, sender_id, share, op_id);
+      // If it's a symmetric key, add it to the map, else receive_share
+      if(json_msg.symmetric_key_msg) {
+        var decryptedSymmetricKey = jiff.hooks.decryptSign(
+          json_msg.symmetric_key,
+          jiff.secret_key,
+          jiff.keymap[sender_id],
+          'symmetric_key'
+        );
+  
+        jiff.symmetric_key_map[sender_id] = new Uint8Array(JSON.parse(decryptedSymmetricKey));
+        console.log("Symmetric Key Map:");
+        console.log(jiff.symmetric_key_map);
+      }
+      else
+        receive_share(jiff, sender_id, share, op_id);
     });
 
     jiff.socket.on('open', function(msg, callback) {
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index 0a326d466..fdbf30209 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -17,9 +17,6 @@ module.exports = {
     if(options == null) options = {};
     jiff.logs = options.logs !== false;
 
-    // Parse encryption option. Default is 'AsymmetricKeys'
-    jiff.encryptionType = !options.encryptionType ? 'AsymmetricKeys' : options.encryptionType;
-
     // hooks: TODO
 
     // helpers
@@ -67,10 +64,6 @@ module.exports = {
     var secret_key_map = {};
     jiff.secret_key_map = secret_key_map;
 
-    // { computation_id -> { party_id -> symmetric_key}}
-    var symmetric_key_map = {};
-    jiff.symmetric_key_map = symmetric_key_map;
-
     // { comptuation_id -> { party_id -> [ message1, message2, ... ] } }
     // Every party has a mailbox of messages that are not yet sent to it (in order).
     var mailbox = {};
@@ -276,30 +269,6 @@ module.exports = {
         });
       });
 
-      socket.on('symmetric_key', function(_) {
-        if(jiff.encryptionType == "SymmetricKey") {
-          jiff.sodium_promise.then(function() {
-            var party_id = party_map[socket.id];
-            var computation_id = computation_map[socket.id];
-            var generatedSymmetricKey = jiff.sodium.crypto_aead_xchacha20poly1305_ietf_keygen();
-
-            if(symmetric_key_map[computation_id] == null)
-              symmetric_key_map[computation_id] = {};
-            symmetric_key_map[computation_id][party_id] = generatedSymmetricKey;
-
-            var encryptedSymmetricKey = client.utils.encrypt_and_sign(
-              '[' + generatedSymmetricKey.toString() + ']',
-              key_map[computation_id][party_id],
-              secret_key_map[computation_id],
-              'symmetric_key'
-            );
-            io.to(socket.id).emit('symmetric_key', encryptedSymmetricKey);
-          });
-        } else {
-          //do nothing. public keys should be used.
-        }
-      });
-
       socket.on('disconnect', function() {
         console.log('user disconnected');
       });

From e52e0c6b219a0ea8a797f1ad905f39181398c3da Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Tue, 3 Apr 2018 09:00:22 +0200
Subject: [PATCH 3/6] integration of symmetric key encryption done. tested on
 /demos/sum/client.html

---
 demos/sum/client.html |  2 +-
 lib/jiff-client.js    | 88 ++++++++++++++++++++++++++++++++-----------
 2 files changed, 67 insertions(+), 23 deletions(-)

diff --git a/demos/sum/client.html b/demos/sum/client.html
index 0ca8c1805..545832371 100644
--- a/demos/sum/client.html
+++ b/demos/sum/client.html
@@ -22,7 +22,7 @@
           $("#output").append("<p class='error'>Party count must be a valid number!</p>");
           $('#connectButton').prop('disabled', false);
         } else {
-          var options = { party_count: party_count};
+          var options = { party_count: party_count, encryption_type: 'symmetric_key'};
           options.onError = function(error) { $("#output").append("<p class='error'>"+error+"</p>"); };
           options.onConnect = function() { $("#sumButton").attr("disabled", false); $("#output").append("<p>All parties Connected!</p>"); };
           
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index eb2d9fd24..175c54ed0 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -112,14 +112,18 @@
 
   /**
    * Encrypts a message with a symmetric key and adds a tag for validation (using crypto_aead_xchacha20poly1305_ietf_encrypt).
+   * The function will execute message.toString(10) internally to ensure type of message is a string before encrypting.
    * @memberof jiff.utils
    * @instance
    * @param {number/String} message - the message to encrypt.
    * @param {Uint8Array/Array/String} symmetric_key - the symmetric key to be used for encryption.
    * @returns {object} - the signed cipher. {cipher:<cipher>,nonce:<nonce>}
    */
-  function symmetric_key_encrypt(message, symmetric_key) {
+  function symmetric_key_encrypt(message, symmetric_key, operation_type) {
+    if(operation_type == 'share' || operation_type == 'open') message = message.toString(10);
     var generatedNonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+
+    // parsing the inputs to make sure they're Uint8Array
     try {
       symmetric_key = symmetric_key instanceof Uint8Array ? symmetric_key :
                       symmetric_key instanceof Array ? new Uint8Array(symmetric_key) :
@@ -142,6 +146,7 @@
 
   /**
    * Decrypts a message with a symmetric key and verifies it (using crypto_aead_xchacha20poly1305_ietf_decrypt).
+   * The function will execute parseInt internally to ensure that the returned value is a number.
    * @memberof jiff.utils
    * @instance
    * @param {Uint8Array/Array/String} ciphertext - the ciphertext to decrypt.
@@ -149,7 +154,8 @@
    * @param {Uint8Array/Array/String} nonce - the nonce used to decrypt with.
    * @returns {number/string} the decrypted message.
    */
-  function symmetric_key_decrypt(ciphertext, symmetric_key, nonce) {
+  function symmetric_key_decrypt(ciphertext, symmetric_key, nonce, operation_type) {
+    // parsing the inputs to make sure they're Uint8Array
     try {
       ciphertext = ciphertext instanceof Uint8Array ? ciphertext :
                    ciphertext instanceof Array ? new Uint8Array(ciphertext) :
@@ -166,15 +172,20 @@
       return;
     }
 
-    var decryptedText = sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(
-      null,
-      ciphertext,
-      null,
-      nonce,
-      symmetric_key //symmetric_key_map[computation_id][party_id]
-    );
-
-    return decryptedText;
+    try {
+      var decryptedData = sodium.to_string(sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(
+        null,
+        ciphertext,
+        null,
+        nonce,
+        symmetric_key
+      ));
+      decryptedData = (operation_type == 'share' || operation_type == 'open') ? parseInt(decryptedData, 10) : decryptedData;
+      return decryptedData;
+
+    } catch(_) {
+      throw "Error decrypting symmetric key encrypted data. Might be a bad signature or nonce.";
+    }
   }
 
   /**
@@ -238,8 +249,13 @@
         if(p_id == jiff.id) continue;
 
         // send encrypted and signed shares_id[p_id] to party p_id
-        var cipher_share = jiff.hooks.encryptSign(shares[p_id], jiff.keymap[p_id], jiff.secret_key, 'share');
-        var msg = { party_id: p_id, share: cipher_share, op_id: share_id };
+        var cipher_share
+        switch(jiff.encryption_type) {
+          case 'none': cipher_share = jiff.hooks.encryptSign(shares[p_id], jiff.keymap[p_id], jiff.secret_key, 'share'); break; // TODO
+          case 'asymmetric_keys': cipher_share = jiff.hooks.encryptSign(shares[p_id], jiff.keymap[p_id], jiff.secret_key, 'share'); break;
+          case 'symmetric_key': cipher_share = jiff.hooks.symmetricEncrypt(shares[p_id], jiff.symmetric_key_map[p_id], 'share'); break;
+        }
+        var msg = { party_id: p_id, share: cipher_share, op_id: share_id, encryption_type: jiff.encryption_type };
         jiff.socket.safe_emit('share', JSON.stringify(msg));
       }
     }
@@ -333,11 +349,16 @@
    *                         is the same as receiver, then it is
    *                         an unencrypted number.
    * @param {number} op_id - the id of the share operation.
+   * @param {string} message_encryption_type - the method of encryption used.
    *
    */
-  function receive_share(jiff, sender_id, share, op_id) {
+  function receive_share(jiff, sender_id, share, op_id, message_encryption_type) {
     // Decrypt share
-    share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'share');
+    switch (message_encryption_type) {
+      case 'none': share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'share'); break; // TODO
+      case 'asymmetric_keys': share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'share'); break;
+      case 'symmetric_key': share = jiff.hooks.symmetricDecrypt(share.cipher, jiff.symmetric_key_map[sender_id], share.nonce, 'share'); break;
+    }
 
     // Call hook
     share = jiff.execute_array_hooks('receiveShare', [jiff, sender_id, share], 2);
@@ -500,8 +521,13 @@
       if(i == jiff.id) { receive_open(jiff, i, share.value, op_ids[i], share.Zp); continue; }
 
       // encrypt, sign and send
-      var cipher_share = jiff.hooks.encryptSign(share.value, jiff.keymap[i], jiff.secret_key, 'open');
-      var msg = { party_id: i, share: cipher_share, op_id: op_ids[i], Zp: share.Zp };
+      var cipher_share
+      switch(jiff.encryption_type) {
+        case 'none': cipher_share = jiff.hooks.encryptSign(share.value, jiff.keymap[i], jiff.secret_key, 'open'); break; // TODO
+        case 'asymmetric_keys': cipher_share = jiff.hooks.encryptSign(share.value, jiff.keymap[i], jiff.secret_key, 'open'); break;
+        case 'symmetric_key': cipher_share = jiff.hooks.symmetricEncrypt(share.value, jiff.symmetric_key_map[i], 'open'); break;
+      }
+      var msg = { party_id: i, share: cipher_share, op_id: op_ids[i], Zp: share.Zp, encryption_type: jiff.encryption_type };
       jiff.socket.safe_emit('open', JSON.stringify(msg));
     }
   }
@@ -515,11 +541,16 @@
    *                         an unencrypted number..
    * @param {number} op_id - the id of the share operation.
    * @param {number} Zp - the modulos.
+   * @param {string} message_encryption_type - the method of encryption used.
    */
-  function receive_open(jiff, sender_id, share, op_id, Zp) {
+  function receive_open(jiff, sender_id, share, op_id, Zp, message_encryption_type) {
     // Decrypt share
     if(sender_id != jiff.id)
-      share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'open');
+      switch(message_encryption_type) {
+        case 'none': share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'open'); break; //TODO
+        case 'asymmetric_keys': share = jiff.hooks.decryptSign(share, jiff.secret_key, jiff.keymap[sender_id], 'open'); break;
+        case 'symmetric_key':  share = jiff.hooks.symmetricDecrypt(share.cipher, jiff.symmetric_key_map[sender_id], share.nonce, 'open'); break;
+      }
 
     // call hook
     share = jiff.execute_array_hooks('receiveOpen', [jiff, sender_id, share, Zp], 2);
@@ -1187,7 +1218,7 @@
       if(self.ready && o.ready) // both shares are ready
         return self.jiff.secret_share(self.jiff, true, null, ready_sub(), self.holders, max(self.threshold, o.threshold), self.Zp);
 
-      // promise to execute ready_add when both are ready
+      // promise to execute ready_sub when both are ready
       var promise = self.pick_promise(o).then(ready_sub, self.error);
       return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp);
     };
@@ -1790,6 +1821,17 @@
      */
     jiff.computation_id = computation_id;
 
+    /**
+     * They type of encryption to use.
+     * @member {string} encryption_type
+     * @memberof jiff.jiff-instance
+     * @instance
+     * @enum {('asymmetric_keys', 'symmetric_key', 'none')} The allowed types of encryption.
+     * @default asymmetric_keys
+     */
+    jiff.encryption_type = (['asymmetric_keys', 'symmetric_key', 'none'].indexOf(options.encryption_type) > -1) ?
+                            options.encryption_type : 'asymmetric_keys';
+
     /**
      * Flags whether this instance is capable of starting the computation.
      * In other words, the public keys for all parties and servers are known,
@@ -2587,6 +2629,7 @@
       var sender_id = json_msg["party_id"];
       var op_id = json_msg["op_id"];
       var share = json_msg["share"];
+      var message_encryption_type = json_msg["encryption_type"];
 
       // If it's a symmetric key, add it to the map, else receive_share
       if(json_msg.symmetric_key_msg) {
@@ -2602,7 +2645,7 @@
         console.log(jiff.symmetric_key_map);
       }
       else
-        receive_share(jiff, sender_id, share, op_id);
+        receive_share(jiff, sender_id, share, op_id, message_encryption_type);
     });
 
     jiff.socket.on('open', function(msg, callback) {
@@ -2615,8 +2658,9 @@
       var op_id = json_msg["op_id"];
       var share = json_msg["share"];
       var Zp = json_msg["Zp"];
+      var message_encryption_type = json_msg["encryption_type"];
 
-      receive_open(jiff, sender_id, share, op_id, Zp);
+      receive_open(jiff, sender_id, share, op_id, Zp, message_encryption_type);
     });
 
     // handle custom messages

From fac6bd508ac365aca43bb47391a9ef0065b95b1d Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Tue, 3 Apr 2018 15:16:42 +0200
Subject: [PATCH 4/6] modified check for ready when using symmetric keys

---
 demos/sum/party.js  |  2 +-
 demos/sum/server.js |  2 +-
 lib/jiff-client.js  | 26 +++++++++++++++++++-------
 lib/jiff-server.js  |  1 -
 4 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/demos/sum/party.js b/demos/sum/party.js
index 74dd72836..4f9c0d017 100644
--- a/demos/sum/party.js
+++ b/demos/sum/party.js
@@ -1,6 +1,6 @@
 var jiff_instance;
 
-var options = {party_count: 2};
+var options = {party_count: 2, encryption_type: 'symmetric_key'};
 options.onConnect = function() {
   var shares = jiff_instance.share(3);
   var sum = shares[1];
diff --git a/demos/sum/server.js b/demos/sum/server.js
index a3eda7fc9..f09713178 100644
--- a/demos/sum/server.js
+++ b/demos/sum/server.js
@@ -1,7 +1,7 @@
 var express = require('express');
 var app = express();
 var http = require('http').Server(app);
-var jiff_instance = require('../../lib/jiff-server').make_jiff(http, {logs:true, encryptionType:'SymmetricKey'});
+var jiff_instance = require('../../lib/jiff-server').make_jiff(http, {logs:true});
 
 // Define a computation with id '1' and a maximum of 3 participants.
 jiff_instance.totalparty_map['1'] = 3;
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 175c54ed0..984038ea6 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -127,7 +127,7 @@
     try {
       symmetric_key = symmetric_key instanceof Uint8Array ? symmetric_key :
                       symmetric_key instanceof Array ? new Uint8Array(symmetric_key) :
-                      new Uint8Array(JSON.parse(symmbetric_key))
+                      new Uint8Array(JSON.parse(symmetric_key))
     } catch(e) {
       console.error('error parsing symmetric key');
       console.error(e);
@@ -247,7 +247,6 @@
       for(var i = 0; i < receivers_list.length; i++) {
         var p_id = receivers_list[i];
         if(p_id == jiff.id) continue;
-
         // send encrypted and signed shares_id[p_id] to party p_id
         var cipher_share
         switch(jiff.encryption_type) {
@@ -2498,7 +2497,7 @@
             // BEGIN generate symmetric keys.
             // Generate symmetric keys for other parties in the computation.
             // Members with lower party id generate the key for the higher.
-            if(!jiff.symmetric_key_map[i] && i > jiff.id) {
+            if(jiff.encryption_type == 'symmetric_key' && !jiff.symmetric_key_map[i] && i > jiff.id) {
               // generate the key
               jiff.symmetric_key_map[i] = sodium.crypto_aead_xchacha20poly1305_ietf_keygen();
               // encrypt the key with the receiver's public key
@@ -2520,8 +2519,11 @@
 
         // Check if all keys have been received
         if(jiff.keymap["s1"] == null) return;
-
-        // Check if all keys have been received
+        if(jiff.encryption_type == 'symmetric_key')
+          for(var i = 1; i < jiff.party_count; i++) {
+            if(i == jiff.id) continue;
+            if(jiff.symmetric_key_map[i] == null) return;
+          }
         for(var i = 1; i <= jiff.party_count; i++)
           if(jiff.keymap[i] == null) return;
 
@@ -2641,8 +2643,18 @@
         );
   
         jiff.symmetric_key_map[sender_id] = new Uint8Array(JSON.parse(decryptedSymmetricKey));
-        console.log("Symmetric Key Map:");
-        console.log(jiff.symmetric_key_map);
+
+        // check whether ready.
+        if(jiff.keymap["s1"] == null) return;
+        for(var i = 1; i < jiff.party_count; i++) {
+          if(i == jiff.id) continue;
+          if(jiff.symmetric_key_map[i] == null) return;
+        }
+        if(jiff.__ready !== true) {
+          jiff.__ready = true;
+          if(options.onConnect != null)
+            options.onConnect(jiff);
+        }
       }
       else
         receive_share(jiff, sender_id, share, op_id, message_encryption_type);
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index fdbf30209..bb1eb64a4 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -237,7 +237,6 @@ module.exports = {
           tmp[party_id] = new Uint8Array(JSON.parse(msg));
           key_map[computation_id] = tmp;
 
-
           // add the server public/secret key to any server side computation instance if needed
           computation_instances_deferred[computation_id].then(function() {
             computation_instances_map[computation_id].secret_key = secret_key_map[computation_id];

From bad03d99ff242a95b1ab9ba187cae3722eee91c7 Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Tue, 3 Apr 2018 17:45:56 +0200
Subject: [PATCH 5/6] presentation and logs

---
 demos/sum-presentation/client.html | 155 +++++++++++++++++++++++++++++
 demos/sum-presentation/server.js   |  14 +++
 lib/jiff-client.js                 |  44 +++++++-
 3 files changed, 210 insertions(+), 3 deletions(-)
 create mode 100644 demos/sum-presentation/client.html
 create mode 100644 demos/sum-presentation/server.js

diff --git a/demos/sum-presentation/client.html b/demos/sum-presentation/client.html
new file mode 100644
index 000000000..6f7a12e22
--- /dev/null
+++ b/demos/sum-presentation/client.html
@@ -0,0 +1,155 @@
+<html>
+    <head>
+        <title>Presentation</title>
+        <style>
+            body {
+                font-family:'Lucida Sans', 'Lucida Sans Regular', 'Lucida Grande', 'Lucida Sans Unicode', Geneva, Verdana, sans-serif;
+            }
+            .scrollbox {
+                height:650px;
+                width:500px;
+                border:1px solid #CCCCCC;
+                overflow:auto;
+                resize:both;
+                display:inline-block;
+            }
+            .i {
+                display:inline-block;
+                vertical-align: top;
+                width:300px;
+            }
+            .values {
+                vertical-align: top;
+                display:inline-block;
+            }
+            .inline {
+                display:inline-block;
+            }
+            .error {
+                color: #FF0000;
+            }
+        </style>
+        <script src="https://code.jquery.com/jquery-1.11.1.js"></script>
+        <script src="/socket.io/socket.io.js"></script>
+        <script src="/lib/sodium.js"></script>
+        <script src="/lib/jiff-client.js"></script>
+        <script type="text/javascript">
+        var jiff_instance;
+
+        function connect() {
+            $('#connectButton').prop('disabled', true);
+            var computation_id = $('#computation_id').val();
+            var party_count = parseInt($('#count').val());
+
+            if(isNaN(party_count)) {
+            $("#output").append("<p class='error'>Party count must be a valid number!</p>");
+            $('#connectButton').prop('disabled', false);
+            } else {
+            var options = { party_count: party_count, encryption_type: 'symmetric_key'};
+            options.onError = function(error) { $("#output").append("<p class='error'>"+error+"</p>"); };
+            options.onConnect = function() { $("#sumButton").attr("disabled", false); $("#output").append("<p>All parties Connected!</p>"); };
+            options.logs_box = function(new_line) { $("#logs-box").append("<div>"+new_line+"</div><hr>"); }
+            options.public_keys_display = function(keys) {
+                var pkp = "";
+                for(var i in keys) {
+                    pkp += "(" + i + ") [";
+                    for(var j = 0; j < keys[i].length; ++j)
+                        pkp += keys[i][j] + ", ";
+                    pkp += "]<br/><hr>";
+                }
+                $("#public-keys").html(pkp);
+            }
+            options.symmetric_keys_display = function(keys) {
+                var skp = "";
+                for(var i in keys) {
+                    skp += "(" + i + ") [";
+                    for(var j = 0; j < keys[i].length; ++j)
+                        skp += keys[i][j] +", ";
+                    skp += "]<br/><hr>";
+                }
+                $("#symmetric-keys").html(skp);
+            }
+            options.id_display = function(id) { $("#jiff_id").html("Party ID: " + id); }
+            options.public_key_display = function(key){ $("#public_key").html("Public Key: [" + key + "]."); }
+            options.secret_key_display = function(key){ $("#secret_key").html("Secret Key: [" + key + "]."); }
+            options.socket_id_display = function(key){ $("#socket_id").html("Socket ID: [" + key + "]."); }
+
+            var hostname = window.location.hostname.trim();
+            var port = window.location.port;
+            if(port == null || port == '') 
+                port = "80";
+            if(!(hostname.startsWith("http://") || hostname.startsWith("https://")))
+                hostname = "http://" + hostname;
+            if(hostname.endsWith("/"))
+                hostname = hostname.substring(0, hostname.length-1);
+            if(hostname.indexOf(":") > -1)
+                hostanme = hostname.substring(0, hostname.indexOf(":"));
+    
+            hostname = hostname + ":" + port;
+            jiff_instance = jiff.make_jiff(hostname, computation_id, options);
+            }
+        }
+
+        function sum() {
+            var input = parseInt($("#number").val());
+
+            if(isNaN(input))
+            $("#output").append("<p class='error'>Input a valid number!</p>");
+            else if(100 < input || input < 0 || input != Math.floor(input))
+            $("#output").append("<p class='error'>Input a WHOLE number between 0 and 100!</p>");
+            else if(jiff_instance == null || !jiff_instance.isReady())
+            alert("Please wait!");
+            else
+            MPC(input);
+        }
+
+        function MPC(input) {
+            $("#sumButton").attr("disabled", true);
+            $("#output").append("<p>Starting...</p>");
+            var shares = jiff_instance.share(input);
+            
+            var sum = shares[1];
+            for(var i = 2; i <= jiff_instance.party_count; i++)
+            sum = sum.sadd(shares[i]);
+            
+            sum.open(handleResult);          
+        }
+
+        function handleResult(result) {
+            $("#output").append("<p>Result is: " + result + "</p>");
+            $("#sumButton").attr("disabled", false);
+        }
+        </script>
+    </head>
+    <body>
+        <h1>Presentation</h1>
+        <p>This is a sum demo that tries to present what is happening under the hood.</p>
+        <label for="computation_id">Computation ID</label><input id="computation_id" value="test-sum"></input><br/><br/>
+        <label for="count">Party Count<label> <input id="count" pattern="[0-9]*"> &nbsp; <button id="connectButton" onclick="connect();">Connect</button><br/><br/>
+        <hr/>
+        <h1>Sum Numbers under MPC</h1>
+        <label for="number">Input Number (between 0 and 100)</label> <input id="number" pattern="[0-9]+"> &nbsp; <button onclick="sum();" disabled="disabled" id="sumButton">Sum</button><br/>
+        <div id="output"></div><br/>
+        <hr/><br/>
+        <div class="values">
+            <div id="jiff_id">Party ID: </div>
+            <div id="socket_id">Socket ID: </div>
+            <div id="public_key">Public Key: []</div>
+            <div id="secret_key">Secret Key: []</div>
+        </div>
+        <br/><br/><br/>
+        <div>
+            <div class="scrollBox" id="logs-box">
+            </div>
+            <div class="i">
+                <div>Public Keymap</div><br/>
+                <div id="public-keys">...</div>
+            </div>
+            <div class="i">
+                <div>Symmetric Key Map</div><br/>
+                <div id="symmetric-keys">...</div>
+            </div>
+        </div>
+        <br/><br/>
+    </body>
+</html>
diff --git a/demos/sum-presentation/server.js b/demos/sum-presentation/server.js
new file mode 100644
index 000000000..0833709a5
--- /dev/null
+++ b/demos/sum-presentation/server.js
@@ -0,0 +1,14 @@
+var express = require('express');
+var app = express();
+var http = require('http').Server(app);
+var jiff_instance = require('../../lib/jiff-server').make_jiff(http, {logs:true});
+
+// Serve static files.
+app.use("/demos", express.static("demos"));
+app.use("/lib", express.static("lib"));
+app.use("/lib/ext", express.static("lib/ext"));
+http.listen(8080, function() {
+  console.log('listening on *:8080');
+});
+
+console.log("Direct your browser to *:8080/demos/sum-presentation/client.html.");
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 984038ea6..25ead9840 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -1860,6 +1860,7 @@
 
       // Store message in the mailbox until acknowledgment is received
       socket.safe_emit = function(label, msg) {
+        jiff.log("Sending message.<br/>Label: " + label + "<br/>Message: " + msg);
         // add message to mailbox
         var mailbox_pointer = socket.mailbox.add({ "label": label, "msg": msg });
         if(socket.connected)
@@ -2092,12 +2093,17 @@
       // identification
       if(options.__internal_socket == null) {
         jiff.socket.on('connect', function() {
+          jiff.log("Socket connected! Socket id: " + jiff.socket.id + ". Sending 'computation_id' emit to server.<br/>id: " + computation_id + "<br/>party_id: " + jiff.id + "<br/>party_count: " + jiff.party_count);
+          if(jiff.socket_id_display)
+            jiff.socket_id_display(jiff.socket.id);
           jiff.socket.emit("computation_id", JSON.stringify({ "computation_id": computation_id, "party_id": jiff.id, "party_count": jiff.party_count }));
         });
         jiff.socket.connect();
       }
-      else
+      else {
+        jiff.log("Sending 'computation_id' emit to server.<br/>id: " + computation_id + "<br/>party_id: " + jiff.id + "<br/>party_count: " + jiff.party_count);
         jiff.socket.emit("computation_id", JSON.stringify({ "computation_id": computation_id, "party_id": jiff.id, "party_count": jiff.party_count }));
+      }
     }
     if(!(options.autoConnect === false)) jiff.connect();
 
@@ -2463,9 +2469,14 @@
     // Store the id when server sends it back
     jiff.socket.on('init', function(msg) {
       sodium_promise.then(function() {
+        jiff.log("Received 'init' emit from server.");
         msg = JSON.parse(msg);
-        if(jiff.id == null)
+        if(jiff.id == null) {
           jiff.id = msg.party_id;
+          jiff.log("Our party_id is now = " + jiff.id);
+          if(jiff.id_display)
+            jiff.id_display(jiff.id);
+        }
 
         if(jiff.party_count == null)
           jiff.party_count = msg.party_count;
@@ -2475,8 +2486,14 @@
           var genkey = sodium.crypto_box_keypair();
           jiff.secret_key = genkey.privateKey;
           jiff.public_key = genkey.publicKey;
+          jiff.log("Keypair generated!<br/>Public key = [" + jiff.public_key.toString() + "]. Private key = [" + jiff.secret_key.toString() + "].")
+          if(jiff.public_key_display)
+            jiff.public_key_display(jiff.public_key.toString());
+          if(jiff.secret_key_display)
+            jiff.secret_key_display(jiff.secret_key.toString());
         }
 
+        jiff.log("Sending 'public_key' emit to server.<br/> Public key: [" + jiff.public_key.toString() + "].")
         jiff.socket.emit("public_key", '['+jiff.public_key.toString()+']');
         // Now: (1) this party is connect (2) server (and other parties) know this public key
         // Resend all pending messages
@@ -2488,11 +2505,14 @@
 
     jiff.socket.on('public_key', function(msg) {
       sodium_promise.then(function() {
+        jiff.log("Public key emit received.");
         jiff.keymap = JSON.parse(msg);
 
         for(var i in jiff.keymap)
           if(jiff.keymap.hasOwnProperty(i)) {
             jiff.keymap[i] = new Uint8Array(JSON.parse(jiff.keymap[i]));
+            if(jiff.public_keys_display)
+              jiff.public_keys_display(jiff.keymap);
 
             // BEGIN generate symmetric keys.
             // Generate symmetric keys for other parties in the computation.
@@ -2500,6 +2520,10 @@
             if(jiff.encryption_type == 'symmetric_key' && !jiff.symmetric_key_map[i] && i > jiff.id) {
               // generate the key
               jiff.symmetric_key_map[i] = sodium.crypto_aead_xchacha20poly1305_ietf_keygen();
+              if(jiff.symmetric_keys_display)
+                jiff.symmetric_keys_display(jiff.symmetric_key_map);
+              
+              jiff.log("Generated symmetric key for (" + i + ") = [" + jiff.symmetric_key_map[i].toString() + "].");
               // encrypt the key with the receiver's public key
               var encryptedSymmetricKey = jiff.hooks.encryptSign(
                 '[' + jiff.symmetric_key_map[i] + ']',
@@ -2616,6 +2640,17 @@
 
     // For logging / debugging
     jiff.logs = [];
+    jiff.logs_box = options.logs_box;
+    jiff.log = function(log_line) {
+      jiff.logs.push(log_line);
+      if(jiff.logs_box) jiff.logs_box(log_line);
+    }
+    jiff.public_keys_display = options.public_keys_display;
+    jiff.symmetric_keys_display = options.symmetric_keys_display;
+    jiff.id_display = options.id_display;
+    jiff.public_key_display = options.public_key_display;
+    jiff.secret_key_display = options.secret_key_display;
+    jiff.socket_id_display = options.socket_id_display;
 
     // Store a map from a sharing id (which share operation) to the
     // corresponding deferred and shares array.
@@ -2632,6 +2667,7 @@
       var op_id = json_msg["op_id"];
       var share = json_msg["share"];
       var message_encryption_type = json_msg["encryption_type"];
+      jiff.log("Received 'share' emit from " + sender_id + ", share (object): " + share + ", op_id: " + op_id); console.log(share);
 
       // If it's a symmetric key, add it to the map, else receive_share
       if(json_msg.symmetric_key_msg) {
@@ -2641,8 +2677,9 @@
           jiff.keymap[sender_id],
           'symmetric_key'
         );
-  
         jiff.symmetric_key_map[sender_id] = new Uint8Array(JSON.parse(decryptedSymmetricKey));
+        if(jiff.symmetric_keys_display)
+          jiff.symmetric_keys_display(jiff.symmetric_key_map);
 
         // check whether ready.
         if(jiff.keymap["s1"] == null) return;
@@ -2671,6 +2708,7 @@
       var share = json_msg["share"];
       var Zp = json_msg["Zp"];
       var message_encryption_type = json_msg["encryption_type"];
+      jiff.log("Received 'open' emit from " + sender_id + ", share (object): " + share + ", op_id: " + op_id + ", zp: " + Zp);
 
       receive_open(jiff, sender_id, share, op_id, Zp, message_encryption_type);
     });

From 901fa503bfdd7a4a680ec71228b970afaf11e40e Mon Sep 17 00:00:00 2001
From: 842Mono <842mono@gmail.com>
Date: Fri, 27 Apr 2018 18:04:16 -0400
Subject: [PATCH 6/6] bug fix and concept fix

---
 lib/jiff-client.js | 63 ++++++++++++++++++++++++----------------------
 lib/jiff-server.js | 16 ++++++++++++
 2 files changed, 49 insertions(+), 30 deletions(-)

diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 25ead9840..b2311f359 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -2101,7 +2101,6 @@
         jiff.socket.connect();
       }
       else {
-        jiff.log("Sending 'computation_id' emit to server.<br/>id: " + computation_id + "<br/>party_id: " + jiff.id + "<br/>party_count: " + jiff.party_count);
         jiff.socket.emit("computation_id", JSON.stringify({ "computation_id": computation_id, "party_id": jiff.id, "party_count": jiff.party_count }));
       }
     }
@@ -2532,8 +2531,8 @@
                 'symmetric_key'
               );
               // sending the key as a 'share' emit
-              var encryptedSymmetricKeyMessage = { party_id: i, symmetric_key: encryptedSymmetricKey, symmetric_key_msg:true };
-              jiff.socket.safe_emit('share', JSON.stringify(encryptedSymmetricKeyMessage));
+              var encryptedSymmetricKeyMessage = { party_id: i, symmetric_key: encryptedSymmetricKey};
+              jiff.socket.safe_emit('symmetric_key', JSON.stringify(encryptedSymmetricKeyMessage));
             }
             // END generate symmetric keys.
           }
@@ -2667,34 +2666,38 @@
       var op_id = json_msg["op_id"];
       var share = json_msg["share"];
       var message_encryption_type = json_msg["encryption_type"];
-      jiff.log("Received 'share' emit from " + sender_id + ", share (object): " + share + ", op_id: " + op_id); console.log(share);
-
-      // If it's a symmetric key, add it to the map, else receive_share
-      if(json_msg.symmetric_key_msg) {
-        var decryptedSymmetricKey = jiff.hooks.decryptSign(
-          json_msg.symmetric_key,
-          jiff.secret_key,
-          jiff.keymap[sender_id],
-          'symmetric_key'
-        );
-        jiff.symmetric_key_map[sender_id] = new Uint8Array(JSON.parse(decryptedSymmetricKey));
-        if(jiff.symmetric_keys_display)
-          jiff.symmetric_keys_display(jiff.symmetric_key_map);
-
-        // check whether ready.
-        if(jiff.keymap["s1"] == null) return;
-        for(var i = 1; i < jiff.party_count; i++) {
-          if(i == jiff.id) continue;
-          if(jiff.symmetric_key_map[i] == null) return;
-        }
-        if(jiff.__ready !== true) {
-          jiff.__ready = true;
-          if(options.onConnect != null)
-            options.onConnect(jiff);
-        }
+      jiff.log("Received 'share' emit from " + sender_id + ", share (object): " + share + ", op_id: " + op_id);
+
+      receive_share(jiff, sender_id, share, op_id, message_encryption_type);
+    });
+
+    jiff.socket.on('symmetric_key', function(msg, callback) {
+      callback(true);
+
+      var json_msg = JSON.parse(msg);
+      var sender_id = json_msg["party_id"];
+
+      var decryptedSymmetricKey = jiff.hooks.decryptSign(
+        json_msg.symmetric_key,
+        jiff.secret_key,
+        jiff.keymap[sender_id],
+        'symmetric_key'
+      );
+      jiff.symmetric_key_map[sender_id] = new Uint8Array(JSON.parse(decryptedSymmetricKey));
+      if(jiff.symmetric_keys_display)
+        jiff.symmetric_keys_display(jiff.symmetric_key_map);
+
+      // check whether ready.
+      if(jiff.keymap["s1"] == null) return;
+      for(var i = 1; i < jiff.party_count; i++) {
+        if(i == jiff.id) continue;
+        if(jiff.symmetric_key_map[i] == null) return;
+      }
+      if(jiff.__ready !== true) {
+        jiff.__ready = true;
+        if(options.onConnect != null)
+          options.onConnect(jiff);
       }
-      else
-        receive_share(jiff, sender_id, share, op_id, message_encryption_type);
     });
 
     jiff.socket.on('open', function(msg, callback) {
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index bb1eb64a4..1788c2454 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -310,6 +310,22 @@ module.exports = {
           jiff.safe_emit('open', JSON.stringify(json_msg), computation_id, to_id);
       });
 
+      socket.on('symmetric_key', function(msg, callback) {
+        callback(true);
+
+        var computation_id = computation_map[socket.id];
+        var from_id = party_map[socket.id];
+
+        var json_msg = JSON.parse(msg);
+        var to_id = json_msg["party_id"];
+        json_msg["party_id"] = from_id;
+
+        if(to_id == 's1')
+          computation_instances_deferred[computation_id].then(function() { computation_instances_map[computation_id].socket.receive('share', JSON.stringify(json_msg)); });
+        else
+          jiff.safe_emit('symmetric_key', JSON.stringify(json_msg), computation_id, to_id);
+      });
+
       socket.on('custom', function(msg, callback) {
         callback(true); // send ack to client