def tls_connect(cls, host, port, username, password, **kwargs):
from tlslite.api import TLSConnection
s = cls._connect(host, port, **kwargs)
s2 = TLSConnection(s)
s2.fileno = lambda fd=s.fileno(): fd
s2.handshakeClientSRP(username, password)
return cls(s2)
class tlslite_wrapper(object):
def __init__(self, s):
self.s = TLSConnection(s)
self.s.handshakeClientCert()
self.writing = None
self.reading = None
def write(self, data):
if self.writing is None:
self.writing = (len(data), self.s.writeAsync(data))
try:
self.writing[1].next()
return 0
except StopIteration:
pass
sent = self.writing[0]
self.writing = None
return sent
def read(self, amount):
d = None
while d == None:
try:
d = self.reading.next()
except (StopIteration, AttributeError):
self.reading = self.s.readAsync(amount)
try:
len(d)
except:
raise socket.error("No data ready to be read.")
return d
class tlslite_wrapper(object):
def __init__(self, s):
self.s = TLSConnection(s)
self.s.handshakeClientCert()
self.writing = None
self.reading = None
def write(self, data):
if self.writing is None:
self.writing = (len(data), self.s.writeAsync(data))
try:
self.writing[1].next()
return 0
except StopIteration:
pass
sent = self.writing[0]
self.writing = None
return sent
def read(self, amount):
d = None
while d == None:
try:
d = self.reading.next()
except (StopIteration, AttributeError):
self.reading = self.s.readAsync(amount)
try:
len(d)
except:
raise socket.error("No data ready to be read.")
return d
def run_handshake(client_cb, server_cb):
"""Run the given client/server callbacks in parallel, returning sent data.
This function spawns two background threads on which to run the given
callbacks in parallel. Each will be passed an instance of `TLSConnection`
through which it can communicate with the other.
Once both callbacks complete, this function will return a tuple (c, s) of
the data sent by the client, and by the server. If either callback throws
an error it will be propagated into the main thread.
"""
c, s = mocketpair()
client = TLSConnection(c)
server = TLSConnection(s)
errors = []
def run_client():
try:
client_cb(client)
except Exception as err:
errors.append(err)
def run_server():
try:
server_cb(server)
except Exception as err:
errors.append(err)
tc = threading.Thread(target=run_client)
ts = threading.Thread(target=run_server)
tc.start()
ts.start()
tc.join()
ts.join()
if errors:
raise errors[0]
assert len(MOCKED_URANDOM_CALLS) == 0, 'unused mock urandom call'
return (c.sent_data, s.sent_data)
h_dict['content-length'] = -1
return h_dict
if __name__ == '__main__':
host, port = parse_args()
out_dir = os.path.join(os.getcwd(), host)
if not os.path.exists(out_dir):
try:
os.mkdir(out_dir)
except OSError:
out_dir = mkdtemp()
print('Using %s as output directory' % (out_dir))
print('Trying to connect to %s:%i' % (host, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
connection = TLSConnection(sock)
connection.handshakeClientCert(nextProtos=["spdy/%i" % SPDY_VERSION])
print ('TLS NPN Selected: %s' % connection.next_proto)
spdy_ctx = Context(CLIENT, version=SPDY_VERSION)
connection.write(get_site_resource(spdy_ctx, host))
headers = {spdy_ctx._last_stream_id: {'path': 'index'}}
res_files = {spdy_ctx._last_stream_id: (os.path.join(out_dir, 'index'), None)}
resources = None
goaway = False
while not goaway:
answer = connection.read() # Blocking
spdy_ctx.incoming(answer)
frame = get_frame(spdy_ctx)
while frame:
sid = getattr(frame, 'stream_id', None)
if hasattr(frame, 'headers'):
def __init__(self, s):
self.s = TLSConnection(s)
self.s.handshakeClientCert()
self.writing = None
self.reading = None
return h_dict
if __name__ == '__main__':
host, port = parse_args()
out_dir = os.path.join(os.getcwd(), host)
if not os.path.exists(out_dir):
try:
os.mkdir(out_dir)
except OSError:
out_dir = mkdtemp()
print('Using %s as output directory' % (out_dir))
print('Trying to connect to %s:%i' % (host, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
connection = TLSConnection(sock)
connection.handshakeClientCert(nextProtos=["spdy/%i" % SPDY_VERSION])
print('TLS NPN Selected: %s' % connection.next_proto)
spdy_ctx = Context(CLIENT, version=SPDY_VERSION)
connection.write(get_site_resource(spdy_ctx, host))
headers = {spdy_ctx._last_stream_id: {'path': 'index'}}
res_files = {
spdy_ctx._last_stream_id: (os.path.join(out_dir, 'index'), None)
}
resources = None
goaway = False
while not goaway:
answer = connection.read() # Blocking
spdy_ctx.incoming(answer)
frame = get_frame(spdy_ctx)
while frame:
spdy_ctx.put_frame(syn_frame)
def get_frame(spdy_ctx):
try:
return spdy_ctx.get_frame()
except SpdyProtocolError as e:
print ('error parsing frame: %s' % str(e))
if __name__ == '__main__':
host, port = parse_args()
print('Trying to connect to %s:%i' % (host, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
connection = TLSConnection(sock)
connection.handshakeClientCert(nextProtos=["spdy/%i" % SPDY_VERSION])
print ('TLS NPN Selected: %r' % connection.next_proto)
spdy_ctx = Context(CLIENT, version=SPDY_VERSION)
ping_test(spdy_ctx)
get_page(spdy_ctx, host)
out = spdy_ctx.outgoing()
#print str2hexa(str(out))
connection.write(out)
file_out = open('/tmp/spdyout.txt', 'wb')
goaway = False
content_type_id = {}
while not goaway:
answer = connection.read() # Blocking
#print '<<\n', str2hexa(answer)
spdy_ctx.incoming(answer)
spdy_ctx.put_frame(syn_frame)
def get_frame(spdy_ctx):
try:
return spdy_ctx.get_frame()
except spdy.SpdyProtocolError as e:
print ('error parsing frame: %s' % str(e))
if __name__ == '__main__':
host, port = parse_args()
print('Trying to connect to %s:%i' % (host, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
connection = TLSConnection(sock)
connection.handshakeClientCert(nextProtos=["spdy/2"])
spdy_ctx = spdy.Context(spdy.CLIENT)
ping_test(spdy_ctx)
get_page(spdy_ctx, host)
out = spdy_ctx.outgoing()
# print str2hexa(str(out))
connection.write(out)
file_out = open('/tmp/spdyout.txt', 'wb')
goaway = False
while not goaway:
answer = connection.read() # Blocking
# print '<<\n', str2hexa(answer)
def from_secure_server_socket(cls, sock, vdb):
from tlslite.api import TLSConnection
sock = TLSConnection(sock)
sock.handshakeServer(verifierDB=vdb)
return cls(sock)
def from_new_secure_socket(cls, host, port, username, password):
from tlslite.api import TLSConnection
stream = cls.from_new_socket(host, port)
stream.sock = TLSConnection(stream.sock)
stream.sock.handshakeClientSRP(username, password)
return stream
def __init__(self, s): self.s = TLSConnection(s) self.s.handshakeClientCert() self.writing = None self.reading = None
def get_frame(spdy_ctx):
try:
return spdy_ctx.get_frame()
except SpdyProtocolError as e:
print('error parsing frame: %s' % str(e))
if __name__ == '__main__':
host, port = parse_args()
print('Trying to connect to %s:%i' % (host, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
connection = TLSConnection(sock)
connection.handshakeClientCert(nextProtos=["spdy/%i" % SPDY_VERSION])
print('TLS NPN Selected: %r' % connection.next_proto)
spdy_ctx = Context(CLIENT, version=SPDY_VERSION)
ping_test(spdy_ctx)
get_page(spdy_ctx, host)
out = spdy_ctx.outgoing()
#print str2hexa(str(out))
connection.write(out)
file_out = open('/tmp/spdyout.txt', 'wb')
goaway = False
content_type_id = {}
while not goaway:
answer = connection.read() # Blocking
#print '<<\n', str2hexa(answer)
spdy_ctx.incoming(answer)
