def linkedin(): global opener cookie_filename = "cookies.txt" # Simulate browser with cookies enabled cj = cookielib.MozillaCookieJar(cookie_filename) if os.access(cookie_filename, os.F_OK): cj.load() # Load Proxy settings if len(config['proxylist']) > 0: proxy_handler = urllib2.ProxyHandler( {'https': config['proxylist'][0]}) opener = urllib2.build_opener( proxy_handler, urllib2.HTTPRedirectHandler(), urllib2.HTTPHandler(debuglevel=0), urllib2.HTTPSHandler(debuglevel=0), urllib2.HTTPCookieProcessor(cj) ) else: opener = urllib2.build_opener( urllib2.HTTPRedirectHandler(), urllib2.HTTPHandler(debuglevel=0), urllib2.HTTPSHandler(debuglevel=0), urllib2.HTTPCookieProcessor(cj) ) user_agent = config['cookie']['User-Agent'] opener.addheaders = [('User-Agent', user_agent)] # Get CSRF Token html = load_page("https://www.linkedin.com/") soup = BeautifulSoup(html, "html.parser") csrf = soup.find(id="loginCsrfParam-login")['value'] # Authenticate login_data = urllib.urlencode({ 'session_key': config['username'], 'session_password': config['password'], 'loginCsrfParam': csrf, }) html = load_page("https://www.linkedin.com/uas/login-submit", login_data) soup = BeautifulSoup(html, "html.parser") try: print(cj._cookies['.www.linkedin.com']['/']['li_at'].value) except Exception: print("error") cj.save() os.remove(cookie_filename)
def auth(email, password, client_id, scope): def split_key_value(kv_pair): kv = kv_pair.split("=") return kv[0], kv[1] # Authorization form def auth_user(email, password, client_id, scope, opener): response = opener.open( 'http://oauth.vk.com/oauth/authorize?' + 'redirect_uri=http://oauth.vk.com/blank.html&response_type=token&' + 'client_id=%s&scope=%s&display=wap' % (client_id, ",".join(scope)) ) html_dock = response.read().decode("utf-8") parser = FormParser() parser.feed(html_dock) parser.close() if not parser.form_parsed or parser.url is None or "pass" not in parser.params or "email" not in parser.params: raise RuntimeError("Something wrong") parser.params["email"] = email parser.params["pass"] = password if parser.method == "POST": response = opener.open(parser.url, urllib.parse.urlencode(parser.params).encode()) else: raise NotImplementedError("Method '%s'" % parser.method) return response.read(), response.geturl() # Permission request form def give_access(html_dock, browser): parser = FormParser() parser.feed(html_dock.decode("utf-8")) parser.close() if not parser.form_parsed or parser.url is None: raise RuntimeError("Something wrong") if parser.method == "POST": response = browser.open(parser.url, urllib.parse.urlencode(parser.params).encode()) else: raise NotImplementedError("Method '%s'" % parser.method) return response.geturl() if not isinstance(scope, list): scope = [scope] opener = request.build_opener( request.HTTPCookieProcessor(cooki.CookieJar()), request.HTTPRedirectHandler()) doc, url = auth_user(email, password, client_id, scope, opener) if urlparse(url).path != "/blank.html": # Need to give access to requested scope url = give_access(doc, opener) if urlparse(url).path != "/blank.html": raise RuntimeError("Expected success here") answer = dict(split_key_value(kv_pair) for kv_pair in urlparse(url).fragment.split("&")) if "access_token" not in answer or "user_id" not in answer: raise RuntimeError("Missing some values in answer") return answer["access_token"], answer["user_id"]
def __init__(self, login, password): self.login = login self.password = password self.cj = cookielib.CookieJar() self.opener = urllib2.build_opener( urllib2.HTTPRedirectHandler(), urllib2.HTTPHandler(debuglevel=0), urllib2.HTTPSHandler(debuglevel=0), urllib2.HTTPCookieProcessor(self.cj)) user_agent = ( "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.1.4322)" ) self.opener.addheaders = [('User-agent', user_agent)] self.loginToLearn()
def __init__(self, user_agent, username, password): self.cj = get_persistent_cookiejar() # Older articles in Wiley's Online Library hit the default limit of 10 # redirections. rh = request.HTTPRedirectHandler() rh.max_redirections = 20 self.opener = request.build_opener(rh, request.HTTPCookieProcessor(self.cj)) self.opener.addheaders = [('User-Agent', user_agent)] ###self.opener.process_request['http'][0].set_http_debuglevel(1) ###self.opener.process_request['https'][0].set_http_debuglevel(1) self.inputs = list(self.default_inputs) self.inputs.append(('username', username)) self.inputs.append(('password', password))
def get_need_dates(username, password): app_id = 7561984 opener = urllib2.build_opener( urllib2.HTTPCookieProcessor(cookielib.CookieJar()), urllib2.HTTPRedirectHandler()) html, url = auth_user(email=username, password=password, app_id=app_id, scope=['friends', 'account'], opener=opener) if urlparse(url).path != "/blank.html": url = give_access(html, opener) token = urlparse(url).fragment.split("&")[0].split("=")[1] id = urlparse(url).fragment.split("&")[2].split("=")[1] return id, token
def get_stock_html(ticker_name): opener = urllib.build_opener( urllib.HTTPRedirectHandler(), urllib.HTTPHandler(debuglevel=0), ) opener.addheaders = [ ('User-agent', "Mozilla/4.0 (compatible; MSIE 7.0; " "Windows NT 5.1; .NET CLR 2.0.50727; " ".NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)") ] url = "http://finance.yahoo.com/q?s=" + ticker_name response = opener.open(url) return b''.join(response.readlines())
def login(): cookie_filename = 'cookies.txt' cookie_jar = cookiejar.MozillaCookieJar(cookie_filename) opener = request.build_opener(request.HTTPRedirectHandler(), request.HTTPHandler(debuglevel=0), request.HTTPSHandler(debuglevel=0), request.HTTPCookieProcessor(cookie_jar)) print("login1") html = load_page(opener, 'https://www.linkedin.com/checkpoint/lg/login') soup = BeautifulSoup(html, 'html.parser') print("login2") csrf = soup.find('input', {'name': 'csrfToken'}).get('value') loginCsrfParam = soup.find('input', { 'name': 'loginCsrfParam' }).get('value') login_data = parse.urlencode({ 'session_key': config.USERNAME, 'session_password': config.PASSWORD, 'csrfToken': csrf, 'loginCsrfParam': loginCsrfParam }) load_page(opener, 'https://www.linkedin.com/checkpoint/lg/login-submit', login_data) try: cookie = cookie_jar._cookies['.www.linkedin.com']['/']['li_at'].value jsessionid = '' for ck in cookie_jar: # print cookie.name, cookie.value, cookie.domain if ck.name == 'JSESSIONID': jsessionid = ck.value except Exception as e: print(e) sys.exit(0) cookie_jar.save() os.remove(cookie_filename) return cookie, csrf
def post_junk(index, to_feed): url = "https://progbase.herokuapp.com/profile/update" params = { 'method': 'POST', 'text': random.choice(to_feed['text']), 'email': random.choice(to_feed['email']), 'number': random.choice(to_feed['number']) } data_to_post = urllib.urlencode(params) binary_data_to_post = data_to_post.encode('utf-8') print('{0}) Starting to get a response...'.format(index + 1)) opener = urllib2.build_opener( urllib2.HTTPCookieProcessor(cookielib.CookieJar()), urllib2.HTTPRedirectHandler()) response = opener.open(url, binary_data_to_post) print("Done!") return response
def getRandomMUID(self): opener = urllib.build_opener(urllib.HTTPErrorProcessor(), urllib.HTTPRedirectHandler(), urllib.HTTPHandler()) request = urllib.Request( "http://gatherer.wizards.com/Pages/Card/Details.aspx?action=random" ) c = 0 while 1: try: response = opener.open(request) except Exception as e: i = int(e.__dict__['url'].split('=')[1]) if i not in self.__used_muids__: yield i elif (c > 100): # this means at least 99.9% completion. raise StopIteration() else: c += 1
def make_request( url: str, method: typing.Optional[str] = 'GET' ) -> typing.Tuple[request.OpenerDirector, request.Request]: """ Creates a request and an opener to run it :param url: Initial URL for request :param method: HTTP Method for request :return: tuple containing the OpenerDirector instance and the Request object """ rdh = request.HTTPRedirectHandler() rdh.max_repeats = 999 rdh.max_redirections = 999 cj = CookieJar() cjh = request.HTTPCookieProcessor(cj) opener = request.build_opener(rdh, cjh) return opener, request.Request(url, method=method)
def auth(self, app_id, scope, login, password): opener = request.build_opener( request.HTTPCookieProcessor(cookiejar.CookieJar()), request.HTTPRedirectHandler()) try: response_auth = opener.open( "https://oauth.vk.com/authorize?client_id={}" "&display=page&redirect_uri=https://oauth.vk.com/blank.htm&scope={}" "&response_type=token&v={}".format(app_id, scope, self.v_api)) except error.HTTPError: raise VKAuthError("Don't auth, may be wrong app id") parser = AuthFormParser() parser.feed(str(response_auth.read())) parser.close() parser.params['email'] = login parser.params['pass'] = password response_allow = opener.open( parser.url, parse.urlencode(parser.params).encode('utf8')) url_parse = parse.urlparse(response_allow.geturl()) if url_parse.path != '/blank.html': query = parse.parse_qs(url_parse.query) if 'email' in query: raise VKAuthError("Wrong login or pass") action_allow = re.findall( r'(?<=<form\smethod=\"post\"\saction=\").*(?=\")', response_allow.read().decode("utf-8"))[0] response_allow = opener.open(action_allow) url_parse = parse.urlparse(response_allow.geturl()) query_params = dict( (k, v) for k, v in (item.split('=') for item in url_parse.fragment.split('&'))) self.token = query_params['access_token'] self.expires_in = query_params['expires_in'] self.user_id = query_params['user_id']
def build_token(scope=[], state='default', mail='123', password='******'): url = '&'.join( ('https://oauth.vk.com/authorize?client_id=5521254', 'display=page', 'redirect_uri=https://oauth.vk.com/blank.html', 'scope=%s' % ','.join(scope), 'response_type=token', 'v=5.53', 'state=%s' % state), ) opener = urllib2.build_opener( urllib2.HTTPCookieProcessor(cookielib.CookieJar()), urllib2.HTTPRedirectHandler()) response = opener.open(url) vkform_parser = FormParser() vkform_parser.feed(response.read().decode("utf-8")) vkform_parser.params["email"] = mail vkform_parser.params["pass"] = password data_to_post = urllib.urlencode(vkform_parser.params) binary_data_to_post = data_to_post.encode('utf-8') print('Starting to get a response...') response = opener.open(vkform_parser.url, binary_data_to_post) print('Got the token!') vk_token = re.search(r'(.*)access_token=(.*)&expires_in(.*)', response.url) return vk_token.group(2)
def __init__(self, login, password): """ Start up... """ self.login = login self.password = password self.cj = cookiejar.CookieJar() self.opener = request.build_opener( request.HTTPRedirectHandler(), request.HTTPHandler(debuglevel=0), request.HTTPSHandler(debuglevel=0), request.HTTPCookieProcessor(self.cj)) # Auth # print(('%s:%s' % (login, password)).encode("utf-8")) base64string = base64.b64encode( ('%s:%s' % (login, password)).encode("utf-8")) auth_str = str(base64string)[2:-1] # print(auth_str) self.opener.addheaders = [('User-agent', ('Mozilla/4.0 (compatible; MSIE 6.0; ' 'Windows NT 5.2; .NET CLR 1.1.4322)')), ("Authorization", "Basic %s" % auth_str)]
def _request(self, url, data=None, method=None): """ Send an HTTP request to the remote server. :Args: - method - A string for the HTTP method to send the request with. - url - The URL to send the request to. - body - The message body to send. :Returns: A dictionary with the server's parsed JSON response. """ LOGGER.debug('%s %s %s' % (method, url, data)) parsed_url = parse.urlparse(url) if self.keep_alive: headers = { "Connection": 'keep-alive', method: parsed_url.path, "User-Agent": "Python http auth", "Content-type": "application/json;charset=\"UTF-8\"", "Accept": "application/json" } if parsed_url.username: auth = base64.standard_b64encode( '%s:%s' % (parsed_url.username, parsed_url.password)).replace( '\n', '') headers["Authorization"] = "Basic %s" % auth self._conn.request(method, parsed_url.path, data, headers) resp = self._conn.getresponse() statuscode = resp.status else: password_manager = None if parsed_url.username: netloc = parsed_url.hostname if parsed_url.port: netloc += ":%s" % parsed_url.port cleaned_url = parse.urlunparse( (parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment)) password_manager = url_request.HTTPPasswordMgrWithDefaultRealm( ) password_manager.add_password( None, "%s://%s" % (parsed_url.scheme, netloc), parsed_url.username, parsed_url.password) request = Request(cleaned_url, data=data.encode('utf-8'), method=method) else: request = Request(url, data=data.encode('utf-8'), method=method) request.add_header('Accept', 'application/json') request.add_header('Content-Type', 'application/json;charset=UTF-8') if password_manager: opener = url_request.build_opener( url_request.HTTPRedirectHandler(), HttpErrorHandler(), url_request.HTTPBasicAuthHandler(password_manager)) else: opener = url_request.build_opener( url_request.HTTPRedirectHandler(), HttpErrorHandler()) resp = opener.open(request) statuscode = resp.code if not hasattr(resp, 'getheader'): if hasattr(resp.headers, 'getheader'): resp.getheader = lambda x: resp.headers.getheader(x) elif hasattr(resp.headers, 'get'): resp.getheader = lambda x: resp.headers.get(x) data = resp.read() try: if 399 < statuscode < 500: return {'status': statuscode, 'value': data} if 300 <= statuscode < 304: return self._request(resp.getheader('location'), method='GET') body = data.decode('utf-8').replace('\x00', '').strip() content_type = [] if resp.getheader('Content-Type') is not None: content_type = resp.getheader('Content-Type').split(';') if not any([x.startswith('image/png') for x in content_type]): try: data = utils.load_json(body.strip()) except ValueError: if 199 < statuscode < 300: status = ErrorCode.SUCCESS else: status = ErrorCode.UNKNOWN_ERROR return {'status': status, 'value': body.strip()} assert type(data) is dict, ( 'Invalid server response body: %s' % body) assert 'status' in data, ( 'Invalid server response; no status: %s' % body) # Some of the drivers incorrectly return a response # with no 'value' field when they should return null. if 'value' not in data: data['value'] = None return data else: data = {'status': 0, 'value': body.strip()} return data finally: LOGGER.debug("Finished Request") resp.close()
def _request(self, method, url, body=None): """ Send an HTTP request to the remote server. :Args: - method - A string for the HTTP method to send the request with. - url - A string for the URL to send the request to. - body - A string for request body. Ignored unless method is POST or PUT. :Returns: A dictionary with the server's parsed JSON response. """ LOGGER.debug('%s %s %s' % (method, url, body)) parsed_url = parse.urlparse(url) headers = self.get_remote_connection_headers(parsed_url, self.keep_alive) if self.keep_alive: if body and method != 'POST' and method != 'PUT': body = None try: self._conn.request(method, parsed_url.path, body, headers) resp = self._conn.getresponse() except (httplib.HTTPException, socket.error): self._conn.close() raise statuscode = resp.status else: password_manager = None if parsed_url.username: netloc = parsed_url.hostname if parsed_url.port: netloc += ":%s" % parsed_url.port cleaned_url = parse.urlunparse(( parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment)) password_manager = url_request.HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(None, "%s://%s" % (parsed_url.scheme, netloc), parsed_url.username, parsed_url.password) request = Request(cleaned_url, data=body.encode('utf-8'), method=method) else: request = Request(url, data=body.encode('utf-8'), method=method) for key, val in headers.items(): request.add_header(key, val) if password_manager: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler(), url_request.HTTPBasicAuthHandler(password_manager), proxy_handler) else: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler(), proxy_handler) resp = opener.open(request, timeout=self._timeout) statuscode = resp.code if not hasattr(resp, 'getheader'): if hasattr(resp.headers, 'getheader'): resp.getheader = lambda x: resp.headers.getheader(x) elif hasattr(resp.headers, 'get'): resp.getheader = lambda x: resp.headers.get(x) data = resp.read() try: if 300 <= statuscode < 304: return self._request('GET', resp.getheader('location')) body = data.decode('utf-8').replace('\x00', '').strip() if 399 < statuscode <= 500: return {'status': statuscode, 'value': body} content_type = [] if resp.getheader('Content-Type') is not None: content_type = resp.getheader('Content-Type').split(';') if not any([x.startswith('image/png') for x in content_type]): try: data = utils.load_json(body.strip()) except ValueError: if 199 < statuscode < 300: status = ErrorCode.SUCCESS else: status = ErrorCode.UNKNOWN_ERROR return {'status': status, 'value': body.strip()} assert type(data) is dict, ( 'Invalid server response body: %s' % body) # Some of the drivers incorrectly return a response # with no 'value' field when they should return null. if 'value' not in data: data['value'] = None return data else: data = {'status': 0, 'value': body.strip()} return data finally: LOGGER.debug("Finished Request") resp.close()
def _request(self, url, data=None, method=None): """ Send an HTTP request to the remote server. :Args: - method - A string for the HTTP method to send the request with. - url - The URL to send the request to. - body - The message body to send. :Returns: A dictionary with the server's parsed JSON response. """ LOGGER.debug('%s %s %s' % (method, url, data)) parsed_url = parse.urlparse(url) password_manager = None if parsed_url.username: netloc = parsed_url.hostname if parsed_url.port: netloc += ":%s" % parsed_url.port cleaned_url = parse.urlunparse((parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment)) password_manager = url_request.HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(None, "%s://%s" % (parsed_url.scheme, netloc), parsed_url.username, parsed_url.password) request = Request(cleaned_url, data=data.encode('utf-8'), method=method) else: request = Request(url, data=data.encode('utf-8'), method=method) request.add_header('Accept', 'application/json') request.add_header('Content-Type', 'application/json;charset=UTF-8') if password_manager: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler(), url_request.HTTPBasicAuthHandler(password_manager)) else: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler()) response = opener.open(request) try: if response.code > 399 and response.code < 500: return {'status': response.code, 'value': response.read()} body = response.read().decode('utf-8').replace('\x00', '').strip() content_type = [value for name, value in response.info().items() if name.lower() == "content-type"] if not any([x.startswith('image/png') for x in content_type]): try: data = utils.load_json(body.strip()) except ValueError: if response.code > 199 and response.code < 300: status = ErrorCode.SUCCESS else: status = ErrorCode.UNKNOWN_ERROR return {'status': status, 'value': body.strip()} assert type(data) is dict, ( 'Invalid server response body: %s' % body) assert 'status' in data, ( 'Invalid server response; no status: %s' % body) # Some of the drivers incorrectly return a response # with no 'value' field when they should return null. if 'value' not in data: data['value'] = None return data else: data = {'status': 0, 'value': body.strip()} return data finally: response.close()
def _request(self, method, url, body=None): """Send an HTTP request to the remote server. :param method: A string for the HTTP method to send the request with. :type method: str :param url: A string for the URL to send the request to. :type url: str :param body: A string for request body. Ignored unless method is POST or PUT. :type body: str :returns: A dictionary with the server's parsed JSON response. """ self.logger.debug('%s %s %s' % (method, url, body)) for _ in range(3): try: parsed_url = parse.urlparse(url) if self.keep_alive: headers = {"Connection": 'keep-alive', method: parsed_url.path, "User-Agent": "Python http auth", "Content-type": "application/json;charset=\"UTF-8\"", "Accept": "application/json"} if parsed_url.username: auth = base64.standard_b64encode(('%s:%s' % (parsed_url.username, parsed_url.password)).encode('ascii')).decode('ascii').replace('\n', '') headers["Authorization"] = "Basic %s" % auth if body and method != 'POST' and method != 'PUT': body = None try: self._conn.request(method, parsed_url.path, body, headers) resp = self._conn.getresponse() except (httplib.HTTPException, socket.error): self._conn.close() raise statuscode = resp.status else: password_manager = None if parsed_url.username: netloc = parsed_url.hostname if parsed_url.port: netloc += ":%s" % parsed_url.port cleaned_url = parse.urlunparse((parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment)) password_manager = url_request.HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(None, "%s://%s" % (parsed_url.scheme, netloc), parsed_url.username, parsed_url.password) request = Request(cleaned_url, data=body.encode('utf-8'), method=method) else: request = Request(url, data=body.encode('utf-8'), method=method) request.add_header('Accept', 'application/json') request.add_header('Content-Type', 'application/json;charset=UTF-8') if password_manager: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler(), url_request.HTTPBasicAuthHandler(password_manager), url_request.ProxyHandler({})) else: opener = url_request.build_opener(url_request.HTTPRedirectHandler(), HttpErrorHandler(), url_request.ProxyHandler({})) resp = opener.open(request, timeout=self._timeout) statuscode = resp.code if not hasattr(resp, 'getheader'): if hasattr(resp.headers, 'getheader'): resp.getheader = lambda x: resp.headers.getheader(x) elif hasattr(resp.headers, 'get'): resp.getheader = lambda x: resp.headers.get(x) data = resp.read() try: if 300 <= statuscode < 304: return self._request('GET', resp.getheader('location')) body = data.decode('utf-8').replace('\x00', '').strip() if 399 < statuscode < 500: return {'status': statuscode, 'value': body} content_type = [] if resp.getheader('Content-Type') is not None: content_type = resp.getheader('Content-Type').split(';') if not any([x.startswith('image/png') for x in content_type]): try: data = json.loads(body.strip()) except ValueError: if 199 < statuscode < 300: status = ErrorCode.SUCCESS else: status = ErrorCode.UNKNOWN_ERROR return {'status': status, 'value': body.strip()} assert type(data) is dict, ( 'Invalid server response body: %s' % body) # Some of the drivers incorrectly return a response # with no 'value' field when they should return null. if 'value' not in data: data['value'] = None return data else: data = {'status': 0, 'value': body.strip()} return data finally: self.logger.debug("Finished Request") resp.close() except socket.timeout: self.logger.exception('Remote Connection timeout') raise XCTestAgentTimeoutException('XCTestAgent response is timed out') except Exception, e: self.logger.error('Remote Connection:%s' % str(e))
def main(): print(''' +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + This is Only For Practise And Educational Purpose Only + +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ''') number = int(raw_input(' [+] Please Enter Your Username : '******' [+] Please Enter Your Password : '******'http://site24.way2sms.com/Login1.action' data = {'username': str(number), 'password': str(password)} data = urllib.urlencode(data) # ******************************************************** cj = cookielib.CookieJar() header = { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Firefox/31.0 Iceweasel/31.8.0' } req = urllib2.Request(url, data, headers=header) opennr = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj), urllib2.HTTPRedirectHandler()) print('[+] Please Wait. Trying To Login In ') req = opennr.open(req) sucess = str(req.info()) sucess = sucess.find('Set-Cookie') if (sucess == -1): print('\n', '[+] Login Successful [+]') pass else: print('\n', '[+] Login Failed [+]') raw_input('') sys.exit(0) # ****** Tokken Receiving Mechanizem ****************** tokken = cook(cj) print('\n [+] Tokken Received : ', tokken) # ******************************************************************* # ********* Sms Sending System Configuration ************************ url = 'http://site24.way2sms.com/smstoss.action' head = { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Firefox/31.0 Iceweasel/31.8.0', 'Refere': str('http://site24.way2sms.com/sendSMS?Token=' + tokken) } mobile = int( raw_input(' [*] Please Enter Mobile Number For Sending SMS : ')) #================ Checking Mechanizam ===================================== if len(str(mobile)) == 10: pass else: print(" [*] Invalid Username") sys.exit(0) while True: message_raw = str( raw_input( ' [*] Please Enter Message For Sending. Note ! Not More Then 140 Words: ' )) message = message_raw.replace(' ', '+') msglen = 140 - len(message) if len(message) < 140: break else: pass data = 'ssaction=ss&Token=' + tokken + '&mobile=' + str( mobile) + '&message=' + str(message) + '&msgLen=' + str(msglen) req = urllib2.Request(url, data=data, headers=head) print('[+] Sending SMS . Please Wait [+]') req = opennr.open(req) print('\n', ' [+] Task Complete Thanks For Using [+]') raw_input('\n\n')
from traceback import print_exc from urllib import request from sys import version try: args = ArgumentParser() args.add_argument('url', help='Set short url.') args.add_argument('-r', dest='redirect', default=10, type=int, help='Set max redirects.') args.add_argument('-p', dest='proxy', help='Set http proxy.') args = args.parse_args() handle_redirect = request.HTTPRedirectHandler() handle_redirect.max_redirections = args.redirect handle_cookie = request.HTTPCookieProcessor() request.install_opener(request.build_opener(handle_redirect, handle_cookie)) req = request.Request(args.url, method='HEAD') version = version.split() req.add_header('User-Agent', 'Python v{}'.format(version)) if args.proxy: proxy = request.urlparse(args.proxy) req.set_proxy('{}:{}'.format(proxy.hostname, proxy.port), proxy.scheme) with request.urlopen(req) as req:
from http.cookiejar import CookieJar from html.parser import HTMLParser from bs4 import BeautifulSoup as bs from urllib.parse import urlparse from .authData import authData from functions.splitKeyValue import splitKeyValue encoding = 'utf-8' client_id = 5512115 # scope = 'offline,messages' scope = 'messages' email = authData['email'] password = authData['password'] opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(CookieJar()), urllib2.HTTPRedirectHandler()) def vkAuth(): ########################## GET AUTH FROM TIME ################################## authUrl = "http://oauth.vk.com/oauth/authorize?" + \ "redirect_uri=http://oauth.vk.com/blank.html&response_type=token&" + \ "client_id=%s&scope=%s&display=wap" % (client_id, scope) authResponse = opener.open(authUrl) authForm = bs(authResponse.read()).find('form') ########################## SEND AUTH DATA TIME ################################# authData = {} # Collect form inputs
def _create_request(url, market_da): opener = urllib_request_compat.build_opener( urllib_request_compat.HTTPRedirectHandler()) opener.addheaders.append(('Cookie', 'MarketDA=%s' % market_da)) return opener.open(url)