class ConnecterConnection:
def __init__(self,port):
self.s = BTConnection('localhost',port)
self.s.read_handshake_medium_rare()
self.connection = EncrypterConnection(self.s.get_his_id())
def get_my_id(self):
return self.s.get_my_id()
def get_unauth_peer_id(self):
return self.s.get_his_id()
def is_locally_initiated(self):
return True
def send_message(self,msg):
self.s.send(msg)
def get_message(self):
return self.s.recv()
def set_permid(self,x):
pass
def set_auth_peer_id(self,x):
pass
def close(self):
self.s.close()
class ConnecterConnection:
def __init__(self, port):
self.s = BTConnection('localhost', port)
self.s.read_handshake_medium_rare()
self.connection = EncrypterConnection(self.s.get_his_id())
def get_my_id(self):
return self.s.get_my_id()
def get_unauth_peer_id(self):
return self.s.get_his_id()
def is_locally_initiated(self):
return True
def send_message(self, msg):
self.s.send(msg)
def get_message(self):
return self.s.recv()
def set_permid(self, x):
pass
def set_auth_peer_id(self, x):
pass
def close(self):
self.s.close()
def _test_response1(self,ss,gen_resp1,good):
print >>sys.stderr,"test: myserver running:",gen_resp1
conn, addr = ss.accept()
s = BTConnection('',0,conn)
s.read_handshake_medium_rare()
# Read challenge
msg = s.recv()
self.testcase.assert_(msg[0] == CHALLENGE)
randomB = bdecode(msg[1:])
self.testcase.assert_(type(randomB) == StringType)
self.testcase.assert_(len(randomB) == random_size)
[randomA,resp1_data] = gen_resp1(randomB,s.get_his_id())
s.send(resp1_data)
if good:
# Read response2
msg = s.recv()
self.testcase.assert_(msg[0] == RESPONSE2)
self.check_response2(msg[1:],randomA,randomB,s.get_my_id())
# the connection should be intact, so this should not throw an
# exception:
time.sleep(5)
s.send('bla')
s.close()
else:
time.sleep(5)
# the other side should not our bad RESPONSE1 this and close the
# connection
msg = s.recv()
self.testcase.assert_(len(msg)==0)
s.close()
def _test_response1(self, ss, gen_resp1, good):
print >> sys.stderr, "test: myserver running:", gen_resp1
conn, addr = ss.accept()
s = BTConnection('', 0, conn)
s.read_handshake_medium_rare()
# Read challenge
msg = s.recv()
self.testcase.assert_(msg[0] == CHALLENGE)
randomB = bdecode(msg[1:])
self.testcase.assert_(type(randomB) == StringType)
self.testcase.assert_(len(randomB) == random_size)
[randomA, resp1_data] = gen_resp1(randomB, s.get_his_id())
s.send(resp1_data)
if good:
# Read response2
msg = s.recv()
self.testcase.assert_(msg[0] == RESPONSE2)
self.check_response2(msg[1:], randomA, randomB, s.get_my_id())
# the connection should be intact, so this should not throw an
# exception:
time.sleep(5)
s.send('bla')
s.close()
else:
time.sleep(5)
# the other side should not our bad RESPONSE1 this and close the
# connection
msg = s.recv()
self.testcase.assert_(len(msg) == 0)
s.close()
def _test_bad_response2(self, gen_resp2_func):
print >>sys.stderr, time.asctime(), "-", "test: bad response2", gen_resp2_func
s = BTConnection("localhost", self.hisport)
s.read_handshake()
[rB, chal_data] = self.create_good_challenge()
s.send(chal_data)
resp1_data = s.recv()
self.assert_(resp1_data[0] == RESPONSE1)
resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
resp2_data = gen_resp2_func(rB, resp1_dict, s.get_his_id())
s.send(resp2_data)
time.sleep(5)
# the other side should not like this and close the connection
msg = s.recv()
self.assert_(len(msg) == 0)
s.close()
def _test_bad_response2(self, gen_resp2_func):
print >> sys.stderr, "test: bad response2", gen_resp2_func
s = BTConnection('localhost', self.hisport)
s.read_handshake()
[rB, chal_data] = self.create_good_challenge()
s.send(chal_data)
resp1_data = s.recv()
self.assert_(resp1_data[0] == RESPONSE1)
resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
resp2_data = gen_resp2_func(rB, resp1_dict, s.get_his_id())
s.send(resp2_data)
time.sleep(5)
# the other side should not like this and close the connection
msg = s.recv()
self.assert_(len(msg) == 0)
s.close()
def subtest_good_challenge_response2(self):
"""
test good challenge and response2 messages
"""
print >>sys.stderr, time.asctime(), "-", "test: good challenge/response"
s = BTConnection("localhost", self.hisport)
s.read_handshake()
[rB, chal_data] = self.create_good_challenge()
s.send(chal_data)
resp1_data = s.recv()
self.assert_(resp1_data[0] == RESPONSE1)
resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
resp2_data = self.create_good_response2(rB, resp1_dict, s.get_his_id())
s.send(resp2_data)
time.sleep(10)
# the other side should not have closed the connection, as
# this is all valid, so this should not throw an exception:
s.send("bla")
s.close()
def subtest_good_challenge_response2(self):
"""
test good challenge and response2 messages
"""
print >> sys.stderr, "test: good challenge/response"
s = BTConnection('localhost', self.hisport)
s.read_handshake()
[rB, chal_data] = self.create_good_challenge()
s.send(chal_data)
resp1_data = s.recv()
self.assert_(resp1_data[0] == RESPONSE1)
resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
resp2_data = self.create_good_response2(rB, resp1_dict, s.get_his_id())
s.send(resp2_data)
time.sleep(10)
# the other side should not have closed the connection, as
# this is all valid, so this should not throw an exception:
s.send('bla')
s.close()
class OLConnection:
def __init__(self,my_keypair,hostname,port,opensock=None,mylistenport=481,myoversion=None):
""" If opensock is not None, we assume this is a connection we
accepted, and he initiates the Challenge/Response
"""
self.my_keypair = my_keypair
self.b = BTConnection(hostname,port,opensock,mylistenport=mylistenport,myoversion=myoversion)
if opensock:
self.b.read_handshake_medium_rare()
# Read challenge
msg = self.b.recv()
assert(msg[0] == CHALLENGE)
randomB = bdecode(msg[1:])
[randomA,resp1_data] = self.create_good_response1(randomB,self.b.get_his_id())
self.b.send(resp1_data)
# Read response2
msg = self.b.recv()
assert(msg[0] == RESPONSE2)
else:
self.b.read_handshake()
[rB,chal_data] = self.create_good_challenge()
self.b.send(chal_data)
resp1_data = self.b.recv()
if DEBUG:
print >>sys.stderr,"olconn: recv",len(resp1_data),"bytes"
resp1_dict = bdecode(resp1_data[1:])
resp2_data = self.create_good_response2(rB,resp1_dict,self.b.get_his_id())
self.b.send(resp2_data)
if DEBUG:
print >>sys.stderr,"olconn: sent",len(resp2_data),"bytes"
def get_my_fake_listen_port(self):
return self.b.get_my_fake_listen_port()
#
# Cut 'n paste from TestPermIDs
#
def create_good_challenge(self):
r = "".zfill(cr_random_size)
return [r,self.create_challenge_payload(r)]
def create_good_response2(self,rB,resp1_dict,hisid):
resp2 = {}
resp2['certB'] = str(self.my_keypair.pub().get_der())
resp2['A'] = hisid
sig_list = [rB,resp1_dict['rA'],hisid]
sig_data = bencode(sig_list)
sig_hash = sha(sig_data).digest()
sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
resp2['SB'] = sig_asn1
return self.create_response2_payload(resp2)
def create_challenge_payload(self,r):
return CHALLENGE+bencode(r)
def create_response2_payload(self,dict):
return RESPONSE2+bencode(dict)
#
# Cut 'n paste from TestPermIDResponse1
#
def create_good_response1(self,rB,hisid):
resp1 = {}
resp1['certA'] = str(self.my_keypair.pub().get_der())
resp1['rA'] = "".zfill(cr_random_size)
resp1['B'] = hisid
sig_list = [resp1['rA'],rB,hisid]
sig_data = bencode(sig_list)
sig_hash = sha(sig_data).digest()
sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
resp1['SA'] = sig_asn1
return [resp1['rA'],self.create_response1_payload(resp1)]
def create_response1_payload(self,dict):
return RESPONSE1+bencode(dict)
def send(self,data):
""" send length-prefixed message """
self.b.send(data)
def recv(self):
""" received length-prefixed message """
return self.b.recv()
def close(self):
self.b.close()
class OLConnection:
def __init__(self,
my_keypair,
hostname,
port,
opensock=None,
mylistenport=481,
myoversion=None):
""" If opensock is not None, we assume this is a connection we
accepted, and he initiates the Challenge/Response
"""
self.my_keypair = my_keypair
self.b = BTConnection(hostname,
port,
opensock,
mylistenport=mylistenport,
myoversion=myoversion)
if opensock:
self.b.read_handshake_medium_rare()
# Read challenge
msg = self.b.recv()
assert (msg[0] == CHALLENGE)
randomB = bdecode(msg[1:])
[randomA,
resp1_data] = self.create_good_response1(randomB,
self.b.get_his_id())
self.b.send(resp1_data)
# Read response2
msg = self.b.recv()
assert (msg[0] == RESPONSE2)
else:
self.b.read_handshake()
[rB, chal_data] = self.create_good_challenge()
self.b.send(chal_data)
resp1_data = self.b.recv()
if DEBUG:
print >> sys.stderr, "olconn: recv", len(resp1_data), "bytes"
resp1_dict = bdecode(resp1_data[1:])
resp2_data = self.create_good_response2(rB, resp1_dict,
self.b.get_his_id())
self.b.send(resp2_data)
if DEBUG:
print >> sys.stderr, "olconn: sent", len(resp2_data), "bytes"
def get_my_fake_listen_port(self):
return self.b.get_my_fake_listen_port()
#
# Cut 'n paste from TestPermIDs
#
def create_good_challenge(self):
r = "".zfill(cr_random_size)
return [r, self.create_challenge_payload(r)]
def create_good_response2(self, rB, resp1_dict, hisid):
resp2 = {}
resp2['certB'] = str(self.my_keypair.pub().get_der())
resp2['A'] = hisid
sig_list = [rB, resp1_dict['rA'], hisid]
sig_data = bencode(sig_list)
sig_hash = sha(sig_data).digest()
sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
resp2['SB'] = sig_asn1
return self.create_response2_payload(resp2)
def create_challenge_payload(self, r):
return CHALLENGE + bencode(r)
def create_response2_payload(self, dict):
return RESPONSE2 + bencode(dict)
#
# Cut 'n paste from TestPermIDResponse1
#
def create_good_response1(self, rB, hisid):
resp1 = {}
resp1['certA'] = str(self.my_keypair.pub().get_der())
resp1['rA'] = "".zfill(cr_random_size)
resp1['B'] = hisid
sig_list = [resp1['rA'], rB, hisid]
sig_data = bencode(sig_list)
sig_hash = sha(sig_data).digest()
sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
resp1['SA'] = sig_asn1
return [resp1['rA'], self.create_response1_payload(resp1)]
def create_response1_payload(self, dict):
return RESPONSE1 + bencode(dict)
def send(self, data):
""" send length-prefixed message """
self.b.send(data)
def recv(self):
""" received length-prefixed message """
return self.b.recv()
def close(self):
self.b.close()
