def connect(self):
msg = 'getaddrinfo returns an empty list'
for af, socktype, proto, canonname, addr in getaddrinfo(self.host,
self.port, 0, SOCK_STREAM):
try:
_log.debug('ValidatingHTTPSConnection to %r', addr)
ssl = SSLSocket(socket(af, socktype, proto),
keyfile=self.key_file, certfile=self.cert_file,
cert_reqs=self.cert_reqs, ca_certs=self.ca_certs,
ssl_version=self.ssl_version)
ssl.connect(addr)
except SocketError as e:
_log.info('ValidatingHTTPSConnection to %r: %s', addr, e)
msg = e
self.sock = None
continue
server_attrs = ssl.getpeercert()
# getpeercert() returns {} if the certificate was not verified, in
# which case it doesn't matter what the name in the certificate is.
if self.check_hostname and server_attrs:
self.hostname_matches_cert = False
names = []
for gntype, gn in server_attrs.get('subjectAltName', ()):
if gntype == 'DNS':
self._compare_hostname(gn)
names.append(gn)
else:
_log.warn('ValidatingHTTPSConnection unhandled subjectAltName type: %s=%r', gntype, gn)
# Only look at attributes in the first rdn.
for attr,val in server_attrs['subject'][0]:
if attr == 'commonName':
self._cmp_hostname(val)
names.append(val)
if not self.hostname_matches_cert:
raise CertNameMismatchError(self.host, names)
# Newer ssl object implements makefile, fileno, etc. No need to
# use FakeSocket wrapper
self.sock = ssl
break
if not self.sock:
raise SocketError(msg)
def monkey_wrap_socket(sock,
keyfile=None,
certfile=None,
server_side=False,
cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23,
ca_certs=None,
do_handshake_on_connect=True,
suppress_ragged_eofs=True,
ciphers=None):
ssl_version = ssl.PROTOCOL_TLSv1
return SSLSocket(sock,
keyfile=keyfile,
certfile=certfile,
server_side=server_side,
cert_reqs=cert_reqs,
ssl_version=ssl_version,
ca_certs=ca_certs,
do_handshake_on_connect=do_handshake_on_connect,
suppress_ragged_eofs=suppress_ragged_eofs,
ciphers=ciphers)
def connect(self):
print 'Connecting to region: {0}'.format(self.region)
self.token = GetLoginToken(self.user, self.password, self.region[2])
self.socket = SSLSocket(socket(), ssl_version=3)
self.socket.connect((self.host, self.port))
self.connected = True
if not self.doHandshake():
return False
self.socket.setblocking(0)
self.stream = rtmp.decoder.FileBuffer(self.socket.makefile())
self.reader = rtmp.decoder.PacketReader(self.stream)
msg = {
'videoCodecs': 252,
'audioCodecs': 3575,
'flashVer': u'WIN 10,6,602,161',
'app': '',
'tcUrl': 'rtmps://{0}:2099'.format(self.host),
'videoFunction': 1,
'capabilities': 239,
'pageUrl': '',
'fpad': False,
'swfUrl': 'app:/LolClient.swf/[[DYNAMIC]]/32',
'objectEncoding': 3
}
stream = self.encoder.encodeConnect(msg)
self.writeBytes(stream)
self.processThread = Thread(target=self._processMessages)
self.processThread.start()
return True
def open(self):
try:
self.s = socket(self.af, SOCK_STREAM)
if self.dest == "255.255.255.255":
self.s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.s.settimeout(self.timeout)
sendbuf = self.s.getsockopt(SOL_SOCKET, SO_SNDBUF)
if sendbuf < self.maxsize:
self.maxsize = sendbuf
if not self.sport is None:
if self.af == AF_INET:
self.s.bind((self.src, self.sport))
elif self.af == AF_INET6:
try:
self.s.bind((self.src, self.port, 0, 0))
except:
if not self.interface is '':
(_, _, _, _, addri) = getaddrinfo(
"%s%%%s" % (self.src, self.interface),
self.sport,
family=AF_INET6,
proto=IPPROTO_UDP)[0]
self.s.bind(addri)
else:
raise SessionException(
"cant bind to ipv6 LL without interface!")
self.s = SSLSocket(self.s,
self.client_key,
self.client_cert,
ssl_version=3)
if self.server_side:
self.s.listen(1)
(self.cs, (rip, rport)) = self.s.accept()
if self.dport:
while self.dport != rport or self.src != rip:
if self.dport != rport:
print_dizzy(
"session/ssl: remote port %i not destination port %i"
% (rport, self.dport), DEBUG)
if self.src != rip:
print_dizzy(
"session/ssl: remote ip %s not destination ip %i"
% (rip, self.dst), DEBUG)
(self.cs, (sip, rport)) = self.s.accept()
self.cs.settimeout(self.timeout)
else:
connected = False
attempt = 1
try:
self.s.connect((self.dest, self.dport))
connected = True
except (timeout, SSLError):
print_dizzy(
"session/ssl: Connection attempt %d timed out." %
attempt)
while not connected and attempt <= self.connect_retry:
try:
(r, w, x) = select([], [self.s], [], self.timeout)
if self.s in w:
connected = True
except:
pass
attempt += 1
if not connected:
raise SessionException("too much connection attempts")
except Exception as e:
raise SessionException("cant open session: %s" % str(e))
else:
self.is_open = True
