def test_https():
from requests_toolbelt.adapters import host_header_ssl
import socket
cache_func = urllib3.util.connection.create_connection
def wrap_create_connection(address,
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
source_address=None,
socket_options=None):
address = ("14.215.56.238", "443")
return cache_func(address, timeout, source_address, socket_options)
urllib3.util.connection.create_connection = wrap_create_connection
s = requests.Session()
s.mount("https://", host_header_ssl.HostHeaderSSLAdapter())
res = s.get(
"https://file3.data.weipan.cn/84687038/33aa2de11a520c616796445637c52edf13b9a17f?ip=1575539119,59.42.106.170&ssig=Djju4kRf0E&Expires=1575539719&KID=sae,l30zoo1wmz&fn=%E5%91%A8%E6%9D%B0%E4%BC%A6+-+%E4%B8%83%E9%87%8C%E9%A6%99.mp3&se_ip_debug=59.42.106.170&from=1221134",
headers={"Host": "file3.data.weipan.cn"},
stream=True,
# verify=False,
)
content = res.raw.read(44)
print(content)
exit(1)
with requests.Session() as s:
s = requests.Session()
s.mount("https://", host_header_ssl.HostHeaderSSLAdapter())
# res = s.get("http://202.104.186.233:443/84687038/33aa2de11a520c616796445637c52edf13b9a17f?ip=1575535072,59.42.106.170&ssig=9xRrS2tbWs&Expires=1575535672&KID=sae,l30zoo1wmz&fn=%E5%91%A8%E6%9D%B0%E4%BC%A6+-+%E4%B8%83%E9%87%8C%E9%A6%99.mp3&se_ip_debug=59.42.106.170&from=1221134", headers={"Host": "file3.data.weipan.cn"}, stream=True)
res = s.get("http://ayiis.me/aydocs/download/ex.zip",
headers={"Host": "ayiis.me"},
stream=True)
# res = s.get("https://113.113.73.32/5aV1bjqh_Q23odCf/static/superman/img/logo/bd_logo1_31bdc765.png", headers={"Host": "ss0.bdstatic.com"}, stream=True)
# res = requests.get(
# "https://113.113.73.32/5aV1bjqh_Q23odCf/static/superman/img/logo/bd_logo1_31bdc765.png",
# timeout=(3, 3),
# headers={
# "Host": "ss0.bdstatic.com",
# },
# stream=True,
# )
print(111111111111)
content = res.raw.read() # only about content
print("headers:", res.headers)
open("akufwigf1b222.png", "wb").write(content)
def main():
repo = SqliteRepository()
s = sched.scheduler(time.time, time.sleep)
global session
session = requests.session()
if not VERIFY_SSL:
session.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
while True:
try:
logger.debug("Transmitter: scheduling network transmission...")
s.enter(TRANSMIT_INTERVAL_SECONDS,
SCHEDULE_PRIORITY_DEFAULT,
transmit,
argument=(repo, ))
logger.debug("Transmitter: Running scheduler...")
s.run()
logger.debug("Transmitter: End of iteration.")
except KeyboardInterrupt:
break
except AuthenticationException as ae:
logger.error("Transmitter: {0]".format(ae.message))
except TransmissionException as te:
logger.error("Transmitter: {0}".format(te.message))
finally:
pass
logger.info("Transmitter: exiting.")
def check_proxy(proxy_url, retry=False, through=False):
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
i = 0
while i < 3:
if through:
try:
r = s.get('https://' + proxy_url,
headers={'Host': 'plex.ruxn.media'},
timeout=27.05)
except requests.exceptions.RequestException:
if not retry:
return False
i += 1
else:
if r.status_code == 401:
return True
else:
return False
else:
try:
r = s.get('https://' + proxy_url + '/statuscheck',
headers={'Host': 'plex.ruxn.media'},
timeout=27.05)
except requests.exceptions.RequestException:
if not retry:
return False
i += 1
else:
if r.status_code == 200:
return True
else:
return False
return False
def call_api(self, endpoint, method, headers=None, data=None, urldata=None, timeout=None):
try:
# covnert server cert to file
if self.server_cert_file_content_exists is True:
with open(self.server_cert_name, 'w') as f:
try:
f.write(self.server_cert_file_content)
except IOError:
self.logger.error('Failed to setup certificate')
url = None
actual_headers = self.headers.copy()
if headers is not None:
for header_key in headers:
actual_headers[header_key] = headers[header_key]
if self.url_modifier_function is not None:
url = self.url_modifier_function(
self.server_ip, endpoint, actual_headers)
else:
url = 'https://' + self.server_ip + '/' + endpoint
try:
session = requests.Session()
retry_strategy = Retry(total=self.retry_max, backoff_factor=0, status_forcelist=[429, 500, 502, 503, 504],
method_whitelist=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"])
session.mount("http://", TimeoutHTTPAdapter(max_retries=retry_strategy))
if self.sni is not None:
# only use the tool belt session in case of SNI for safety
session.mount('https://', host_header_ssl.HostHeaderSSLAdapter(max_retries=self.retry_max))
actual_headers["Host"] = self.sni
else:
session.mount("https://", TimeoutHTTPAdapter(max_retries=retry_strategy))
call = getattr(session, method.lower())
it = InterruptableThread(exception_catcher, call, url, headers=actual_headers, params=urldata, data=data,
verify=self.server_cert_content,
timeout=(self.connect_timeout, timeout),
auth=self.auth)
it.start()
it.join(timeout)
if it.is_alive():
raise Exception(f'timeout_error ({timeout} sec)')
response = it.result
if isinstance(response, Exception):
raise response
if 'headers' in dir(response) and isinstance(response.headers, collections.Mapping) and \
'Content-Type' in response.headers and "Deprecated" in response.headers['Content-Type']:
self.logger.error("WARNING: " +
response.headers['Content-Type'], file=sys.stderr)
return ResponseWrapper(response)
except Exception as e:
self.logger.error('exception occured during requesting url: ' + str(e))
raise e
finally:
if self.server_cert_file_content_exists is True:
try:
os.remove(self.server_cert_name)
except OSError as e:
if e.errno != errno.ENOENT:
raise
def getAllStudents() -> list:
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.get(BASE_URL + 'students', verify=CERT_PATH, headers=HEADERS)
if response.status_code != 200:
return []
return response.json()
def setup_api():
session = requests.Session()
session.mount(
API_HOST,
host_header_ssl.HostHeaderSSLAdapter(
max_retries=3,
),
)
session.headers.update({'Host': PRODUCTION_DOMAIN})
api_config = {
'base_url': '%s/api/v2/' % API_HOST,
'serializer': serialize.Serializer(
default='json-drf',
serializers=[
serialize.JsonSerializer(),
DrfJsonSerializer(),
],
),
'session': session,
}
if USER and PASS:
log.debug(
'Using slumber v2 with user %s, pointed at %s',
USER,
API_HOST,
)
session.auth = (USER, PASS)
else:
log.warning('SLUMBER_USERNAME/PASSWORD settings are not set')
return API(**api_config)
def tableau_server_response(self):
from requests_toolbelt.adapters import host_header_ssl # avoid top-level import that breaks docs build
context = self.page_context
tabserver_url = 'https://{}/trusted/'.format(self.visualization.server.server_name)
post_arguments = {'username': self.visualization.server.domain_username}
if self.visualization.server.target_site != 'Default':
post_arguments.update({'target_site': self.visualization.server.target_site})
if self.visualization.server.validate_hostname != '':
request = requests.Session()
request.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
tabserver_response = request.post(tabserver_url,
post_arguments,
headers={'Host': self.visualization.server.validate_hostname})
else:
tabserver_response = requests.post(tabserver_url, post_arguments)
if tabserver_response.status_code == 200:
if tabserver_response.content != b'-1':
context.update({'ticket': tabserver_response.content.decode('utf-8')})
return render(self.request, self.template_name, context)
else:
context.update({"failure_message": _("Tableau trusted authentication failed")})
return render(self.request, 'reports/tableau_server_request_failed.html', context)
else:
message = _("Request to Tableau failed with status code {}").format(tabserver_response.status_code)
context.update({"failure_message": message})
return render(self.request, 'reports/tableau_server_request_failed.html', context)
def get_sc(sc):
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
a = s.get(
"https://10.62.130.80/backend/public/api/tracking?_dc=1533002388191&ScNoss=true&Field=ORDER_ID&SearchText="
+ sc,
headers={"Host": "telkom.co.id"})
return a
def getGroups(groupNumber) -> list:
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.get(BASE_URL + 'groups/' + groupNumber,
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return []
return response.json()
def getAnswers(lessonId) -> list:
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.get(BASE_URL + 'quiz/' + str(lessonId) + '/answers',
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return []
return response.json()
def connectDrill(self):
global tpass
if self.drill_connected == False:
try:
tuser = os.environ['JPY_USER']
except:
raise Exception(
"Could not find user at ENV JPY_USER - Please use '%drill connect alt' to specify"
)
print("Connecting as user %s" % tuser)
try:
turl = os.environ['DRILL_BASE_URL']
except:
raise Exception(
"No DRILL_BASE_URL specified in ENV - Please use '%drill connect alt' to specify"
)
print("Connecting to Drill URL: %s" % turl)
print("")
print("Now, please enter the password you wish to connect with:")
tpass = ""
self.myip.ex(
"from getpass import getpass\ntpass = getpass(prompt='Drill Connect Password: '******'tpass']
self.session = requests.Session()
if self.drill_pin_to_ip == True:
tipurl = self.getipurl(turl)
print("")
print("Pinning to IP for this session: %s" % tipurl)
print("")
self.drill_base_url = tipurl
self.session.mount(tipurl,
host_header_ssl.HostHeaderSSLAdapter())
else:
self.drill_base_url = turl
self.drill_user = tuser
self.drill_pass = tpass
self.myip.user_ns['tpass'] = ""
#try:
if 1 == 1:
self.session = self.authDrill()
self.drill_connected = True
print("%s - Drill Connected!" % self.drill_base_url)
#except:
# print("Connection Error - Perhaps Bad Usename/Password?")
else:
print(
"Drill is already connected - Please type %drill for help on what you can you do"
)
def _load_url(source, timeout, host):
"""Load contents from URL"""
headers = {}
if host:
headers.update({'HOST': host})
sess = Session()
sess.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = sess.get(source, timeout=timeout, headers=headers)
return response.text if response else None
def main():
"""
Main function
"""
request_session = requests.Session()
request_session.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = request_session.get(
'https://1.2.3.4', headers={'Host': 'example.com'}, verify=True)
print(response.text)
def getTeachers(searchPhraze) -> list:
namePattern = "%" + searchPhraze + "%"
namePattern.replace(' ', '%')
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.get(BASE_URL + 'teachers/' + namePattern,
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return []
return response.json()
def __init__(self):
self.code = ""
session = requests.Session()
session.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
self.requests = session
self.code_verifier, self.code_challenge = self.oauth_pkce(self.s256)
self.login_params = {
"code_challenge": self.code_challenge,
"code_challenge_method": "S256",
"client": "pixiv-android",
}
self.msger = biuMsg("Login")
def postNewQuestion(lessonId, text) -> bool:
answerData = {"answer_type": 'questions', "answer": text}
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.post(BASE_URL + 'quiz/' + str(lessonId),
data=answerData,
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return False
return True
def vault_auth(self):
vault_client = hvac.Client(url=os.environ['VAULT_ADDR'],
token=os.environ['VAULT_TOKEN'])
vault_client.session.mount('https://',
host_header_ssl.HostHeaderSSLAdapter())
vault_client.session.headers['Host'] = VAULT_TLS_SERVER_NAME
token = vault_client.auth_approle(
vault_client.read(ROLE_ID_PATH)['data']['role_id'],
vault_client.write(SECRET_ID_PATH)['data']
['secret_id'])['auth']['client_token']
vault_client.token = token
return vault_client
def setup_api():
session = Session()
session.mount(API_HOST, host_header_ssl.HostHeaderSSLAdapter())
session.headers.update({'Host': PRODUCTION_DOMAIN})
api_config = {
'base_url': '%s/api/v1/' % API_HOST,
'session': session,
}
if USER and PASS:
log.debug('Using slumber with user %s, pointed at %s', USER, API_HOST)
session.auth = (USER, PASS)
else:
log.warning('SLUMBER_USERNAME/PASSWORD settings are not set')
return API(**api_config)
def getQuestions(lessonId) -> list:
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.get(BASE_URL + 'quiz/' + str(lessonId),
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return []
questions = []
for element in response.json():
questions.append(
Question(element['question']['id'], element['question']['text'],
element['question']['type']))
return questions
def ssl_url_check_custom_IP(self, node_ip):
self.node_ip = node_ip
https_url_ip = 'https://' + self.node_ip + self.uri
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
try:
rhttps = s.get(https_url_ip,
headers={"Host": self.domain_name},
timeout=5)
return rhttps.status_code
except requests.ConnectTimeout:
return "TimeOut_Error"
except requests.ConnectionError:
return "Connection_Error"
def call_api(self, endpoint, method, headers=None, params=[], data=None, urldata=None, timeout=None):
try:
# covnert server cert to file
if self.server_cert_file_content_exists is True:
with open(self.server_cert_name, 'w') as f:
try:
f.write(self.server_cert_file_content)
except IOError:
self.logger.error('Failed to setup certificate')
url = None
actual_headers = self.headers.copy()
if headers is not None:
for header_key in headers:
actual_headers[header_key] = headers[header_key]
if self.url_modifier_function is not None:
url = self.url_modifier_function(
self.server_ip, endpoint, actual_headers)
else:
url = 'https://' + self.server_ip + '/' + endpoint
try:
call = getattr(requests, method.lower())
# only use the tool belt session in case of SNI for safety
if self.sni is not None:
session = requests.Session()
call = getattr(session, method.lower())
session.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
actual_headers["Host"] = self.sni
response = call(url, headers=actual_headers, params=urldata, data=data, verify=self.server_cert_content,
timeout=timeout)
if 'headers' in dir(response) and isinstance(response.headers, collections.Mapping) and \
'Content-Type' in response.headers and "Deprecated" in response.headers['Content-Type']:
self.logger.error("WARNING: " +
response.headers['Content-Type'], file=sys.stderr)
return ResponseWrapper(response)
except Exception as e:
self.logger.error('exception occured during requesting url: ' + str(e))
raise e
finally:
if self.server_cert_file_content_exists is True:
try:
os.remove(self.server_cert_name)
except OSError as e:
if e.errno != errno.ENOENT:
raise
def setTeacherChatId(teacherId, chatId) -> bool:
data = {"id": int(teacherId), "telegram_id": int(chatId)}
print(data)
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.patch(BASE_URL + 'teachers',
data=data,
verify=CERT_PATH,
headers=HEADERS)
print(response.status_code)
if response.status_code != 200:
return False
return True
def session(self):
if self._session is None:
self._session = requests.Session()
# Enables HostHeaderSSLAdapter
# https://toolbelt.readthedocs.io/en/latest/adapters.html#hostheaderssladapter
if self.tls_use_host_header:
self._session.mount('https://',
host_header_ssl.HostHeaderSSLAdapter())
# Attributes can't be passed to the constructor
for option, value in iteritems(self.options):
setattr(self._session, option, value)
return self._session
def __init__(self, typ, **kwargs):
# Make sure required elements are present
get_config_element(CFG_TRANSPORT_HTTPS_AUTH_URL, kwargs,
CFG_PROPERTIES)
get_config_element(CFG_URL, kwargs, CFG_PROPERTIES)
get_config_element(CFG_TRANSPORT_HTTPS_JWT_ID, kwargs, CFG_PROPERTIES)
get_config_element(CFG_TRANSPORT_HTTPS_JWT_KEY, kwargs, CFG_PROPERTIES)
super().__init__(typ, **kwargs)
self.jwt_token = (None, None)
self.session = requests.session()
if not self.verify_ssl():
self.session.mount('https://',
host_header_ssl.HostHeaderSSLAdapter())
self.auth_ttl = self.jwt_token_ttl_minutes()
self.logger = None
def session(self):
if self._session is None:
self._session = requests.Session()
# Enables HostHeaderSSLAdapter
# https://toolbelt.readthedocs.io/en/latest/adapters.html#hostheaderssladapter
if self.tls_use_host_header:
self._session.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
# Enable Unix Domain Socket (UDS) support.
# See: https://github.com/msabramo/requests-unixsocket
self._session.mount('{}://'.format(UDS_SCHEME), requests_unixsocket.UnixAdapter())
# Attributes can't be passed to the constructor
for option, value in iteritems(self.options):
setattr(self._session, option, value)
return self._session
def test_durum(make_message_edns, host, ip, record_type, dnssec):
"""Tests durum, Wikidough's check service at check.wikimedia-dns.org.
This check works by querying for *.check.wikimedia-dns.org; if the query
comes from a Wikidough host, gdnsd returns DURUM_YES_IP*. For all other
cases, it returns DURUM_NO_IP.
What about ECS? Again, gdnsd takes care of that by ignoring ECS for
checkdoh-map in geo-maps by setting `ignore_ecs => true'; this allows us to
see the recursor IP address instead of the client's, even though ECS is set
by pdns-recursor for queries to WMF auth servers, as shown in
test_dot_ecs_query_*.
"""
# Query went through Wikidough, gdnsd should return the "yes" IP.
response_wikidough = dns.query.tls(make_message_edns, RESOLVER_IP,
record_type)
assert DURUM_YES_IP_DOT == get_rrset(response_wikidough)
assert DURUM_YES_IP_DOH != get_rrset(response_wikidough)
# Query went through 8.8.8.8, gdnsd should return the "no" IP.
response_not_wikidough = dns.query.tls(make_message_edns, '8.8.8.8',
record_type)
assert DURUM_NO_IP == get_rrset(response_not_wikidough)
# Test the actual web application that users access. To do this, we will
# need requests_toolbelt to create a request to the yes/no IP, with the
# specified SNI.
#
# See puppet: modules/profile/templates/durum/nginx.conf.erb.
durum_url = 'https://{ip}/check'
secure_r = requests.Session()
secure_r.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
headers = {"Host": host}
response_yes = secure_r.get(durum_url.format(ip=DURUM_YES_IP_DOH),
headers=headers)
response_yes.raise_for_status()
assert response_yes.json()['wikidough']
assert response_yes.json()['service'] == "doh"
response_no = secure_r.get(durum_url.format(ip=DURUM_NO_IP),
headers=headers)
response_no.raise_for_status()
assert not response_no.json()['wikidough']
def addkey(self):
# Get common name and IP address for wireguard endpoint in region
cn = self.server_list[self.region]['servers']['wg'][0]['cn']
ip = self.server_list[self.region]['servers']['wg'][0]['ip']
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
s.verify = 'ca.rsa.4096.crt'
r = s.get("https://{}:1337/addKey?pt={}&pubkey={}".format(
ip, urllib.parse.quote(self.token),
urllib.parse.quote(self.publickey)),
headers={"Host": cn})
if r.status_code == 200 and r.json()['status'] == 'OK':
self.connection = r.json()
return True, r.content
else:
return False, r.content
def createNewStudent(groupId, telegramId, login="") -> bool:
if len(login) == 0:
studentData = {"group_id": groupId, "telegram_id": telegramId}
else:
studentData = {
"login": login,
"group_id": groupId,
"telegram_id": telegramId
}
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
response = s.post(BASE_URL + 'students',
data=studentData,
verify=CERT_PATH,
headers=HEADERS)
if response.status_code != 200:
return False
return True
def get_token(self, username, password):
# Get common name and IP address for metadata endpoint in region
meta_cn = self.server_list[self.region]['servers']['meta'][0]['cn']
meta_ip = self.server_list[self.region]['servers']['meta'][0]['ip']
# Some tricks to verify PIA certificate, even though we're sending requests to an IP and not a proper domain
# https://toolbelt.readthedocs.io/en/latest/adapters.html#requests_toolbelt.adapters.host_header_ssl.HostHeaderSSLAdapter
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
s.verify = 'ca.rsa.4096.crt'
r = s.get("https://{}/authv3/generateToken".format(meta_ip),
headers={"Host": meta_cn},
auth=(username, password))
data = r.json()
if r.status_code == 200 and data['status'] == 'OK':
self.token = data['token']
return True
else:
return False
def issue_comment(event, context):
comment = {
# "body": os.environ["body"]
}
#r = requests.get(url = URL, json=query)
s = requests.Session()
s.mount('https://', host_header_ssl.HostHeaderSSLAdapter())
# r = s.get("https://93.184.216.34")
r = s.get("https://93.184.216.34", headers={"Host": "example.org"})
# r = requests.post(url = URL, json=comment, auth=(USER,PASSWORD))
# data = r.json()
print(r.status_code)
print(r.text)
print("Python version:")
print(sys.version)
print("hello world")