Example #1
0
 def test_location_announcement(self):
     self.pager.startProtocol()
     self.pager.location_announcement()
     self.assertEqual(len(self.transport.written), 2)
     packet_serialized, addr = self.transport.written[0]
     packet = deserialize(packet_serialized)
     self.assertEqual(packet[0], constants.Header.LOCATIONANNOUNCEMENT)
Example #2
0
 def test_asym_encryption(self):
     identifier = helpers.pick_random()
     ciphertext = helpers.asym_encrypt(identifier, constants.P.public_key)
     s = helpers.serialize([0, ciphertext])
     [op, d] = helpers.deserialize(s)
     plaintext = helpers.asym_decrypt(d, constants.P.private_key)
     self.assertEqual(identifier, plaintext)
Example #3
0
 def lineReceived(self, line):
     print "Received %s from Network Operator" % line
     packet = deserialize(line)
     if packet[0] == constants.Header.LOCATIONUPDATE:
         plaintext = asym_decrypt(packet[1], constants.L.private_key)
         self.factory.server.store(plaintext[0], plaintext[1], plaintext[2])  # pseudo, loc, seed
     else:
         print "Unknown operator %d" % packet[0]
Example #4
0
File: user.py Project: t2d/pyanotel
 def lineReceived(self, line):
     """ will only receive lines, when connected to P or N for outgoing call """
     data = deserialize(line)
     if data[0] == constants.Header.ANSWERCALL:
         cid = data[1]
         self.p_deferred.callback(cid)
     elif data[0] == constants.Header.RAWNOW:
         self.n_deferred.callback("_")
     elif data[0] == constants.Header.ERROR:
         self.n_deferred.errback("Couldn't verify coin.")
Example #5
0
 def lineReceived(self, line):
     print "received " + line
     packet = deserialize(line)
     if packet[0] == constants.Header.ANSWERCALL:
         cid = packet[1]
         self.factory.P.spawn_proxy(cid)
     elif packet[0] == constants.Header.PSEUDONYMUPDATE:
         plaintext = asym_decrypt(packet[1], constants.P.private_key)
         self.factory.P.pseudonym_update(plaintext[0], plaintext[1], plaintext[2])  # pseudonym, identifier, secret
     else:
         print "Type %d unknown" % packet[0]
Example #6
0
    def lineReceived(self, line):
        data = deserialize(line)

        if data[0] == constants.Header.SIGN:
            # sign my blinds
            blinds = data[1:]
            print("Signing %d blinds" % len(blinds))
            answer = [constants.Header.SIGN]
            for blind in blinds:
                blindsig = self.key.sign(b64decode(blind), "bla")[0]
                answer.append(blindsig)
            self.sendLine(serialize(answer))
Example #7
0
    def lineReceived(self, line):
        print "Received %s from Pseudonym Provider" % line
        packet = deserialize(line)

        if packet[0] == constants.Header.REGISTER:
            if packet[1] == "P":
                # register pseudonym provider
                self.factory.pseudonym_provider = self
                print "Registered Pseudonym Provider"
        elif packet[0] == constants.Header.INITCALL:
            self.handle_call(packet[1], packet[2])
        else:
            print "Wrong request_type %d" % packet[0]
Example #8
0
File: user.py Project: t2d/pyanotel
 def lineReceived(self, line):
     data = deserialize(line)
     if data[0] == constants.Header.SIGN:
         print "Receiving blind signatures"
         answers = data[1:]
         for i in range(len(answers)):
             blindsig = long(answers[i])
             blinding_factor, msg = self.blinding_factors[i]
             sig = self.bank_key.unblind(blindsig, blinding_factor)
             if self.bank_key.verify(msg, (sig,)):
                 self.user.coins.append((msg, (sig,)))
             else:
                 print "Couldn't verify signature for %s" % msg
         print "You now have %d coins." % len(self.user.coins)
Example #9
0
 def lineReceived(self, line):
     print "received " + str(line)
     data = deserialize(line)
     op = data[0]
     if op == constants.Header.INITCALL:
         # if len(data) == 3:
         #     callee = data[1]
         #     caller = data[2]
         # el
         if len(data) == 2:
             callee, caller, pseudonym, msg = asym_decrypt(data[1], constants.P.private_key)
         else:
             print "Wrong amount of arguments"
             print data
         self.factory.P.init_call(callee, caller, pseudonym, self)
     elif op == constants.Header.MSG:
         callee, caller, msg = asym_decrypt(data[1], constants.P.private_key)
         self.factory.P.send_msg(callee, caller, msg)
     else:
         print "Type %d unknown" % op
Example #10
0
    def lineReceived(self, line):
        # addr = self.transport.getPeer()
        # print "received: " + line + " from %s:%d" % (addr.host, addr.port)
        inputs = deserialize(line)

        if inputs[0] == constants.Header.REGISTER:
            self.register(inputs[1], self)
            return
        elif inputs[0] == constants.Header.PAGING:
            self.build_paging(inputs)
            return

        if self.factory.fully_connected:
            if inputs[0] == constants.Header.STORE_CID:
                self.factory.store_cid(inputs[1])
                return
            elif inputs[0] == constants.Header.LOCATIONUPDATE:
                # XXX check location validity?
                # forward to L
                self.factory.location_provider.sendLine(line)
                return
            elif inputs[0] == constants.Header.ANSWERCALL:
                cid = inputs[1]
                self.factory.connect_call(cid, self)
                return
            elif inputs[0] == constants.Header.INITCALL:
                cid = inputs[1]
                coin = (inputs[2], (long(inputs[3]),))
                self.forward(cid, coin)
                return
            elif inputs[0] == constants.Header.PSEUDONYMUPDATE:
                # forward to P
                self.factory.pseudonym_provider.sendLine(line)
                return
            else:
                print "Received unrecognized header %d" % inputs[0]
Example #11
0
 def test_serialization(self):
     packet = [constants.Header.INITCALL, helpers.pick_random(), helpers.pick_random()]
     line = helpers.serialize(packet)
     self.assertEqual(type(line), str)
     self.assertEqual(packet, helpers.deserialize(line))
Example #12
0
                for b in chunk:
                    yield b
            else:
                break

s = socket(AF_INET, SOCK_STREAM)
#s.bind(('192.168.50.4', 0))
pseudonym_provider = (constants.P.ip, constants.P.port)
s.connect(pseudonym_provider)

data = [constants.Header.INITCALL, constants.user1_id, 1111111111111111]  # callee , caller
s.send(serialize(data) + "\r\n")
print "sending %s" % serialize(data)

answer = s.recv(1024)
packet = deserialize(answer)
print packet

if packet[0] == constants.Header.ANSWERCALL:
    cid = packet[1]
    # connect to network operator with CID and send raw data
    network = socket(AF_INET, SOCK_STREAM)
    network.connect((constants.N.ip, constants.N.port))
    announcement = [constants.Header.INITCALL, cid]
    network.send(serialize(announcement) + "\r\n")

    answer = network.recv(1024)
    packet = deserialize(answer)
    if packet[0] == constants.Header.RAWNOW:
        print "Sending"
        for b in bytes_from_file('hints.txt'):