nino

.gitignore

@@ -1,22 +1,8 @@
-# IDE junk files
-.idea/*
-*.pyc
-*~
-#*#
-tmp*
-ec2/logs/*
-ec2/logs_old/*
-ec2/hosts
-*_keys
-*.keys
-
-# Unit test / coverage reports
-.cache
+logs/
+*__pycache__*
 .coverage
-.coverage.*
-coverage.xml
-htmlcov/
-.pytest_cache
-
-# Sphinx documentation
 docs/_build/
+*.pyc
+important_logs/
+backup_tests/
+our_srcs/__pycache__/

Dockerfile

@@ -11,7 +11,7 @@ ENV B 16
 
 RUN apt-get update && apt-get -y install bison flex libgmp-dev libmpc-dev
 
-RUN wget https://crypto.stanford.edu/pbc/files/pbc-0.5.14.tar.gz
+RUN wget --no-check-certificate https://crypto.stanford.edu/pbc/files/pbc-0.5.14.tar.gz
 RUN tar -xvf pbc-0.5.14.tar.gz
 RUN cd pbc-0.5.14 && ./configure && make && make install
 

README.md

@@ -59,3 +59,10 @@ If the above went all well, you should be setup for developing
 ## License
 This is released under the CRAPL academic license. See ./CRAPL-LICENSE.txt
 Other licenses may be issued at the authors' discretion.
+
+
+### Our added documentation
+# To watch log results being written live
+   ```bash
+   grep -v DEBUG logs/`ls -t logs | head -n 1`   
+   ```

experiments/honest_party_test_EC2.py

@@ -1,6 +1,6 @@
 #!/usr/bin/python
 __author__ = 'aluex'
-from gevent import monkey
+from gevent import monkey, sleep
 monkey.patch_all()
 
 from gevent.queue import *
@@ -267,7 +267,7 @@ def toBeScheduled():
             finally:
                 print "Consensus Finished"
 
-        s = sched.scheduler(time.time, time.sleep)
+        s = sched.scheduler(time.time, sleep)
 
         time_now = time.time()
         delay = options.delaytime - time_now

experiments/run_local_tor.py

@@ -1,6 +1,7 @@
 __author__ = 'aluex'
 
 import subprocess32 as subprocess
+from gevent import sleep
 import time
 def runOnTransaction(N, t, Tx):
     retry = True
@@ -15,7 +16,7 @@ def runOnTransaction(N, t, Tx):
             retry = False
         except subprocess.TimeoutExpired:
             retry = True
-            time.sleep(2)
+            sleep(2)
     q = subprocess.check_output(['python', 'process.py', 'msglog.TorMultiple'])
     print N, t, Tx, q.replace('\n', ' ')
 

honeybadgerbft/core/binaryagreement.py

@@ -1,3 +1,5 @@
+from gevent import monkey
+monkey.patch_all()
 import gevent
 from gevent.event import Event
 

honeybadgerbft/core/commonsubset.py

@@ -1,6 +1,11 @@
+from gevent import monkey
+monkey.patch_all()
 import gevent
 
 
+from our_srcs.consts import *
+from logging import getLogger; logger=getLogger(LOGGER_NAME)
+
 def commonsubset(pid, N, f, rbc_out, aba_in, aba_out):
     """The BKR93 algorithm for asynchronous common subset.
 

honeybadgerbft/core/honeybadger.py

@@ -1,15 +1,20 @@
 from collections import namedtuple
 from enum import Enum
-
+from gevent import monkey
+monkey.patch_all()
 import gevent
 from gevent.queue import Queue
+import hashlib
+import random
 
 from honeybadgerbft.core.commoncoin import shared_coin
 from honeybadgerbft.core.binaryagreement import binaryagreement
 from honeybadgerbft.core.reliablebroadcast import reliablebroadcast
 from honeybadgerbft.core.commonsubset import commonsubset
 from honeybadgerbft.core.honeybadger_block import honeybadger_block
 from honeybadgerbft.exceptions import UnknownTagError
+from our_srcs.consts import *
+from logging import getLogger; logger=getLogger(LOGGER_NAME)
 
 
 class BroadcastTag(Enum):
@@ -43,6 +48,8 @@ def broadcast_receiver_loop(recv_func, recv_queues):
         broadcast_receiver(recv_func, recv_queues)
 
 
+
+
 class HoneyBadgerBFT():
     r"""HoneyBadgerBFT object used to run the protocol.
 
@@ -64,7 +71,7 @@ class HoneyBadgerBFT():
     :param recv:
     """
 
-    def __init__(self, sid, pid, B, N, f, sPK, sSK, ePK, eSK, send, recv):
+    def __init__(self, sid, pid, B, N, f, sPK, sSK, ePK, eSK, send, recv, amount=-1):
         self.sid = sid
         self.pid = pid
         self.B = B
@@ -76,19 +83,28 @@ def __init__(self, sid, pid, B, N, f, sPK, sSK, ePK, eSK, send, recv):
         self.eSK = eSK
         self._send = send
         self._recv = recv
+        self.amount = amount
 
         self.round = 0  # Current block number
         self.transaction_buffer = []
         self._per_round_recv = {}  # Buffer of incoming messages
+        self.messages_seen = set()
+        self.bytes_sent = 0
 
     def submit_tx(self, tx):
         """Appends the given transaction to the transaction buffer.
 
         :param tx: Transaction to append to the buffer.
         """
-        print('submit_tx', self.pid, tx)
         self.transaction_buffer.append(tx)
 
+    def get_bytes_sent(self):
+        """Returns the ammount of non empty messages sent"""
+        return self.bytes_sent
+
+    def _prepare_transaction_buffer(self):
+        pass
+
     def run(self):
         """Run the HoneyBadgerBFT protocol."""
 
@@ -113,15 +129,25 @@ def _recv():
                 # round and will stop participating!
 
         self._recv_thread = gevent.spawn(_recv)
-
         while True:
             # For each round...
             r = self.round
+            logger.debug(str(self.pid) + f" round number: {self.round}")
+            logger.debug(str(self.pid) + f" transaction buffer with len: {len(self.transaction_buffer)}") 
             if r not in self._per_round_recv:
                 self._per_round_recv[r] = Queue()
 
             # Select all the transactions (TODO: actual random selection)
-            tx_to_send = self.transaction_buffer[:self.B]
+            self._prepare_transaction_buffer()
+            if len(self.transaction_buffer):
+                tx_to_send = self.transaction_buffer[:self.B]
+                logger.debug(str(self.pid) + f"Chosen tx_to_send for {self.pid} is {tx_to_send[0][:40]}")
+                for t in tx_to_send:
+                    self.bytes_sent += len(t)
+
+            else:
+                tx_to_send = ['']
+            logger.debug(str(self.pid) + f"EEEEE transaction_buffer for id {self.pid}: {[t[:40] for t in self.transaction_buffer]}")
 
             # TODO: Wait a bit if transaction buffer is not full
 
@@ -133,14 +159,21 @@ def _send(j, o):
             send_r = _make_send(r)
             recv_r = self._per_round_recv[r].get
             new_tx = self._run_round(r, tx_to_send[0], send_r, recv_r)
-            print('new_tx:', new_tx)
+            for msg_recvd in new_tx:
+                if msg_recvd != b'':
+                    logger.debug(str(self.pid) + f'Node id {self.pid} got from his friends: {msg_recvd[:40]}')
+                    self.messages_seen.add(msg_recvd)
 
             # Remove all of the new transactions from the buffer
-            self.transaction_buffer = [_tx for _tx in self.transaction_buffer if _tx not in new_tx]
+            self.transaction_buffer = [_tx for _tx in self.transaction_buffer if _tx not in [t.decode('utf-8') for t in new_tx] and _tx not in tx_to_send]
+            logger.debug(str(self.pid) + f"New transaction buffer after getting messages for id {self.pid}: {[t[:40] for t in self.transaction_buffer]}")
 
             self.round += 1     # Increment the round
-            if self.round >= 3:
-                break   # Only run one round for now
+            # if not self.transaction_buffer:
+            logger.debug(f"{self.pid} Up to now: {len(set(self.messages_seen))} out of {self.amount}")
+            if len(set(self.messages_seen)) == self.amount:
+                logger.debug(str(self.pid) + f" finished with rounds: {self.round}")
+                break
 
     def _run_round(self, r, tx_to_send, send, recv):
         """Run one protocol round.
@@ -174,7 +207,6 @@ def broadcast(o):
         rbc_outputs = [Queue(1) for _ in range(N)]
 
         my_rbc_input = Queue(1)
-        print(pid, r, 'tx_to_send:', tx_to_send)
 
         def _setup(j):
             """Setup the sub protocols RBC, BA and common coin.
@@ -222,30 +254,58 @@ def rbc_send(k, o):
         # N instances of ABA, RBC
         for j in range(N):
             _setup(j)
-
         # One instance of TPKE
         def tpke_bcast(o):
             """Threshold encryption broadcast."""
             broadcast(('TPKE', 0, o))
 
         tpke_recv = Queue()
-
         # One instance of ACS
         acs = gevent.spawn(commonsubset, pid, N, f, rbc_outputs,
                            [_.put_nowait for _ in aba_inputs],
                            [_.get for _ in aba_outputs])
-
         recv_queues = BroadcastReceiverQueues(
             ACS_COIN=coin_recvs,
             ACS_ABA=aba_recvs,
             ACS_RBC=rbc_recvs,
             TPKE=tpke_recv,
         )
         gevent.spawn(broadcast_receiver_loop, recv, recv_queues)
-
         _input = Queue(1)
         _input.put(tx_to_send)
         return honeybadger_block(pid, self.N, self.f, self.ePK, self.eSK,
                                  _input.get,
                                  acs_in=my_rbc_input.put_nowait, acs_out=acs.get,
                                  tpke_bcast=tpke_bcast, tpke_recv=tpke_recv.get)
+
+
+def permute_list(lst, index):
+    return lst[index:] + lst[:index]
+
+def sha256(s):
+    return hashlib.sha256(s.encode()).digest().hex()
+
+def distance(frac):
+    def dist(s):
+        return abs(int((2**256) * frac)  - int.from_bytes(hashlib.sha256(s.encode()).digest(), 'big'))
+    return dist
+
+class ImprovedHoneyBadgerBFT(HoneyBadgerBFT):
+    def _prepare_transaction_buffer(self):
+        self.transaction_buffer = sorted(self.transaction_buffer, key=sha256, reverse=(self.pid%2 == 1))
+
+class PermutedHoneyBadgerBFT(HoneyBadgerBFT):
+    def _prepare_transaction_buffer(self):
+        self.transaction_buffer = sorted(self.transaction_buffer, key=sha256)
+        self.transaction_buffer = permute_list(self.transaction_buffer, int((self.pid / self.N) * self.N))
+        logger.debug("permutating")
+
+class RandomizedHoneyBadgerBFT(HoneyBadgerBFT):
+    def _prepare_transaction_buffer(self):
+        self.transaction_buffer = random.sample(self.transaction_buffer, len(self.transaction_buffer))
+
+class DistanceHoneyBadgerBFT(HoneyBadgerBFT):
+    def _prepare_transaction_buffer(self):
+        self.transaction_buffer = sorted(self.transaction_buffer, key=distance(self.pid / self.N))
+        logger.debug("permutating with distance")
+

honeybadgerbft/core/honeybadger_block.py

@@ -1,5 +1,7 @@
 from ..crypto.threshenc import tpke
 import os
+from our_srcs.consts import *
+from logging import getLogger; logger=getLogger(LOGGER_NAME)
 
 
 def serialize_UVW(U, V, W):
@@ -70,7 +72,6 @@ def honeybadger_block(pid, N, f, PK, SK, propose_in, acs_in, acs_out, tpke_bcast
         share = SK.decrypt_share(*tkey)
         # share is of the form: U_i, an element of group1
         my_shares.append(share)
-
     tpke_bcast(my_shares)
 
     # Receive everyone's shares
@@ -82,7 +83,6 @@ def honeybadger_block(pid, N, f, PK, SK, propose_in, acs_in, acs_out, tpke_bcast
             print('Received a duplicate decryption share from', j)
             continue
         shares_received[j] = shares
-
     assert len(shares_received) >= f+1
     # TODO: Accountability
     # If decryption fails at this point, we will have evidence of misbehavior,
@@ -100,5 +100,4 @@ def honeybadger_block(pid, N, f, PK, SK, propose_in, acs_in, acs_out, tpke_bcast
         plain = tpke.decrypt(key, ciph)
         decryptions.append(plain)
     # print 'Done!', decryptions
-
     return tuple(decryptions)

misc/includeTransaction.py

@@ -1,6 +1,7 @@
 __author__ = 'aluex' 
-
-from gevent import Greenlet
+from gevent import monkey
+monkey.patch_all()
+from gevent import Greenlet, sleep
 from gevent.queue import Queue, Empty
 from bkr_acs import acs
 from utils import mylog, MonitoredInt, callBackWrap, greenletFunction, \
@@ -321,7 +322,7 @@ def listener():
                 broadcast(eval(msg))  # now the msg is something we mannually send
             mylog("timestampB (%d, %lf)" % (pid, time.time()), verboseLevel=-2)
             if len(transactionCache) < B:  # Let's wait for many transactions. : )
-                time.sleep(0.5)
+                sleep(0.5)
                 print "Not enough transactions", len(transactionCache)
                 continue