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/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/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/lib/jiff-client.js b/lib/jiff-client.js
index f589ac724..b2311f359 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -110,6 +110,84 @@
     }
   }
 
+  /**
+   * 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, 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) :
+                      new Uint8Array(JSON.parse(symmetric_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).
+   * 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.
+   * @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, operation_type) {
+    // parsing the inputs to make sure they're Uint8Array
+    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;
+    }
+
+    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.";
+    }
+  }
+
   /**
    * Share given secret to the participating parties.
    * @param {jiff-instance} jiff - the jiff instance.
@@ -169,10 +247,14 @@
       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 = 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));
       }
     }
@@ -266,11 +348,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);
@@ -433,8 +520,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));
     }
   }
@@ -448,11 +540,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);
@@ -1120,7 +1217,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);
     };
@@ -1723,6 +1820,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,
@@ -1752,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)
@@ -1837,6 +1946,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).
@@ -1874,6 +1991,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.
@@ -1974,12 +2093,16 @@
       // 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.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();
 
@@ -2345,9 +2468,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;
@@ -2357,8 +2485,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
@@ -2370,17 +2504,49 @@
 
     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))
+          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.
+            // Members with lower party id generate the key for the higher.
+            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] + ']',
+                jiff.keymap[i],
+                jiff.secret_key,
+                'symmetric_key'
+              );
+              // sending the key as a 'share' emit
+              var encryptedSymmetricKeyMessage = { party_id: i, symmetric_key: encryptedSymmetricKey};
+              jiff.socket.safe_emit('symmetric_key', 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;
+        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;
 
@@ -2473,6 +2639,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.
@@ -2488,8 +2665,39 @@
       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"];
+      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);
+    });
 
-      receive_share(jiff, sender_id, share, op_id);
+    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);
+      }
     });
 
     jiff.socket.on('open', function(msg, callback) {
@@ -2502,8 +2710,10 @@
       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"];
+      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);
+      receive_open(jiff, sender_id, share, op_id, Zp, message_encryption_type);
     });
 
     // handle custom messages
@@ -2571,6 +2781,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..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
 
