def get_fandom_name(url: str) -> str:
"""Scrape browse page url and return fandom name.
Args:
url (str): url of fandom browse page
ex: https://www.fanfiction.net/book/Harry-Potter/
Returns:
str: scraped fandom name
"""
options = uc.ChromeOptions()
options.headless = True
options.add_argument('--headless')
chrome = uc.Chrome(options=options)
chrome.get(url)
html = chrome.page_source
soup = BeautifulSoup(html, "lxml")
regex = r" (FanFiction Archive|Crossover) \| FanFiction$"
name = re.sub(regex, '', soup.find('title').string)
time.sleep(5)
chrome.quit()
return name
def __init__(self, driver_name, driver_executable_path,
browser_executable_path, command_executor, driver_arguments):
"""Initialize the selenium webdriver
Parameters
----------
driver_name: str
The selenium ``WebDriver`` to use
driver_executable_path: str
The path of the executable binary of the driver
driver_arguments: list
A list of arguments to initialize the driver
browser_executable_path: str
The path of the executable binary of the browser
command_executor: str
Selenium remote server endpoint
"""
if driver_name == 'uc':
# uses https://github.com/ultrafunkamsterdam/undetected-chromedriver to bypass blocking
options = uc.ChromeOptions()
for argument in driver_arguments:
options.add_argument(argument)
self.driver = uc.Chrome(options=options)
else:
webdriver_base_path = f'selenium.webdriver.{driver_name}'
driver_klass_module = import_module(
f'{webdriver_base_path}.webdriver')
driver_klass = getattr(driver_klass_module, 'WebDriver')
driver_options_module = import_module(
f'{webdriver_base_path}.options')
driver_options_klass = getattr(driver_options_module, 'Options')
driver_options = driver_options_klass()
if browser_executable_path:
driver_options.binary_location = browser_executable_path
for argument in driver_arguments:
driver_options.add_argument(argument)
driver_kwargs = {
'executable_path': driver_executable_path,
'options': driver_options
}
# locally installed driver
if driver_executable_path is not None:
driver_kwargs = {
'executable_path': driver_executable_path,
'options': driver_options
}
self.driver = driver_klass(**driver_kwargs)
# remote driver
elif command_executor is not None:
from selenium import webdriver
capabilities = driver_options.to_capabilities()
self.driver = webdriver.Remote(
command_executor=command_executor,
desired_capabilities=capabilities)
def check_for_update():
BASE_URL = "https://www.amazon.co.uk/s?k=1440p+144hz+monitor&i=computers&rh=n%3A428652031%2Cp_n_specials_match%3A21583550031"
options = uc.ChromeOptions()
options.headless = True
options.add_argument('--headless')
chrome = uc.Chrome(options=options)
chrome.get(BASE_URL)
html = chrome.page_source
soup = BeautifulSoup(html, features='lxml')
results_html = soup.find_all(
attrs={"data-component-type": "s-search-results"})[0].select(
".s-main-slot")[0].findChildren(
attrs={"data-component-type": "s-search-result"},
recursive=False)
titles = list(
map(lambda res: res.find(attrs={
"class": "a-size-medium"
}).get_text(), results_html))
titles.sort()
title_str = ''.join(titles)
with open('results_cache.txt', "r") as f:
if f.read() != title_str:
send_notification()
print("Sending notification")
with open('results_cache.txt', 'w') as f:
f.write(title_str)
def get_cookie(url):
global useragent, cookieJAR, cookie
options = webdriver.ChromeOptions()
arguments = [
'--no-sandbox', '--disable-setuid-sandbox', '--disable-infobars', '--disable-logging', '--disable-login-animations',
'--disable-notifications', '--disable-gpu', '--headless', '--lang=ko_KR', '--start-maxmized',
'--user-agent=Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60 MicroMessenger/6.5.18 NetType/WIFI Language/en'
]
for argument in arguments:
options.add_argument(argument)
driver = webdriver.Chrome(options=options)
driver.implicitly_wait(3)
driver.get(url)
for _ in range(60):
cookies = driver.get_cookies()
tryy = 0
for i in cookies:
if i['name'] == 'cf_clearance':
cookieJAR = driver.get_cookies()[tryy]
useragent = driver.execute_script("return navigator.userAgent")
cookie = f"{cookieJAR['name']}={cookieJAR['value']}"
driver.quit()
return True
else:
tryy += 1
pass
time.sleep(1)
driver.quit()
return False
def __init__(self):
if Browser.__instance is not None:
raise Exception("This class is a singleton!")
else:
Browser.__instance = self
self.user_agent = ""
options = uc.ChromeOptions()
self.browser = uc.Chrome(options=options)
self.cookie = Cookies.getCookies(self)
self._setUserAgent()
def __init__(self):
# prepare WebDriver
self.options = uc.ChromeOptions()
self.options.headless = False
self.options.add_argument(
'/Users/vincentyan/Library/Application Support/Google/Chrome')
self.options.add_argument(
'user-agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"'
)
self.driver = uc.Chrome(options=self.options)
def get_new_marionette(cls, headless: bool = False) -> uc.Chrome:
print('Requesting a new marionette')
options = uc.ChromeOptions()
if headless:
options.headless = True
options.add_argument('--headless')
options.add_argument('--disable-gpu')
options.add_argument('--no-first-run --no-service-autorun --password-store=basic')
driver = uc.Chrome(options=options)
print('Got new marionette.')
return driver
def __init__(self, proxy=False, headless=False):
self.options = uc.ChromeOptions()
if headless:
self.options.headless = True
self.options.add_argument('--headless')
if proxy:
self.set_proxy()
self.driver = uc.Chrome(options=self.options)
self.logger = logging.getLogger(__name__)
self.driver.implicitly_wait(0)
def headless_uc(request: FixtureRequest):
options = uc.ChromeOptions()
options.headless = True
request.instance.driver = uc.Chrome(options=options)
def teardown():
request.instance.driver.sapipve_screenshot(FAILED_SCREENSHOT_NAME)
request.instance.driver.quit()
request.addfinalizer(teardown)
return request.instance.driver
def get_chromedriver_options():
options = uc.ChromeOptions()
# options.headless=True
# options.add_argument('--headless')
options.add_argument("window-size=1280,800")
# options.add_argument('--user-data-dir=/home/julius/.user_data')
# options.add_argument('--disable-notifications')
# options.add_argument('--allow-running-insecure-content')
# options.add_argument('--no-sandbox')
# options.add_argument('--disable-setuid-sandbox')
# options.add_argument('--disable-web-security')
return options
def __init__(self, **kwargs):
super().__init__()
option = uc.ChromeOptions()
# option.add_argument('--headless')
with open(self.custom_settings['cookie_dir'], 'r',
encoding='utf-8') as f:
cookie = json.loads(f.read())
option.add_argument("--start-maximized")
self.browser = uc.Chrome(options=option)
self.browser.get(self.start_urls)
# load cookies
for cookie_ in cookie:
self.browser.add_cookie(cookie_dict=cookie_)
def WebController(url):
global driver
global scan_active
global current_state
global thread_stop
try:
options = uc.ChromeOptions()
options.add_argument('--headless')
driver = uc.Chrome(options=options)
#driver = uc.Chrome('C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe', options=options)
driver.get("https://www.twitch.tv/popout/"+str(poll)+"/poll")
scan_active = True
except:
current_state = "Webdriver Error"
def iniciar():
crome_options = uc.ChromeOptions()
#crome_options.add_argument('--headless')
#crome_options.add_argument(f"--window-size=800,600")
crome_options.add_argument("--hide-scrollbars")
crome_options.add_argument("--log-level=3")
crome_options.add_argument('--disable-extensions')
crome_options.add_argument('--profile-directory=Default')
crome_options.add_argument("--incognito")
crome_options.add_argument("--disable-plugins-discovery");
driver = webdriver.Chrome(r'./chromedriver.exe', options=crome_options)
#chrome.delete_all_cookies()
return driver
def WebController(url):
global driver
global scan_active
global current_state
global thread_stop
try:
options = uc.ChromeOptions()
driver = uc.Chrome(options=options)
#options.add_argument('--headless')
#driver = uc.Chrome('C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe', options=options)
driver.get(url)
scan_active = True
except:
current_state = "Webdriver Error"
def glados(cookie_string):
options = uc.ChromeOptions()
options.add_argument("--disable-popup-blocking")
version = get_driver_version()
driver = uc.Chrome(version_main=version, options=options)
# Load cookie
driver.get("https://glados.rocks")
if cookie_string.startswith("cookie:"):
cookie_string = cookie_string[len("cookie:"):]
cookie_dict = [{
"name": x[:x.find('=')].strip(),
"value": x[x.find('=') + 1:].strip()
} for x in cookie_string.split(';')]
driver.delete_all_cookies()
for cookie in cookie_dict:
if cookie["name"] in ["koa:sess", "koa:sess.sig"]:
driver.add_cookie({
"domain": "glados.rocks",
"name": cookie["name"],
"value": cookie["value"],
"path": "/",
})
driver.get("https://glados.rocks")
WebDriverWait(driver, 240).until(lambda x: x.title != "Just a moment...")
message = str()
checkin_code, checkin_message = glados_checkin(driver)
if checkin_code == -2:
checkin_message = "Login fails, please check your cookie."
message = f"{message}【Checkin】{checkin_message}\n"
print(f"【Checkin】{checkin_message}")
if checkin_code != -2:
status_code, status_data = glados_status(driver)
left_days = int(float(status_data["leftDays"]))
print(f"【Status】Left days:{left_days}")
message = f"{message}【Status】Left days:{left_days}\n"
driver.close()
driver.quit()
return checkin_code, message
def init_webdriver(logger):
AGENT = get_agent(logger)
chrome_options = uc.ChromeOptions()
chrome_options.add_argument(f"user-agent= {AGENT}")
chrome_options.add_argument(
'--disable-blink-features=AutomationControlled')
#chrome_options.add_argument("--incognito")
chrome_options.add_argument('--user-data-dir=./Configs/User_Data')
#chrome_options.add_argument('headless')
chrome_options.add_argument("--disable-extensions")
chrome_options.add_argument("--disable-popup-blocking")
chrome_options.add_experimental_option(
"excludeSwitches", ["enable-automation", "enable-logging"])
chrome_options.add_experimental_option('useAutomationExtension', False)
browserdriver = uc.Chrome(options=chrome_options)
return browserdriver
def create_driver():
system = platform.system()
# print("SYSTEM IS: " + str(system))
if system == 'Darwin':
path = 'chrome_mac/chromedriver'
elif system == 'Linux':
path = 'chrome_linux/chromedriver'
elif system == 'Windows':
path = os.getcwd() + '\chrome_windows\chromedriver.exe'
# Shoutout to the dev who created this
use_undetected_chromedriver = True
if use_undetected_chromedriver:
options = uc.ChromeOptions()
options.add_argument('--profile-directory=Profile 8')
options.add_argument('--disable-popup-blocking') # allow for new tab
# options.add_extension("adblocker/uBlock-Origin.crx")
driver = uc.Chrome(options=options)
return driver
else:
options = webdriver.ChromeOptions()
# For older ChromeDriver under version 79.0.3945.16
options.add_argument("--ignore-certificate-error")
options.add_argument("--ignore-ssl-errors")
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
options.add_experimental_option("excludeSwitches",
["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
# Stop annoying windows logs
options.add_argument('--disable-logging')
options.add_argument("--log-level=3")
driver = webdriver.Chrome(executable_path=path, options=options)
return driver
def scrape(self):
"""Scrape all urls of self.sections."""
print("Start scraping...")
options = uc.ChromeOptions()
options.headless = True
options.add_argument('--headless')
chrome = uc.Chrome(options=options)
length = len(self.sections)
for i, section in enumerate(self.sections):
print(section.url)
try:
chrome.get(section.url)
html = chrome.page_source
section.scrape(html)
except Exception as e:
print("Get page source error!")
print(e)
if i != length - 1:
time.sleep(5)
chrome.quit()
def __init__(self,
showWindow=True,
proxy=None,
downloadPath: str = None,
add_arguments=None,
window_size=None,
driver_path="",
seleniumwire_options=None,
driver=None):
add_arguments = add_arguments or []
if seleniumwire_options is not None:
# import seleniumwire
# import seleniumwire.webdriver
import seleniumwire.undetected_chromedriver.v2 # import Chrome, ChromeOptions
# import seleniumwire.undetected_chromedriver # import Chrome, ChromeOptions
options = seleniumwire.undetected_chromedriver.v2.ChromeOptions()
# options = seleniumwire.webdriver.ChromeOptions()
else:
if driver is not None:
options = driver.ChromeOptions()
else:
options = webdriver.ChromeOptions()
# options.add_argument("--disable-dev-shm-usage")
# options.add_argument("--no-sandbox")
# options.add_experimental_option("prefs", {
# "profile.default_content_setting_values.notifications": 1
# })
for arg in add_arguments:
options.add_argument(arg)
if downloadPath is not None and isinstance(downloadPath, str):
absolutePath = os.path.abspath(downloadPath)
if (not os.path.isdir(absolutePath)):
raise FileNotFoundError(errno.ENOENT,
os.strerror(errno.ENOENT),
absolutePath)
options.add_experimental_option(
'prefs', {'download.default_directory': absolutePath})
if proxy is not None and isinstance(proxy, str):
options.add_argument("--proxy-server={}".format(proxy))
if not showWindow:
options.headless = True
options.add_argument("--headless")
driverfilename = ''
if sys.platform == 'linux' or sys.platform == 'linux2':
driverfilename = 'chrome_linux'
if showWindow and not os.environ.get("DISPLAY", ""):
raise Exception(
"DISPLAY variable not set and non-headless mode requested")
elif sys.platform == 'win32':
driverfilename = 'chrome_windows.exe'
elif sys.platform == 'darwin':
driverfilename = 'chrome_mac'
if driver_path:
driverpath = driver_path
else:
driverpath = os.path.join(
os.path.split(__file__)[0],
'drivers{0}{1}'.format(os.path.sep, driverfilename))
os.chmod(driverpath, 0o755)
if seleniumwire_options is not None:
import seleniumwire.undetected_chromedriver.v2 # import Chrome, ChromeOptions
# import seleniumwire.undetected_chromedriver # import Chrome, ChromeOptions
# import seleniumwire.webdriver
# import seleniumwire.webdriver
self.driver = seleniumwire.undetected_chromedriver.v2.Chrome(
# self.driver = seleniumwire.undetected_chromedriver.Chrome(
executable_path=driverpath,
options=options,
seleniumwire_options=seleniumwire_options)
# self.driver = seleniumwire.webdriver.Chrome(executable_path=driverpath, options=options,
# seleniumwire_options=seleniumwire_options)
elif driver is None:
self.driver = webdriver.Chrome(executable_path=driverpath,
options=options)
elif driver is not None:
options.add_argument(f'--proxy-server=socks5://127.0.0.1:9050')
self.driver = driver.Chrome(options=options)
else:
raise NotImplementedError("Options combination is not implemented")
if window_size:
self.driver.set_window_size(*window_size)
self.Key = Keys
self.errors = []
[
setattr(self, function, getattr(self.driver, function))
for function in [
'add_cookie', 'delete_all_cookies', 'delete_cookie',
'execute_script', 'execute_async_script', 'fullscreen_window',
'get_cookie', 'get_cookies', 'get_log',
'get_network_conditions', 'get_screenshot_as_base64',
'get_screenshot_as_file', 'get_screenshot_as_png',
'get_window_position', 'get_window_rect', 'get_window_size',
'maximize_window', 'minimize_window', 'implicitly_wait',
'quit', 'refresh', 'save_screenshot', 'set_network_conditions',
'set_page_load_timeout', 'set_script_timeout',
'set_window_position', 'set_window_rect', 'start_client',
'start_session', 'stop_client', 'switch_to_alert'
]
]
import datetime
import pyfiglet as f
import undetected_chromedriver as UC
import pickle
import account as ac
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import *
from fake_useragent import UserAgent
UC.TARGET_VERSION = 87 # You can change your chrome version target
options = UC.ChromeOptions()
hl = input("Headless / Normal")
if hl == "Headless":
options.headless = True
options.add_argument("--headless")
else:
options.headless = False
options.add_argument("start-maximized")
# Add proxy to become more invisible
server = input("Proxy / Socks5 / None : ")
if server.lower == "proxy":
proxy = input("Masukan proxy : ")
options.add_argument(f'--proxy-server={proxy}')
elif server.lower == "socks5":
socks5 = input("Masukan socks5 : ")
options.add_argument(f'--proxy-server=socks5://{socks5}')
def browser(asef, passwd, selection_month, selection_day, email, proxy):
# uc.TARGET_VERSION = 78
options = uc.ChromeOptions()
#ua = UserAgent()
#userAgent = ua.random
#print(userAgent)
#options.add_argument(f'user-agent={userAgent}')
options.add_argument('--proxy-server=' + str(proxy))
print('Proxy: ' + str(proxy))
options.add_extension("./extensions/buster_chrome.crx")
options.add_extension("./extensions/xpather.crx")
# options.add_argument("--headless")
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument("--enable-features=ReaderMode")
prefs = {
"profile.managed_default_content_settings.images": 2,
"profile.default_content_setting_values.notifications": 2,
"profile.managed_default_content_settings.stylesheets": 2,
"profile.managed_default_content_settings.cookies": 2,
"profile.managed_default_content_settings.javascript": 1,
"profile.managed_default_content_settings.plugins": 1,
"profile.managed_default_content_settings.popups": 2,
"profile.managed_default_content_settings.geolocation": 2,
"profile.managed_default_content_settings.media_stream": 2,
}
prefs1 = {"profile.managed_default_content_settings.images": 2}
options.add_experimental_option("prefs", prefs)
options.binary_location = r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe"
chrome_driver_binary = "./selenium"
driver = uc.Chrome(chrome_options=options)
driver.execute_script(
"Object.defineProperty(navigator, 'webdriver', {get: () => false})")
driver.set_page_load_timeout(60)
for i in range(2):
try:
driver.get("https://discord.com/register")
navigation_start = driver.execute_script(
"return window.performance.timing.navigationStart")
dom_complete = driver.execute_script(
"return window.performance.timing.domComplete")
waittime = int(round(dom_complete - navigation_start)) / 1000
print("Time to connect & load the Discord page: " + str(waittime))
# driver.execute_script("window.open('https://www.yinsiduanxin.com/mail.html')")
# driver.switch_to.window(driver.window_handles[1])
break
except:
print("failed to connect")
driver.quit()
# driver.find_element_by_xpath("//button[contains(string(), '随机邮箱')]").click()
# time.sleep(0.5)
# emaill = driver.find_element_by_xpath("//span[contains(string(), '@mailscode.com')]").text
driver.switch_to.window(driver.window_handles[0])
sleeptime = int(500) / 1000
try:
enter_searchbar = driver.find_element_by_name("email")
enter_searchbar.send_keys(email) #l)
time.sleep(sleeptime)
enter_user = driver.find_element_by_name("username")
enter_user.send_keys(asef)
time.sleep(sleeptime)
enter_passwd = driver.find_element_by_name("password")
enter_passwd.send_keys(passwd)
time.sleep(sleeptime)
enter_month = driver.find_element_by_id("react-select-2-input")
enter_month.send_keys(selection_month, Keys.ENTER)
time.sleep(sleeptime)
enter_day = driver.find_element_by_id("react-select-3-input")
enter_day.send_keys(selection_day, Keys.ENTER)
time.sleep(sleeptime)
enter_year = driver.find_element_by_id("react-select-4-input")
enter_year.send_keys(random.randint(1988, 1997), Keys.ENTER)
time.sleep(sleeptime)
driver.find_element_by_xpath("//button[@type='submit']").click()
time.sleep(sleeptime)
except:
print("Value input failed due to unloaded elements.")
driver.quit()
try:
driver.find_element_by_xpath(
"//div[contains(string(), 'Email is already registered')]"
).is_displayed()
email = emails()
enter_searchbar = driver.find_element_by_name("email")
enter_searchbar.clear()
enter_searchbar.send_keys(email)
time.sleep(sleeptime)
driver.find_element_by_xpath("//button[@type='submit']").click()
except:
print("Email was not used before.")
try:
driver.find_element_by_xpath(
"//span[contains(string(), 'Password is too weak or common to use')]"
)
enter_passwd = driver.find_element_by_name("password")
enter_passwd.send_keys("321!@#")
time.sleep(sleeptime)
driver.find_element_by_xpath("//button[@type='submit']").click()
except:
print("Password was strong enough.")
try:
driver.find_element_by_xpath(
"//div[contains(string(), 'You are being rate limited')]"
).is_displayed()
result = ratelimit()
if "429" in str(result[0]):
print("Ratelimited for " + str(round(result[1]['retry_after'])) +
" seconds. Waiting until that is over.")
time.sleep(int(round(result[1]['retry_after'])))
driver.find_element_by_xpath("//button[@type='submit']").click()
except:
print("Registration was not ratelimited.")
wait = WebDriverWait(driver, 300)
wait.until(
EC.frame_to_be_available_and_switch_to_it(
(By.XPATH, "//iframe[attribute::*[contains(name(), 'a')]]")))
#wait.until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR,"iframe[name^='a-']")))
wait.until(EC.element_to_be_clickable((By.ID, "recaptcha-anchor"))).click()
time.sleep(2)
for _ in range(10):
actions = ActionChains(driver)
actions.send_keys(Keys.TAB + " ")
actions.perform()
time.sleep(5)
try:
#wait = WebDriverWait(driver, 3)
#wait.until(EC.presence_of_element_located(By.XPATH, "/html/body/div/div/div[1]"))
driver.find_element_by_xpath(
"//iframe[attribute::*[contains(name(), 'a')]]/html/body/div/div/div[1]"
)
print("Multiple captcha solving needed.")
except:
print("breaking")
break
# try:
# wait = WebDriverWait(driver, 30)
# wait.until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, "iframe[name^='a-']")))
# wait.until(EC.presence_of_element_located((By.XPATH, "//div[@class='rc-audiochallenge-error-message']")))
# print("succeeded.")
# except:
# print("passed")
wait = WebDriverWait(driver, 600)
desired_url = "https://discord.com/channels/@me"
wait.until(lambda driver: driver.current_url == desired_url)
time.sleep(3)
try:
driver.find_element_by_xpath("//h2[contains(string(), 'Add Friend')]")
print("Token works fine.")
except:
print("We have been either email or phone-locked.")
# driver.switch_to.window(driver.window_handles[1])
# time.sleep(2)
# driver.find_element_by_xpath("//button[contains(string(), '接收邮件')]").click()
# time.sleep(2)
# driver.find_element_by_xpath("//td[contains(string(), 'Discord')]").click()
# time.sleep(2)
# driver.find_element_by_xpath("//a[contains(string(), 'Verify Email')]").click()
driver.quit()
# https://github.com/ultrafunkamsterdam/undetected-chromedriver
import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
options = uc.ChromeOptions()
options.headless=True
driver = uc.Chrome(options=options)
url = "https://antoinevastel.com"
driver.get(url)
user_agent = driver.execute_script("return navigator.userAgent")
print("User-Agent: {}".format(user_agent))
# Legit user-agent, doesn't contain "HeadlessChrome":
# Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36
has_webdriver = driver.execute_script("return !!navigator.webdriver")
print("Has webdriver: {}".format(has_webdriver))
# No webdriver
articles = []
a_elts = driver.find_elements(By.CSS_SELECTOR, 'article a')
for a_elt in a_elts:
articles.append({
'title': a_elt.text,
'url': a_elt.get_attribute("href")
})
print(articles)
# [{'title': 'Equivalent of Promise.map (Bluebird) in Python', 'url': 'https://antoinevastel.com/python/2021/03/13/promise-map-python.html'}, {'title': 'A common mistake while monitoring HTTP responses with Puppeteer', 'url': 'https://antoinevastel.com/puppeteer/2021/01/23/instrumenting-requests-puppeteer-bug.html'}, {'title': "Analyzing Recent's Magento 1 Credit Card Skimmer", 'url': 'https://antoinevastel.com/fraud/2020/09/20/analyzing-magento-skimmer.html'}, {'title': 'Creating a simple ExpressJS middleware to detect bots', 'url': 'https://antoinevastel.com/bot/2020/05/10/express-middleware-bot.html'}, {'title': 'Bot detection 101: How to detect web bots?', 'url': 'https://antoinevastel.com/javascript/2020/02/09/detecting-web-bots.html'}, {'title': 'Bot detection 101: Categories of web bots', 'url': 'https://antoinevastel.com/crawler/2019/12/29/families-web-bots.html'}, {'title': 'Benchmarking our JavaScript obfuscator', 'url': 'https://antoinevastel.com/javascript/2019/09/10/benchmarking-obfuscator.html'}, {'title': 'Improving our homemade JavaScript obfuscator', 'url': 'https://antoinevastel.com/javascript/2019/09/09/improving-obfuscator.html'}, {'title': 'A simple homemade JavaScript obfuscator', 'url': 'https://antoinevastel.com/javascript/2019/09/04/home-made-obfuscator.html'}, {'title': 'The Intriguing Sneaker Bot industry', 'url': 'https://antoinevastel.com/javascript/2019/08/31/sneakers-supreme-bots.html'}]
def browser(user, passwd, selection_month, selection_day, email, proxy):
# uc.TARGET_VERSION = 78
options = uc.ChromeOptions()
ua = UserAgent()
userAgent = ua.random
#print(userAgent)
options.add_argument(f'user-agent={userAgent}')
options.add_argument("--proxy-server=socks5://" + str(proxy))
options.add_argument(
"--host-resolver-rules=\"MAP * ~NOTFOUND , EXCLUDE myproxy\"")
print('Proxy: ' + str(proxy))
options.add_extension("./extensions/buster_chrome.crx")
options.add_extension("./extensions/xpather.crx")
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument("--enable-features=ReaderMode")
options.add_argument('--ignore-ssl-errors=yes')
options.add_argument('--ignore-certificate-errors')
# Stricter preferences.
prefs = {
"profile.managed_default_content_settings.images": 2,
"profile.default_content_setting_values.notifications": 2,
"profile.managed_default_content_settings.stylesheets": 2,
"profile.managed_default_content_settings.cookies": 2,
"profile.managed_default_content_settings.javascript": 1,
"profile.managed_default_content_settings.plugins": 1,
"profile.managed_default_content_settings.popups": 2,
"profile.managed_default_content_settings.geolocation": 2,
"profile.managed_default_content_settings.media_stream": 2,
}
prefs1 = {
"profile.managed_default_content_settings.images": 1,
"profile.managed_default_content_settings.popups": 2,
"profile.default_content_setting_values.notifications": 2,
"profile.managed_default_content_settings.geolocation": 2,
"profile.managed_default_content_settings.stylesheets": 2,
}
options.add_experimental_option("prefs", prefs1)
options.binary_location = binary_path
driver = uc.Chrome(chrome_options=options)
driver.execute_script(
"Object.defineProperty(navigator, 'webdriver', {get: () => false})")
driver.set_page_load_timeout(120)
try:
driver.get('https://www.yinsiduanxin.com/mail.html')
navigation_start = driver.execute_script(
"return window.performance.timing.navigationStart")
dom_complete = driver.execute_script(
"return window.performance.timing.domComplete")
driver.execute_script("window.open('https://discord.com/register')")
waittime = int(round(dom_complete - navigation_start)) / 1000
print("Time to connect & load the Discord page: " + str(waittime))
except Exception as e:
print("failed to connect\nException: " + str(e))
proxy_cleaner(proxy)
driver.quit()
return "Did not load page.", "Did not get token."
try:
wait = WebDriverWait(driver, 10)
wait.until(
EC.presence_of_element_located(
(By.XPATH, "//button[contains(string(), '随机邮箱')]"))).click()
except Exception as e:
print("Proxy error: " + str(e))
proxy_cleaner(proxy)
driver.quit()
return "Did not load page.", "Did not get token."
wait = WebDriverWait(driver, 30)
emaill = wait.until(
EC.presence_of_element_located(
(By.XPATH, "//span[contains(string(), '@mailscode.com')]"))).text
driver.switch_to.window(driver.window_handles[1])
sleeptime = int(500) / 1000
try:
wait = WebDriverWait(driver, 30)
enter_searchbar = wait.until(
EC.presence_of_element_located((By.NAME, "email")))
enter_searchbar.send_keys(emaill)
time.sleep(sleeptime)
enter_user = driver.find_element_by_name("username")
enter_user.send_keys(user)
time.sleep(sleeptime)
enter_passwd = driver.find_element_by_name("password")
enter_passwd.send_keys(passwd)
time.sleep(sleeptime)
enter_month = driver.find_element_by_id("react-select-2-input")
enter_month.send_keys(selection_month, Keys.ENTER)
time.sleep(sleeptime)
enter_day = driver.find_element_by_id("react-select-3-input")
enter_day.send_keys(selection_day, Keys.ENTER)
time.sleep(sleeptime)
enter_year = driver.find_element_by_id("react-select-4-input")
enter_year.send_keys(random.randint(1988, 1997), Keys.ENTER)
time.sleep(sleeptime)
try:
driver.find_element_by_xpath("//input[@type='checkbox']").click()
except:
pass
driver.find_element_by_xpath("//button[@type='submit']").click()
except Exception as e:
print("Value input failed due to unloaded elements. \nError: " +
str(e))
proxy_cleaner(proxy)
driver.quit()
return "Did not load page.", "Did not grab token."
time.sleep(1)
try:
# randomly stops working for some reason, this is just a check.
driver.find_element_by_xpath("//button[@type='submit']").click()
except:
pass
try:
driver.find_element_by_xpath(
"//span[contains(string(), 'Password is too weak or common to use')]"
)
enter_passwd = driver.find_element_by_name("password")
passwd = passwd + "321!@#"
enter_passwd.send_keys("321!@#")
time.sleep(sleeptime)
driver.find_element_by_xpath("//button[@type='submit']").click()
print("Fixed password being too short.")
except Exception as e:
print("Password was strong enough.") # \nError: " + str(e))
try:
driver.find_element_by_xpath(
"//div[contains(string(), 'You are being rate limited.')]"
).is_displayed()
result = ratelimit()
if "429" in str(result[1]):
print("Ratelimited for " + str(round(result[1]['retry_after'])) +
" seconds. Waiting until that is over.")
time.sleep(int(round(result[1]['retry_after'])))
driver.find_element_by_xpath("//button[@type='submit']").click()
print(result[0] + " " + result[1])
except Exception as e:
print("Registration was not ratelimited.") # \nError: " + str(e))
try:
wait = WebDriverWait(driver, 30)
wait.until(
EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, "iframe[name^='a-']")))
wait.until(EC.element_to_be_clickable(
(By.ID, "recaptcha-anchor"))).click()
time.sleep(2)
except Exception as e:
print("Could not find captcha. \nError: " + str(e))
proxy_cleaner(proxy)
driver.quit()
return "Did not load page.", "Did not grab token."
actions = ActionChains(driver)
actions.send_keys(Keys.TAB + " ")
actions.perform()
while True:
try:
wait = WebDriverWait(driver, 8)
desired_url = "https://discord.com/channels/@me"
wait.until(lambda driver: driver.current_url == desired_url)
break
except:
pass
# try:
# wait.until(EC.frame_to_be_available_and_switch_to_it((By.XPATH, "//div//iframe[@title='recaptcha challenge']")))
# except Exception as e:
# print(str(e))
# actions = ActionChains(driver)
# actions.send_keys(Keys.TAB + Keys.TAB + Keys.TAB + " ")
# print("first:")
# time.sleep(5)
# actions.send_keys(Keys.TAB + Keys.TAB + " ")
# print("second")
# actions.perform()
# try:
# wait = WebDriverWait(driver, 30)
# wait.until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, "iframe[name^='a-']")))
# wait.until(EC.presence_of_element_located((By.XPATH, "//div[@class='rc-audiochallenge-error-message']")))
# print("succeeded.")
# except:
# print("passed")
# wait = WebDriverWait(driver, 600)
# desired_url = "https://discord.com/channels/@me"
# wait.until(lambda driver: driver.current_url == desired_url)
# print("Captcha passed.")
driver.delete_all_cookies()
driver.switch_to.window(driver.window_handles[0])
time.sleep(1)
wait = WebDriverWait(driver, 20)
driver.find_element_by_xpath(
"//button[contains(string(), '接收邮件')]").click()
time.sleep(0.5)
wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//td[contains(string(), 'Discord')]"))).click()
time.sleep(0.5)
driver.find_element_by_xpath(
"//a[contains(string(), 'Verify Email')]").click()
driver.switch_to.window(driver.window_handles[2])
try:
wait = WebDriverWait(driver, 3)
wait.until(
EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, "iframe[name^='a-']")))
wait.until(EC.element_to_be_clickable(
(By.ID, "recaptcha-anchor"))).click()
time.sleep(2)
driver.switch_to.default_content
actions = ActionChains(driver)
actions.send_keys(Keys.TAB + " ")
actions.perform()
except:
pass
try:
wait = WebDriverWait(driver, 60)
wait.until(
EC.element_to_be_clickable((By.XPATH, "//button[@type='button']")))
print("Second captcha solved.")
except:
print("Could not find the button.")
time.sleep(0.5)
# driver.switch_to.window(driver.window_handles[2])
# try:
# driver.find_element_by_xpath("//h2[contains(string(), 'Add Friend')]")
# print("Token works fine.")
# except Exception as e:
# print("We have been either email or phone-locked.\n" + str(e))
file1 = open("results/verifiedaccs.txt", "a+")
file1.write("\n\nUsername: {}".format(user))
file1.write("\nEmail: {}".format(emaill))
file1.write("\nPassword: {}".format(passwd))
token = gettoken(driver)
print("Result: " + str(token))
file1.write("\nToken: {}".format(token))
#if int(waittime) < 5:
# with open("config/fastwork.txt", "a+") as file2:
# if str(proxy).strip("\n") not in file2.readlines():
# file2.write("{}\n".format(proxy))
#elif int(waittime) < 10:
# with open("config/medwork.txt", "a+") as file3:
# if str(proxy).strip("\n") not in file3.readlines():
# file3.write("{}\n".format(proxy))
return emaill, token
def __init__(self, chrome_path=None, verbose=False, chrome_version=None):
self.chrome_path = chrome_path
self.verbose = verbose
self.pid = {}
self.driver = None
self.ready = False
self.wanted_url = None
self.time_last_cookie_dump = time.monotonic()
# Initialize Chrome & load the cookie store
logger = logging.getLogger(name="ProxiedBrowser(init)")
service_log_path = './chrome_service_log.log' if self.verbose else os.devnull
options = uc.ChromeOptions()
options.add_argument(
'--no-first-run --no-service-autorun --password-store=basic')
if self.chrome_path is not None:
logger.debug('Forcing binary path to %s', chrome_path)
options.binary_location = self.chrome_path
try:
self.driver = driver = uc.Chrome(service_log_path=service_log_path,
options=options,
version_main=chrome_version)
except urllib.error.HTTPError as e:
logger.error('Downloading chromedriver %i failed: %s',
chrome_version, str(e))
raise e
except Exception as e:
logger.error("Failed to initialize Chrome: %s", str(e))
raise e
# Store Chrome' pid for last ressort cleanup
self.pid['chromedriver'] = driver.service.process.pid
self.pid['chrome'] = driver.browser_pid
logger.info(
'chromedriver version ' + colorama.Style.BRIGHT + '%s' +
colorama.Style.RESET_ALL + ' running as pid ' +
colorama.Style.BRIGHT + '%i' + colorama.Style.RESET_ALL +
' driving Chrome version ' + colorama.Style.BRIGHT + '%s' +
colorama.Style.RESET_ALL + ' running as pid ' +
colorama.Style.BRIGHT + '%i' + colorama.Style.RESET_ALL,
driver.capabilities['chrome']['chromedriverVersion'],
self.pid['chromedriver'], driver.capabilities['browserVersion'],
self.pid['chrome'])
try:
driver.get('chrome://version')
except Exception as e:
logger.critical(
'Cannot navigate to internal page. Something is REALLY broken; %s',
str(e))
raise e
cookies = list()
logger.info('Trying to load existing cookie...')
try:
with open(cookie_store, 'r') as cookie_file:
cookies = json.load(codecs.getwriter('utf-8')(cookie_file))
except:
logger.debug('No cookie to import...')
else:
for cookie in cookies:
prefix = "http://"
if cookie['domain'].startswith('.'):
prefix = "http://www"
if cookie['domain'].startswith('.www.'): #Yes, it happened...
prefix = "http://"
cookie['domain'] = cookie['domain'].replace(
'.www.', 'www.')
driver.get('{}{}'.format(prefix, cookie['domain']))
if 'sameSite' in cookie:
if cookie['sameSite'] == 'None':
cookie['sameSite'] = 'Strict'
driver.add_cookie(cookie)
logger.debug('Added %i cookie(s)', len(cookies))
self.ready = True
def main(username, password, users_list, comments_list):
# with open('./backend/static/instabot/lists/usragents.txt') as f:
# USER_AGENT_PARTS = f.readlines()
# with open('./lists/usragents.txt') as f:
# USER_AGENT_PARTS = f.readlines()
opts = uc.ChromeOptions()
opts.add_argument('--headless')
opts.add_argument('--disable-gpu')
opts.add_argument('--no-sandbox')
opts.add_argument('--disable-dev-shm-usage')
opts.add_argument('--remote-debugging-port=9222')
base_url = 'https://www.instagram.com'
print("got before")
driver = uc.Chrome(options=opts)
print("got after")
# driver = uc.Chrome()
opts.add_argument("--example-flag")
driver.get(base_url)
wait_random(3, 6)
try:
cookie_div = driver.find_element_by_class_name("mt3GC")
cookie_btn = cookie_div.find_elements_by_tag_name('button')[0]
wait_random(3, 6)
cookie_btn.click()
print("got after cookie btn")
except NoSuchElementException as e:
pass
login_form = driver.find_element_by_id('loginForm')
form_usr = login_form.find_elements_by_tag_name('label')[0]
form_pass = login_form.find_elements_by_tag_name('label')[1]
write(form_usr, username)
wait_random(1, 3)
print("got after username")
write(form_pass, password)
wait_random(1, 4)
print("got after password")
form_pass.send_keys(Keys.ENTER)
wait_random(4, 8)
try:
save_login = driver.find_element_by_class_name("cmbtv")
save_login.click()
wait_random(2, 4)
print("got after savelogin")
except NoSuchElementException:
pass
try:
notifications_div = driver.find_element_by_class_name("mt3GC")
notifications_btn = notifications_div.find_elements_by_tag_name('button')[1]
wait_random(2, 4)
notifications_btn.click()
print("got after notifbtn")
except NoSuchElementException:
pass
wait_random(2, 7)
# if len(users_list) > len(comments_list):
# diff = len(users_list) - len(comments_list)
# comments_list.extend(comments_list[:diff])
for user, comm in zip(users_list, comments_list):
try:
driver.get(base_url + '/' + user + '/')
wait_random(2, 5)
article_holder = driver.find_element_by_class_name('ySN3v')
first_photo_link = article_holder.find_element_by_tag_name('a')
driver.get(first_photo_link.get_attribute('href'))
wait_random(3, 5)
like_div = driver.find_element_by_class_name('eo2As')
like_btn, comm_btn = like_div.find_elements_by_tag_name('button')[:2]
like_svg = like_btn.find_element_by_tag_name('svg')
print(like_svg.get_attribute('fill'))
if like_svg.get_attribute('fill') != '#ed4956':
like_svg.click()
print('liked')
wait_random(2, 6)
print("got after like")
comm_btn.click()
wait_random(1, 2)
comm_form = driver.find_element_by_class_name('RxpZH').find_element_by_tag_name('form')
comm_text = comm_form.find_element_by_tag_name('textarea')
write(comm_text, comm)
comm_text.send_keys(Keys.ENTER)
wait_random(2, 4)
print("got after user")
except NoSuchElementException:
pass
except WebDriverException:
pass
wait_random(5, 10)
driver.close()
def __init__(self, **kwargs):
super().__init__()
option = uc.ChromeOptions()
# option.add_argument('--headless')
option.add_argument("--start-maximized")
self.browser = uc.Chrome(options=option)
def __init__(self):
self.options = uc.ChromeOptions()
self.options.headless = True
self.options.add_argument('--headless')
self.driver = uc.Chrome(options=self.options)
def test():
import sys, os
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
import undetected_chromedriver as uc
import threading
def collector(
driver: uc.Chrome,
stop_event: threading.Event,
on_event_coro: Optional[Callable[[List[str]],
Awaitable[Any]]] = None,
listen_events: Sequence = ("browser", "network", "performance"),
):
def threaded(driver, stop_event, on_event_coro):
async def _ensure_service_started():
while (getattr(driver, "service", False)
and getattr(driver.service, "process", False)
and driver.service.process.poll()):
print("waiting for driver service to come back on")
await asyncio.sleep(0.05)
# await asyncio.sleep(driver._delay or .25)
async def get_log_lines(typ):
await _ensure_service_started()
return driver.get_log(typ)
async def looper():
while not stop_event.is_set():
log_lines = []
try:
for _ in listen_events:
try:
log_lines += await get_log_lines(_)
except:
if logging.getLogger().getEffectiveLevel(
) <= 10:
traceback.print_exc()
continue
if log_lines and on_event_coro:
await on_event_coro(log_lines)
except Exception as e:
if logging.getLogger().getEffectiveLevel() <= 10:
traceback.print_exc()
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(looper())
t = threading.Thread(target=threaded,
args=(driver, stop_event, on_event_coro))
t.start()
async def on_event(data):
print("on_event")
print("data:", data)
def func_called(fn):
def wrapped(*args, **kwargs):
print("func called! %s (args: %s, kwargs: %s)" %
(fn.__name__, args, kwargs))
while driver.service.process and driver.service.process.poll(
) is not None:
time.sleep(0.1)
res = fn(*args, **kwargs)
print("func completed! (result: %s)" % res)
return res
return wrapped
logging.basicConfig(level=10)
options = uc.ChromeOptions()
options.set_capability("goog:loggingPrefs", {
"performance": "ALL",
"browser": "ALL",
"network": "ALL"
})
driver = uc.Chrome(version_main=96, options=options)
# driver.command_executor._request = timeout(seconds=1)(driver.command_executor._request)
driver.command_executor._request = func_called(
driver.command_executor._request)
collector_stop = threading.Event()
collector(driver, collector_stop, on_event)
driver.get("https://nowsecure.nl")
time.sleep(10)
driver.quit()
def browser(proxy):
global workers
# email = accountinfo.get_email()
# if not email:
# workers -= 1
# return
options = uc.ChromeOptions()
ua = UserAgent()
userAgent = ua.chrome
options.add_argument(f'user-agent={userAgent}')
#options.add_argument("--headless")
options.add_argument("--proxy-server={}://{}".format(proxyType, proxy))
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument("--enable-features=ReaderMode")
options.add_argument('--ignore-ssl-errors=yes')
options.add_argument('--ignore-certificate-errors')
prefs1 = {
"profile.managed_default_content_settings.images": 1,
"profile.managed_default_content_settings.popups": 2,
"profile.default_content_setting_values.notifications": 2,
"profile.managed_default_content_settings.geolocation": 2,
"profile.managed_default_content_settings.stylesheets": 2,
}
options.add_experimental_option("prefs", prefs1)
options.binary_location = r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe"
try:
driver = uc.Chrome(chrome_options=options)
stealth(
driver,
languages=["en-US", "en"],
user_agent=userAgent,
vendor="Google Inc.",
platform="Win32",
webgl_vendor="Intel Inc.",
renderer="Intel Iris OpenGL Engine",
fix_hairline=True,
)
url = "https://discord.com/register"
#url = "https://accounts.google.com/signin/v2/identifier?service=youtube&uilel=3&passive=true&continue=https%3A%2F%2Fwww.youtube.com%2Fsignin%3Faction_handle_signin%3Dtrue%26app%3Ddesktop%26hl%3Den%26next%3Dhttps%253A%252F%252Fwww.youtube.com%252F&hl=en&ec=65620&flowName=GlifWebSignIn&flowEntry=ServiceLogin"
try:
driver.get(url)
except WebDriverException:
workers -= 1
driver.quit()
return
Thread(target=await_tab, args=(driver, ), daemon=True).start()
sleeptime = 0.4
email = "testing1234crazytown{}@gmail.com".format(
random.randint(0, 100000))
username = "******".format(random.randint(0, 100000))
password = "******"
selection_month = random.choice([
'December', 'January', 'February', 'March', 'April', 'May', 'June',
'July', 'August', 'September', 'October', 'November'
])
selection_day = random.randint(1, 28)
try:
wait = WebDriverWait(driver, 30)
enter_searchbar = wait.until(
EC.presence_of_element_located((By.NAME, "email")))
slow_typing(enter_searchbar, email, 20)
time.sleep(sleeptime)
enter_user = driver.find_element_by_name("username")
slow_typing(enter_user, username, 20)
time.sleep(sleeptime)
enter_password = driver.find_element_by_name("password")
slow_typing(enter_password, password, 20)
time.sleep(sleeptime)
enter_month = driver.find_element_by_id("react-select-2-input")
slow_typing(enter_month, selection_month, 20)
enter_month.send_keys(Keys.ENTER)
time.sleep(sleeptime)
enter_day = driver.find_element_by_id("react-select-3-input")
slow_typing(enter_day, selection_day, 20)
enter_day.send_keys(Keys.ENTER)
time.sleep(sleeptime)
enter_year = driver.find_element_by_id("react-select-4-input")
slow_typing(enter_year, random.randint(1988, 1997), 20)
enter_year.send_keys(Keys.ENTER)
time.sleep(sleeptime)
try:
driver.find_element_by_xpath(
"//input[@type='checkbox']").click()
except Exception:
pass
driver.find_element_by_xpath("//button[@type='submit']").click()
try:
WebDriverWait(driver, 30).until(
EC.frame_to_be_available_and_switch_to_it(
(By.XPATH, '//iframe[contains(@title, "widget")]')))
WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "div#checkbox.checkbox"))).click()
print("Found one!")
except Exception:
print("failed to find iframe!")
workers -= 1
driver.quit()
return
except Exception as e:
print(e)
except Exception as e:
print(e)
time.sleep(30)
workers -= 1
driver.quit()
return
