def getCode(driver):
# 保存浏览器当前页面
driver.save_screenshot("page.png")
# 从页面中截取验证码
vcode = driver.find_element_by_xpath("//*[@id='app']/div/div/div/div[3]/form/div[3]/div/div[2]/img")
# 1、获取验证码上下左右边界左边
loc = vcode.location
print(loc)
size = vcode.size
print(size)
left = loc['x'] * 2
top = loc['y'] * 2
right = (loc['x'] + size['width']) * 2
button = (loc['y'] + size['height']) * 2
# 截取页面中的验证码
page_pic = Image.open('page.png')
# 进行截图：参数时一个元组（left,top,right,button）
v_code_pic = page_pic.crop((left, top, right, button))
v_code_pic.save('yzm.png')
# 利用超级鹰识别验证码中的内容，每次10分
yz = Chaojiying(username='******', password='******', soft_id='901845')
with open('yzm.png', 'rb')as f:
pic = f.read()
# 得到验证码识别的结果
result = yz.post_pic(pic, codetype='1004')['pic_str']
return result
def login():
'''
微博的登陆
:return:
'''
driver = webdriver.Chrome()
try:
driver.maximize_window()
# 加载登录页面
url = 'http://www.weibo.com/login.php'
driver.get(url)
time.sleep(2)
print('输入用户名...')
elem_user = driver.find_element_by_id("loginname")
elem_user.clear()
elem_user.send_keys(loginname)
time.sleep(2)
print('输入密码...')
elem_pwd = driver.find_element_by_name("password")
elem_pwd.clear()
elem_pwd.send_keys(password)
time.sleep(3)
checkCode = driver.find_element_by_xpath(
'//*[@id="pl_login_form"]/div/div[3]/div[3]/div/input')
driver.save_screenshot('./images/weibo.png')
img = driver.find_element_by_xpath(
'//*[@id="pl_login_form"]/div/div[3]/div[3]/a/img')
left = img.location['x'] # 验证码图片左上角横坐标
top = img.location['y'] # 验证码图片左上角纵坐标
right = left + img.size['width'] # 验证码图片右下角横坐标
bottom = top + img.size['height'] # 验证码图片右下角纵坐标
im = Image.open('./images/weibo.png')
im_crop = im.crop(
(left, top, right, bottom)) # 这个im_crop就是从整个页面截图中再截出来的验证码的图片
im_crop.save('./images/zrecaptchar.png')
chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
# 识别验证码
bytes_array = BytesIO()
im_crop.save(bytes_array, format='PNG')
strcode = chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
print(strcode)
print(strcode['pic_str'])
checkCode.send_keys(strcode['pic_str'])
print('登陆微博...')
'//*[@id="pl_login_form"]/div/div[3]/div[6]/a'
login_btn = driver.find_element_by_xpath(
'//*[@id="pl_login_form"]/div/div[3]/div[6]/a')
login_btn.click()
print('已经点击')
time.sleep(10)
print(driver.current_url)
driver.quit()
except Exception as e:
print('login error.')
def pick_code(self):
time.sleep(3)
pick_img_label = self.browser.find_element_by_css_selector('img.geetest_item_img') # 获取点触图片标签
src = pick_img_label.get_attribute('src') # 获取点触图片链接
img_content = requests.get(src).content # 获取图片二进制内容
f = BytesIO()
f.write(img_content)
img0 = Image.open(f) # 将图片以文件的形式打开，主要是为了获取图片的大小
scale = [pick_img_label.size['width'] / img0.size[0],
pick_img_label.size['height'] / img0.size[1]] # 获取图片与浏览器该标签大小的比例
cjy = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
result = cjy.post_pic(img_content, '9005') # 发送图片并获取结果
if result['err_no'] == 0: # 对结果进行分析
position = result['pic_str'].split('|') # position = ['110,234','145,247','25,185']
position = [[int(j) for j in i.split(',')] for i in position] # position = [[110,234],[145,247],[25,185]]
for items in position: # 模拟点击
ActionChains(self.browser).move_to_element_with_offset(pick_img_label, items[0] * scale[0],
items[1] * scale[1]).click().perform()
time.sleep(1)
time.sleep(2)
# 点击登录
certern_btn = self.browser.find_element_by_css_selector('div.geetest_commit_tip')
certern_btn.click()
return cjy, result
class Crack12306:
def __init__(self):
self._url = 'https://kyfw.12306.cn/otn/login/init'
self._browser = webdriver.Chrome()
self._wait = WebDriverWait(self._browser, 20)
self._username = USERNAME
self._password = PASSWORD
self._chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
self._pic_id = None
def __del__(self):
self._browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self._browser.get(self._url)
username = self._wait.until(
EC.presence_of_element_located((By.ID, 'username')))
password = self._wait.until(
EC.presence_of_element_located((By.ID, 'password')))
username.send_keys(self._username)
password.send_keys(self._password)
def get_12306_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self._wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, '.touclick .touclick-image')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_12306_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = (location['y'],
location['y'] + size['height'],
location['x'],
location['x'] + size['width'])
return top, bottom, left, right
def get_screen_shot(self):
"""
获取网页截图
:return: 截图对象
"""
screen_shot = self._browser.get_screenshot_as_png()
screen_shot = Image.open(BytesIO(screen_shot))
return screen_shot
def get_12306_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screen_shot = self.get_screen_shot()
captcha = screen_shot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
element = self.get_12306_element()
for location in locations:
print(location)
ActionChains(self._browser).move_to_element_with_offset(
element, location[0], location[1]).click().perform()
time.sleep(1)
def login(self):
"""
登录
:return: None
"""
submit = self._wait.until(
EC.element_to_be_clickable((By.ID, 'loginSub')))
submit.click()
time.sleep(10)
def check_login_success(self):
"""
检查是否登录成功
:return: None
"""
success = False
try:
self._browser.find_element_by_id('loginSub')
self._chaojiying.report_error(self._pic_id)
except NoSuchElementException:
success = True
return success
def crack(self):
"""
破解入口
:return: None
"""
self.open()
# 获取验证码图片
image = self.get_12306_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self._chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
self._pic_id = result.get('pic_id')
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
# 登录
self.login()
# 失败后重试
success = self.check_login_success()
if not success:
self.crack()
else:
print('登录成功')
class CrackTouClick():
def __init__(self):
self.url = 'https://passport.bilibili.com/login'
self.browser = webdriver.Firefox()
self.wait = WebDriverWait(self.browser, 20)
self.phone = PHONE
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def __del__(self):
self.browser.close()
def open(self):
"""
打开网页输入用户名和密码
:return: None
"""
self.browser.get(self.url)
self.browser.fullscreen_window()
phone = self.wait.until(
EC.presence_of_element_located((By.ID, 'login-username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'login-passwd')))
phone.send_keys(self.phone)
time.sleep(2)
password.send_keys(self.password)
time.sleep(2)
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located((
By.CSS_SELECTOR,
'body > div.geetest_panel.geetest_wind > div.geetest_panel_box.geetest_no_logo.geetest_panelshowclick'
)))
return element
def get_size(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
size = element.size
width = int(size['width'])
height = int(size['height'])
return (width, height)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
im = self.get_touclick_element()
im.screenshot('screenshot.png')
screenshot = Image.open('screenshot.png')
return screenshot
def get_touclick_image(self, name='captcha_resize.png'):
"""
获取验证码图片
:return: 图片对象
"""
screenshot = self.get_screenshot()
time.sleep(5)
width, height = self.get_size()
print('验证码大小', width, height)
time.sleep(2)
captcha = screenshot
# 改变截图的大小 和原图一致
captcha = captcha.resize((width, height))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(
EC.presence_of_element_located((
By.CSS_SELECTOR,
'body > div.geetest_panel.geetest_wind > div.geetest_panel_box.geetest_no_logo.geetest_panelshowclick > div.geetest_panel_next > div > div > div.geetest_panel > a'
)))
button.click()
time.sleep(10)
print('已验证')
def login(self):
"""
登录
:return: None
"""
login = self.wait.until(
EC.element_to_be_clickable((By.CSS_SELECTOR, 'a.btn.btn-login')))
login.click()
time.sleep(5)
print('请验证')
def crack(self):
"""
破解入口
:return: None
"""
self.open()
# 点击登录
self.login()
# 获取验证码图片
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format('PNG'))
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
self.touch_click_verify()
time.sleep(5)
# 判定是否成功
current_url = self.browser.current_url
if current_url != self.url:
success = True
# 失败后重试
if not success:
self.crack()
else:
print('验证成功')
class CrackTouClick():
def __init__(self):
self.url = 'https://ostec.uestc.edu.cn/authcas/login?service=http://202.115.16.61/eems/Login/doLogin'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.username = USERNAME
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def open(self):
self.browser.maximize_window()
self.browser.get(self.url)
username = self.wait.until(
EC.presence_of_element_located((By.ID, 'username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'password')))
username.send_keys(self.username)
password.send_keys(self.password)
def get_touclick_button(self): #返回登陆按钮
button = self.wait.until(
EC.element_to_be_clickable((By.ID, 'action-form-submit')))
return button
def get_touclick_element(self): #获得验证码对象
self.wait.until(EC.presence_of_all_elements_located)
element = self.wait.until(
EC.presence_of_element_located(
(By.XPATH, '//*[@id="captcha-master"]')))
return element
def get_position(self): #获取验证码位置
element = self.get_touclick_element()
time.sleep(5)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self): #得到网页截图
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'): #获取验证码图片
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
#得到位置点
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(10)
def touch_click_verify(self): #点击提交验证
button = self.wait.until(
EC.element_to_be_clickable((By.ID, 'captcha-control-submit')))
return button
def crack(self):
self.open()
# 点击登陆按钮
button = self.get_touclick_button()
button.click()
# 获取验证码图片
image = self.get_touclick_image(name='captcha.png')
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
button_tijiao = self.touch_click_verify()
button_tijiao.click()
class CrackWeibo():
def __init__(self, username, password):
self.url = 'https://passport.weibo.cn/signin/login'
self.browser = webdriver.Chrome(chrome_options=chrome_options)
self.wait = WebDriverWait(self.browser, 20)
self.phone = username
self.password = password
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
def open(self):
"""打开网页，输入用户名和密码,点击登陆,切换到验证码的页面"""
self.browser.get(self.url)
phone = self.wait.until(EC.visibility_of_element_located((By.XPATH, '//*[@id="loginName"]')))
password = self.wait.until(EC.visibility_of_element_located((By.ID, 'loginPassword')))
phone.send_keys(self.phone)
password.send_keys(self.password)
button = self.wait.until(EC.visibility_of_element_located((By.XPATH, '//*[@id="loginAction"]')))
button.click()
def password_error(self):
"""
判断是否密码错误
:return:
"""
try:
return WebDriverWait(self.browser, 5).until(
EC.text_to_be_present_in_element((By.ID, 'errorMsg'), '用户名或密码错误'))
except TimeoutException:
return False
def login_successfully(self):
"""
判断是否登录成功
:return:
"""
try:
return bool(
WebDriverWait(self.browser, 5).until(EC.presence_of_element_located((By.XPATH, '//*[@id="app"]/div[1]/div[1]/div[1]/div[1]'))))
except TimeoutException:
return False
def get_weibo_button(self):
"""获取验证按钮"""
button = self.wait.until(EC.visibility_of_element_located((By.XPATH, '//*[@id="embed-captcha"]/div/div[2]/div[1'
']/div[3]/span[1]')))
return button
def get_weibo_element(self):
"""获取验证图片对象"""
element = self.wait.until(EC.visibility_of_element_located((By.XPATH, '/html/body/div[3]/div[2]/div[1]')))
return element
def get_position(self, element):
"""获取验证图片对象位置"""
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
return top, bottom, left, right
def get_weibo_image(self, top, bottom, left, right):
"""获取验证码图片"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot)).resize((1200, 764))
captcha = screenshot.crop((left, top+30, right, bottom+30))
return captcha
def picture_recognition(self, image):
"""图片的文字位置，用超级鹰识别，返回识别的json格式"""
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
return result
def get_word_points(self, captcha_result):
"""解析文字的识别结果"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')] for group in groups]
return locations
def touch_click_words(self, locations):
"""点击验证码图片里的文字"""
for location in locations:
ActionChains(self.browser).move_to_element_with_offset(self.get_weibo_element(), location[0], location[1]-30).click().perform()
time.sleep(1)
button = self.wait.until(EC.visibility_of_element_located((By.XPATH, '/html/body/div[3]/div[2]/div[1]/div/div/d'
'iv[3]/a/div')))
button.click()
def validation_error(self, result):
"""调用超级鹰识别失败接口返回积分"""
im_id = result['pic_id']
self.chaojiying.report_error(im_id)
def get_cookies(self):
"""获取登陆后的页面信息，然后关闭浏览器"""
return self.browser.get_cookies()
self.browser.close()
def main(self):
"""破解入口"""
SUCCESS = False
# 登陆页面的操作,跳转到验证页面
self.open()
if self.password_error():
return {
'status': 2,
'content': '用户名或密码错误'
}
else:
# 验证页面的操作
self.get_weibo_button().click() # 点击验证按钮
# 如果不需要验证码直接登录成功
if self.login_successfully():
cookies = self.get_cookies()
return {
'status': 1,
'content': cookies
}
else:
while not SUCCESS:
print("开始识别验证码")
element = self.get_weibo_element() # 获取验证码对象
print("开始获取元素位置")
top, bottom, left, right = self.get_position(element) # 获取元素的位置
print("根据元素位置",top, bottom, left, right, '获取验证码图片')
image = self.get_weibo_image(top, bottom, left, right) # 获取验证码图片
print("超级鹰开始识别图片")
captcha_result = self.picture_recognition(image) # 传图片给超级鹰接口识别,返回json格式的识别结果
print("识别结果：", captcha_result)
locations = self.get_word_points(captcha_result) # 解析超级鹰的识别结果
print("解析识别结果为坐标参数：", locations, "\n根据坐标开始点击验证码图片")
# 根据识别结果，点击验证码
self.touch_click_words(locations)
#判断是否验证成功
SUCCESS = self.login_successfully()
if SUCCESS:
cookies = self.get_cookies()
return {
'status': 3,
'content': cookies
}
else:
self.validation_error(captcha_result)
print("识别失败,重新开始\n")
from PIL import Image
import pytesseract
"""下载验证码图片"""
# 验证码地址
# https://www.renrendai.com/passport/index/captcha?time=1551682134111
# url = "https://www.renrendai.com/passport/index/captcha?time=1551682134111"
url = "http://www.testingedu.com.cn:8000/index.php?m=Home&c=User&a=verify&r=0.8834463023296559"
response = requests.get(url).content
#将图片写入文件
with open('C:\\Users\\Administrator\\Desktop\\rryz.png', 'wb') as f:
f.write(response)
# '''识别验证码'''
# #第一步：通过内置模块PIL打开文件
# # with open('rryz.png','wb') as f:
# pic = Image.open('C:\\Users\\Administrator\\Desktop\\rryz.png')
# #第二步：识别图片中的内容
# str1 = pytesseract.image_to_string(pic, lang="chi_sim")# 复杂的验证码，直接识别不了（要进行降噪，，，，处理）
# print("验证码识别", str1)
#读取文件内容
with open('C:\\Users\\Administrator\\Desktop\\rryz.png', 'rb') as f:
pic1 = f.read()
#调用第三方打码平台接口识别验证码
from chaojiying import Chaojiying
yz = Chaojiying(username='******',
password='******',
soft_id='904603')
res = yz.post_pic(pic1, 1902)
print(res['pic_str'])
right = (loc['x'] + size['width']) * 2
button = (loc['y'] + size['height']) * 2
# 截取页面中的验证码
page_pic = Image.open('page.png')
# 进行截图：参数时一个元组（left,top,right,button）
v_code_pic = page_pic.crop((left, top, right, button))
v_code_pic.save('yzm.png')
# 识别验证码中的内容
yz = Chaojiying(username='******', password='******', soft_id='901845')
with open('yzm.png', 'rb') as f:
pic = f.read()
print(pic)
# 得到验证码识别的结果
result = yz.post_pic(pic, codetype='1004')
print('result===')
print(result)
res = result['pic_str']
print('res===' + res)
# 第四步：输入验证码
driver.find_element_by_xpath(
"//*[@id='app']/div/div/div/div[3]/form/div[3]/div/div[1]/input"
).send_keys(res)
# 第五步：点击登录
driver.find_element_by_xpath(
"//*[@id='app']/div/div/div/div[3]/form/div[4]/div/button").click()
class Train():
"""
模拟登录12306
"""
def __init__(self):
"""
初始化数据
"""
self.url = 'https://kyfw.12306.cn/otn/login/init'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.username = '******'
self.password = '******'
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOLD_ID)
def __del__(self):
"""
关闭浏览器
:return: None
"""
time.sleep(10)
self.browser.close()
def open_page(self):
"""
打开网页，并输入账号密码
:return:None
"""
self.browser.get(self.url)
username = self.wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, '#username')))
password = self.wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, '#password')))
username.send_keys(self.username)
time.sleep(0.8)
password.send_keys(self.password)
def get_touclick_element(self):
"""
获取图片对象
:return: 图片对象
"""
img = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'touclick-image')))
return img
def get_position(self):
"""
获取验证码图片位置信息
:return: 验证码位置信息元组
"""
img = self.get_touclick_element()
time.sleep(2)
location = img.location
size = img.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_image(self, name='image.png'):
"""
将验证码图片从网页截图中裁剪出来
:return:验证码图片
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def verification_code_recognition(self, image):
"""
利用超级鹰识别验证码
:return: 识别结果
"""
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
result = self.chaojiying.post_pic(bytes_array.getvalue(), 9004)
return result
def get_point(self, captcha_result):
"""
解析识别结果
:param captcha_result:验证码的识别结果
:return: 解析后的结果（即正确的位置坐标）
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def click_word(self, locations):
"""
点击验证图片
:param locations: 验证码的坐标
:return: Nome
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def login(self):
"""
登录12306
:return:None
"""
login = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'btn200s')))
login.click()
def main(self):
"""
执行
:return:None
"""
# 打开网页，输入账号密码
self.open_page()
# 获取验证码图片
image = self.get_image()
# 识别验证码,其中9004是超级鹰的验证码类型
result = self.verification_code_recognition(image)
print(result)
# 获取验证码坐标信息
locations = self.get_point(result)
# 点击验证码
self.click_word(locations)
# 点击登录
time.sleep(1)
self.login()
class CrackCaptcha():
def __init__(self):
self.url = 'https://captcha3.scrape.cuiqingcai.com/'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.username = USERNAME
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def __del__(self):
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
# 填入用户名密码
username = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'input[type="text"]')))
password = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'input[type="password"]')))
username.send_keys(self.username)
password.send_keys(self.password)
def get_captcha_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'button[type="button"]')))
return button
def get_captcha_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
# 验证码图片加载出来
self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'img.geetest_item_img')))
# 验证码完整节点
element = self.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'geetest_panel_box')))
print('成功获取验证码节点')
return element
def get_captcha_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_captcha_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
screenshot.save('screenshot.png')
return screenshot
def get_captcha_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_captcha_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
ActionChains(self.browser).move_to_element_with_offset(
self.get_captcha_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_commit')))
button.click()
def crack(self):
"""
破解入口
:return: None
"""
self.open()
time.sleep(5)
# 点击验证按钮
button = self.get_captcha_button()
button.click()
# 获取验证码图片
image = self.get_captcha_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
self.touch_click_verify()
# 判定是否成功
success = self.wait.until(
EC.text_to_be_present_in_element((By.TAG_NAME, 'h2'), '登录成功'))
time.sleep(5)
if success:
print('登录成功！')
class Crack():
def __init__(self, username, passwd):
self.url = 'https://passport.bilibili.com/login'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 100)
self.BORDER = 31
self.passwd = passwd
self.username = username
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def open(self):
"""
打开浏览器,并输入查询内容
"""
self.browser.get(self.url)
keyword = self.wait.until(
EC.presence_of_element_located((By.ID, 'login-username')))
keyword.send_keys(self.username)
keyword = self.wait.until(
EC.presence_of_element_located((By.ID, 'login-passwd')))
keyword.send_keys(self.passwd)
btn = self.browser.find_element_by_xpath('//a[@class="btn btn-login"]')
btn.click()
def get_images(self, bg_filename='bg.png'):
"""
获取验证码图片
:return: 图片的location信息
"""
time.sleep(2)
self.browser.save_screenshot(bg_filename)
element = self.browser.find_element_by_xpath(
'//canvas[@class="geetest_canvas_bg geetest_absolute"]')
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
print('验证码位置', top, bottom, left, right)
screenshot = Image.open(bg_filename)
# 截取验证码图片
captcha = screenshot.crop((left, top, right, bottom))
captcha.save("./images/bzyzm.png")
def get_gap(self):
"""
获取缺口偏移量
:param img1: 不带缺口图片
:param img2: 带缺口图片
:return:
"""
# 识别验证码
im = open('./images/bzyzm.png',
'rb').read() # 本地图片文件路径 来替换 a.jpg 有时WIN系统须要//
result = self.chaojiying.post_pic(im, CHAOJIYING_KIND)
print(result)
result = result.get('pic_str').split(',')
result = int(result[0])
return int(result)
def get_track(self, distance):
"""
根据偏移量获取移动轨迹
:param distance: 偏移量
:return: 移动轨迹
"""
# 移动轨迹
track = []
# 当前位移
current = 0
# 减速阈值
mid = distance * 0.7
# 计算间隔
t = 0.05
# 初速度
v = 0
while current < distance:
if current < mid:
# 加速度为正2
a = 18
else:
# 加速度为负3
a = -6
# 初速度v0
v0 = v
# 当前速度v = v0 + at
v = v0 + a * t
# 移动距离x = v0t + 1/2 * a * t^2
move = v0 * t + 1 / 2 * a * t * t
# 当前位移
current += move
# 加入轨迹
track.append(round(move))
print('forword', current, distance)
v = 0
move = current - distance
# 加入轨迹
track.append(round(move))
return track
def get_slider(self):
"""
获取滑块
:return: 滑块对象
"""
while True:
try:
slider = self.browser.find_element_by_xpath(
'//div[@class="geetest_slider_button"]')
break
except:
time.sleep(0.5)
return slider
def move_to_gap(self, slider, track):
"""
拖动滑块到缺口处
:param slider: 滑块
:param track: 轨迹
:return:
"""
ActionChains(self.browser).click_and_hold(slider).perform()
while track:
x = random.choice(track)
#x=track.pop(0)
ActionChains(self.browser).move_by_offset(xoffset=x,
yoffset=0).perform()
track.remove(x)
time.sleep(0.005)
time.sleep(2)
print('release')
ActionChains(self.browser).release(slider).perform()
time.sleep(2)
#self.browser.quit()
def crack(self):
# 打开浏览器
self.open()
# 保存的图片名字
bg_filename = './images/bg.png'
fullbg_filename = './images/fullbg.png'
# 获取图片
self.get_images(bg_filename)
# 获取缺口位置
gap = self.get_gap()
print('缺口位置', gap)
track = self.get_track(gap - self.BORDER)
print('滑动滑块')
#print(track)
# 点按呼出缺口
slider = self.get_slider()
# 拖动滑块到缺口处
self.move_to_gap(slider, track)
#
time.sleep(1)
try:
mspan = self.browser.find_elements_by_class_name('gt_info_content')
if len(mspan) > 0:
info = mspan.text
print('info:', info)
if '怪物吃了拼图' in info:
print(mspan.text)
time.sleep(2)
self.crack()
mspan = self.browser.find_elements_by_class_name('gt_info_type')
if len(mspan) > 0:
info = mspan[0].text
print('info:', info)
if '验证失败:' in info:
time.sleep(2)
self.crack()
except Exception as e:
print(e)
class CrackTouClick(object):
def __init__(self, params):
self.url = 'http://www.baidu.com'
self.KeyUrl = 'https://ticket.urbtix.hk/internet/zh_TW/eventDetail/38663'
self.browser = webdriver.Chrome()
# self.browser_headless = True
self.wait = WebDriverWait(self.browser, 20)
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
# self.pool = redis.ConnectionPool(host='47.56.66.23', password='******', port=6379, db=0, max_connections=2)
# self.red = redis.Redis(connection_pool=self.pool)
self.params = params
def __del__(self):
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
# self.params = self.get_redis()
self.browser.get(self.url)
search = self.wait.until(EC.presence_of_element_located((By.ID, 'kw')))
search.send_keys("城市售票网")
baidu_click = self.wait.until(EC.presence_of_element_located((By.ID, 'su')))
baidu_click.click()
spw = self.wait.until(EC.presence_of_element_located((By.XPATH, '//*[@id="1"]/h3/a[1]')))
spw.click()
self.browser.switch_to.window(self.browser.window_handles[1])
if self.browser.current_url == "https://busy.urbtix.hk/":
time.sleep(4)
if self.browser.current_url == "https://busy.urbtix.hk/redirect.html":
time.sleep(4)
try:
self.browser.find_element_by_xpath('/html/body/div[2]/table/tbody/tr/td/table/tbody/tr[4]/td/a').Click()
except Exception as E:
print(E)
def login(self):
self.browser.get('https://ticket.urbtix.hk/internet/login/memberLogin')
while True:
time.sleep(2)
try:
j_username = self.wait.until(EC.presence_of_element_located((By.ID, 'j_username')))
j_username.clear()
j_username.send_keys(self.params.get("account"))
j_password = self.wait.until(EC.presence_of_element_located((By.ID, 'j_password')))
j_password.clear()
j_password.send_keys(self.params.get("password"))
break
except Exception as E:
print(E)
def get_touclick_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-hod-wrap')))
return button
def get_touclick_element(self, kind):
"""
获取验证图片对象
:return: 图片对象
"""
if kind == 1:
self.wait.until(EC.presence_of_element_located((By.ID, 'captchaImage')))
element = self.browser.find_element_by_xpath('//*[@id="captchaImage"]')
# element = self.wait.until(EC.presence_of_element_located((By.ID, 'captchaImage')))
elif kind == 2:
self.wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, '#captcha-image-input-key-container > table > tbody')))
element = self.browser.find_element_by_xpath('//*[@id="captcha-image-input-key-container"]/table/tbody/tr[1]')
elif kind == 3:
self.wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, '#captcha-image-input-key-container > table > tbody')))
element = self.browser.find_element_by_xpath('//*[@id="captcha-image-input-key-container"]/table/tbody/tr[2]')
return element
def get_position(self, kind):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element(kind)
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
time.sleep(5)
# 424,474,703,823
# 533 583 622 872
# 583 633 622 872
return top, bottom, left, right
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, kind=1):
"""
获取验证码图片
:return: 图片对象
"""
name = "captcha{}.png".format(kind)
top, bottom, left, right = self.get_position(kind)
print(top, bottom, left, right)
im = self.get_screenshot()
self.browser.save_screenshot('full_snap.png')
if kind == 1 and self.browser_headless:
self.browser.save_screenshot('full_snap.png')
image = Image.open('full_snap.png')
resized_image = image.resize((1920, 1080), Image.ANTIALIAS)
resized_image.save('full_snap.png')
im = Image.open('full_snap.png')
# im = Image.open(name)
captcha = im.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')] for group in groups]
return locations
# def touch_click_words(self, locations):
# """
# 点击验证图片
# :param locations: 点击位置
# :return: None
# """
# for location in locations:
# print(location)
# ActionChains(self.browser).move_to_element_with_offset(self.get_touclick_element(), location[0],
# location[1]).click().perform()
# time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-pub-submit')))
button.click()
def login_click(self):
"""
登录
:return: None
"""
self.browser.find_element_by_xpath('//*[@id="login-submit"]/div/div').click()
time.sleep(2)
print('login success')
def get_picture_result(self, kind):
image = self.get_touclick_image(kind)
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# # # 识别验证码
if kind == 1:
CHAOJIYING_CODE = CHAOJIYING_KIND
else:
CHAOJIYING_CODE = CHAOJIYING_KIND1
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_CODE)
print(result)
return result['pic_str']
def refresh(self):
self.browser.find_element_by_xpath('//*[@id="loginForm"]/div/div[2]/table/tbody/tr/td[1]/table/tbody/tr[8]/td[2]/img[2]').click()
time.sleep(2)
def click_code(self, key_index):
for index in key_index:
if index < 5:
self.browser.find_element_by_xpath('//*[@id="captcha-image-input-key-container"]/table/tbody/tr[1]/td[{}]/img'.format(index + 1)).click()
else:
index = index - 5
self.browser.find_element_by_xpath(
'//*[@id="captcha-image-input-key-container"]/table/tbody/tr[2]/td[{}]/img'.format(
index + 1)).click()
time.sleep(0.2)
def choose_ticker(self):
try:
self.browser.find_element_by_xpath('//*[@id="concurrent-login-yes"]/div/div').click()
except Exception as E:
print(E)
while True:
if self.browser.current_url != self.params.get("key_url"):
self.browser.get(self.params.get("key_url"))
try:
self.browser.find_element_by_xpath('//*[@id="evt-perf-items-tbl"]/tbody/tr[{}]/td[6]/div/img'.format(self.params.get('period'))).click()
break
except Exception as E:
pass
# self.browser.save_screenshot("choose_ticker.png")
def choose_ticker_num(self):
# print("start choose_ticker_num")
self.wait.until(EC.presence_of_element_located((By.ID, 'ticket-quota-223-sel')))
html = self.browser.page_source.replace('xmlns="http://www.w3.org/1999/xhtml"', '')
options = PyQuery(html).find('#ticket-quota-223-sel > option')
num = PyQuery(options[-1]).val()
self.browser.find_element_by_xpath('//*[@id="ticket-quota-223-sel"]').send_keys(1)
# self.browser.find_element_by_xpath('//*[@id="ticket-quota-223-sel"]').send_keys(int(num))
self.browser.find_element_by_xpath('//*[@id="adjacent-seats-chk"]').click()
try:
self.browser.find_element_by_xpath('//*[@id="express-purchase-btn"]/div/span').click()
except:
self.browser.find_element_by_xpath('//*[@id="free-seat-purchase-btn"]/div/div/span').click()
try:
self.browser.find_element_by_xpath('/html/body/div[9]/div[3]/div/button[1]').click()
except Exception as E:
# self.browser.find_element_by_xpath('//*[@id="reviewTicketForm"]/div[8]/div/div').click()
print(E)
print("end choose_ticket_num")
# self.browser.save_screenshot("choose_ticket_num.png")
def insert_shopping(self):
try:
self.browser.find_element_by_xpath('//*[@id="checkbox-not-adjacent"]').click()
except Exception as E:
print(E)
pass
try:
self.browser.find_element_by_xpath('//*[@id="reviewTicketForm"]/div[9]/div/div').click()
except Exception as E:
print(E)
try:
self.browser.find_element_by_xpath('//*[@id="reviewTicketForm"]/div[8]/div/div').click()
except Exception as E:
print(E)
print("end insert shopping")
# self.browser.save_screenshot("insert_shopping.png")
def payment_area(self):
print("start payment_area")
time.sleep(1)
try:
self.browser.find_element_by_xpath('//*[@id="checkout-btn"]/div/div').click()
except Exception as E:
print(E)
try:
self.browser.find_element_by_xpath('//*[@id="checkbox-not-adjacent"]').click()
except Exception as E:
print(E)
print("end payment_area")
# self.browser.save_screenshot("payment_area.png")
def personal_data(self):
self.wait.until(EC.presence_of_element_located((By.ID, 'delivery-method-select')))
self.browser.find_element_by_xpath('//*[@id="input-surname"]').clear()
self.browser.find_element_by_xpath('//*[@id="input-surname"]').send_keys("cao")
self.browser.find_element_by_xpath('//*[@id="input-first-name"]').clear()
self.browser.find_element_by_xpath('//*[@id="input-first-name"]').send_keys('cao')
self.browser.find_element_by_xpath('//*[@id="input-email"]').clear()
self.browser.find_element_by_xpath('//*[@id="input-email"]').send_keys(self.params.get('email'))
self.browser.find_element_by_xpath('//*[@id="delivery-method-select"]').click()
time.sleep(2)
self.browser.find_element_by_xpath('//*[@id="delivery_method_group_TDM"]').click()
def choose_pay_mei(self):
print("start choose_pay")
self.browser.find_element_by_xpath('//*[@id="payment-type-select_title"]').click()
time.sleep(3)
self.browser.find_element_by_xpath('//*[@id="payment-type-select_child"]/ul/li[4]/img').click()
time.sleep(0.5)
self.browser.find_element_by_xpath('//*[@id="input-card-number"]').send_keys(
self.params.get('input_card_number'))
time.sleep(0.5)
self.browser.find_element_by_xpath('//*[@id="input-security-code"]').send_keys(
self.params.get('input_security_code'))
time.sleep(0.5)
self.browser.find_element_by_xpath('//*[@id="payment-expiry-month-select"]').send_keys(
self.params.get('payment_expiry_month_select'))
time.sleep(0.5)
self.browser.find_element_by_xpath('//*[@id="payment-expiry-year-select"]').send_keys(
self.params.get('payment_expiry_year_select'))
time.sleep(0.5)
self.browser.find_element_by_xpath('//*[@id="button-confirm"]/div/div/span').click()
print("end choose_pay")
self.browser.save_screenshot("choose_pay.png")
def confirm_mei(self):
print("start_confirm_mei")
self.browser.find_element_by_xpath('//*[@id="checkbox-tnc"]').click()
self.browser.find_element_by_xpath('//*[@id="button-confirm"]/div/div/span').click()
print("end confirm_mei")
def confirm(self):
print("start confirm")
self.browser.find_element_by_xpath('//*[@id="checkbox-tnc"]').click()
self.browser.find_element_by_xpath('//*[@id="button-confirm"]/div/div').click()
print("end confirm")
self.browser.save_screenshot("confirm.png")
def save_ticket(self):
if self.browser.current_url == "":
pass
end = time.time()
self.browser.save_screenshot("save_ticket{}.png".format(end))
def login_crack(self):
"""
破解入口
:return: None
"""
self.open()
self.login()
while True:
index = []
result_str = list()
result = self.get_picture_result(1)
for i in result:
if i.isdigit():
result_str.append(i)
elif i not in result_str:
result_str.append(i.lower())
if len(result_str) != 4:
self.refresh()
continue
str_list = list()
result = self.get_picture_result(2)
for i in result:
if i.isdigit():
str_list.append(i)
elif i.lower() in str_list and i.lower() not in result_str:
str_list.append(i.lower())
else:
str_list.append(i.lower())
if len(str_list) != 5:
self.refresh()
continue
result = self.get_picture_result(3)
for i in result:
if i.isdigit():
str_list.append(i)
elif i.lower() in str_list and i.lower() not in result_str:
str_list.append(i.lower())
else:
str_list.append(i.lower())
if len(str_list) != 10:
self.refresh()
continue
result_list = list(result_str)
for i in result_list:
if not i.isdigit():
for k, v in enumerate(str_list):
if i == v:
index.append(k)
else:
if int(i) != 0:
for k, v in enumerate(str_list):
if i == v:
index.append(k)
else:
for k, v in enumerate(str_list):
if i == v or i == 'o':
index.append(k)
if len(index) != 4:
self.refresh()
continue
key_index = index
break
self.click_code(key_index)
self.login_click()
start = time.clock()
self.choose_ticker()
self.choose_ticker_num()
self.insert_shopping()
print(time.clock() - start)
self.payment_area()
print(time.clock() - start)
self.personal_data()
self.choose_pay_mei()
print(time.clock() - start)
self.confirm_mei()
time.sleep(120)
class CrackCaptcha():
# 初始化了浏览器对象和打码平台的操作对象
def __init__(self):
# 要登录的网址
self.url = 'https://captcha3.scrape.cuiqingcai.com/'
# 自动化浏览器
self.browser = webdriver.Chrome()
# 等待方法访问网址，超时时间20秒
self.wait = WebDriverWait(self.browser, 20)
self.username = USERNAME
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
# 打开网页，填写表单
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
# 获取用户名和密码表单，填入用户名密码
# wait显示等待方法访问，until判断元素是否存在，EC模块进行检验，参数传入检测类型和条件，检测不通过就抛出异常
username = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'input[type="text"]')))
password = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'input[type="password"]')))
username.send_keys(self.username)
password.send_keys(self.password)
# 获取点击验证按钮
def get_captcha_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'button[type="button"]')))
# 点击按钮
button.click()
return button
# 获取验证码元素对象
def get_captcha_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
# 超时等待使用方法具体查看Spider_scrapy_intensive_study的004笔记
# 验证码图片加载出来，验证码图片位于img标签，class属性geetest_item_img
self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, 'img.geetest_item_img')))
# 验证码弹出窗口完整节点，div标签，class属性geetest_panel_box，
# 获取整个弹出的验证码窗口部分，要包含着图片上部和底部的文字部分，文字要依次点击，后台要根据文字顺序返回坐标位置
element = self.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'geetest_panel_box')))
print('成功获取验证码节点')
# print(element)
return element
# 获取验证码图片（验证码弹窗）在浏览器窗口的位置
def get_captcha_position(self):
"""
获取验证码位置，整个验证码弹窗的位置
:return: 验证码位置元组
"""
# 获取验证码图片元素
element = self.get_captcha_element()
time.sleep(2)
# 取出验证码图片的位置，使用location属性，左上角坐标位置xy坐标
location = element.location
print('验证码弹窗在浏览器窗口的位置(坐上角位置坐标):' + str(location))
# size就是div标签大小(宽度和高度)，就是验证码图片的大小
size = element.size
print('验证码弹窗的尺寸:' + str(size))
# 顶部就是y坐标，底部就用顶部加上高度，左边就是x坐标，右边就是左边加上宽度
top, bottom, left, right = location[
'y'], location['y'] + size['height'] + size['height'], location[
'x'], location['x'] + size['width'] + size['width']
# 返回验证码图片四个边框位置
return (top, bottom, left, right)
# 网页截图保存方法，截取的是整个网页
def get_screenshot(self):
"""
获取网页截图方法
:return: 截图对象，截取的是整个网页
"""
# 注意，chrome浏览器必须先截屏浏览器窗口，然后再定位截取元素，火狐浏览器定位元素后可以直接截取元素
# 火狐可以直接使用element.save_screenshot
# 谷歌浏览器：
# 1. chrome save_screenshot 截图，可以截取整个网页。
# 2. 利用element的size和location属性，获取element在网页(浏览器窗口)中的位置。
# 3. 这之后用PIL下Image中的crop方法截取元素。
# 截图，
screenshot = self.browser.get_screenshot_as_png()
# 截图打开为字节文件，screenshot已经变成了Image下的方法，后面直接使用corp方法截取元素
screenshot = Image.open(BytesIO(screenshot))
# 将截图的字节文件保存为png图片，此处截取的是整个网页，即浏览器窗口
screenshot.save('screenshot.png')
# 返回截图的字节文件
return screenshot
# 根据验证码图片位置截图，然后保存为图片
def get_captcha_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
# 获取验证码元素的位置
top, bottom, left, right = self.get_captcha_position()
print('验证码图片的位置:', top, bottom, left, right)
# 调用截图方法
screenshot = self.get_screenshot()
# 利用element的size和location属性，获取element在网页中的位置,即验证码元素的位置
# 用PIL下Image中的crop方法截取元素，根据验证码图片在浏览器窗口中位置进行截图
captcha = screenshot.crop((left, top, right, bottom))
# 保存截取的验证码图片
captcha.save(name)
return captcha
# 传入图片给超级鹰后台识别,返回识别结果JSON 格式的字符串，如下，pic_str里面就是要点击文字的坐标位置（左上角坐标）
# {'err_no': 0, 'err_str': 'OK', 'pic_id': '6002001380949200001', 'pic_str': '132,127|56,77', 'md5': '1f8e1d4bef8b11484cb1f1f34299865b'}
def recognize_image(self):
image = self.get_captcha_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
# print(result)
return result
# 解析识别结果，解析出来位置坐标
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
# 根据文字坐标位置，依次点击文字
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
ActionChains(self.browser).move_to_element_with_offset(
self.get_captcha_element(), location[0],
location[1]).click().perform()
time.sleep(1)
class CrackTouClick():
def __init__(self):
self.url = 'https://kyfw.12306.cn/otn/login/init'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
# def __del__(self):
# self.browser.close()
def crack(self):
"""
破解入口
:return: None
"""
self.browser.get(self.url)
#print(self.browser.page_source)
email = self.wait.until(
EC.presence_of_element_located((By.ID, 'username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'password')))
email.send_keys(self.email)
password.send_keys(self.password)
time.sleep(2)
# 点击验证码刷新按钮 element_to_be_clickable
button = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'touclick-reload')))
# 点击验证码刷新按钮
button.click()
time.sleep(2)
# 获取验证码图片
# 获取验证码元素位置范围
element = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'touclick-image')))
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
print('验证码位置', top, bottom, left, right)
# 网页快照
self.browser.save_screenshot("./images/12306.png")
screenshot = Image.open("./images/12306.png")
#screenshot = self.browser.get_screenshot_as_png()
#screenshot = Image.open(BytesIO(screenshot))
# 截取验证码图片
captcha = screenshot.crop((left, top, right, bottom))
captcha.save("./images/captcha.png")
bytes_array = BytesIO()
captcha.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
# 解析识别结果
groups = result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
# 点击验证图片
for location in locations:
print(location)
element = self.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'touclick-image')))
ActionChains(self.browser).move_to_element_with_offset(
element, location[0], location[1]).click().perform()
time.sleep(1)
class login():
def __init__(self):
self.url = 'https://passport.ctrip.com/user/login?BackUrl=http%3A%2F%2Fwww.ctrip.com%2F#ctm_ref=c_ph_login_buttom'
self.driver = webdriver.Chrome()
self.wait = WebDriverWait(self.driver, 20)
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
def loginto(self):
"""
登录起始页
用户名和密码输入
:return:
"""
self.driver.get(self.url)
user = self.driver.find_element_by_id('nloginname')
user.send_keys(username) #输入用户名
passw = self.driver.find_element_by_id('npwd')
passw.send_keys(password) #输入密码
slider = self.get_slider() #获取滑块位置
track = self.get_track(300) #获取滑动轨迹
self.move_to_gap(slider, track) #开始滑动
image = self.get_touclick_image() #获取点击图片
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
#利用超级鹰识别验证码,result为返回结果
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
locations = self.get_points(result)
self.touch_click_words(locations) #点击验证
self.touch_click_verify() #点击后提交
self.logint() #点击登录
def get_slider(self):
"""
获取滑块
:return: 滑块对象
"""
slider = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'cpt-drop-btn')))
return slider
def move_to_gap(self, slider, track):
"""
拖动滑块到缺口处
:param slider: 滑块
:param track: 轨迹
:return:
"""
ActionChains(self.driver).click_and_hold(slider).perform()
for x in track:
ActionChains(self.driver).move_by_offset(xoffset=x, yoffset=0).perform()
time.sleep(0.5)
ActionChains(self.driver).release().perform()
def get_track(self, distance):
"""
根据偏移量获取移动轨迹
:param distance: 偏移量
:return: 移动轨迹
"""
# 移动轨迹
track = []
# 当前位移
current = 0
# 减速阈值
mid = distance * 4 / 5
# 计算间隔
t = 0.2
# 初速度
v = 0
while current < distance:
if current < mid:
# 加速度为正2
a = 2
else:
# 加速度为负3
a = -3
# 初速度v0
v0 = v
# 当前速度v = v0 + at
v = v0 + a * t
# 移动距离x = v0t + 1/2 * a * t^2
move = v0 * t + 1 / 2 * a * t * t
# 当前位移
current += move
# 加入轨迹
track.append(round(move))
return track
def logint(self):
self.driver.find_element_by_id('nsubmit').click()
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(EC.presence_of_element_located((By.XPATH, '//div[@id="sliderddnormal-choose"]/div[2]')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
top = int(top)
bottom = int(bottom)
left = int(left)
right = int(right)
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.driver.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captch.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')] for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.driver).move_to_element_with_offset(self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(EC.element_to_be_clickable((By.XPATH, '//div[@class="cpt-sub-box"]/a')))
button.click()
class WeiboCookies():
def __init__(self, username, password, browser):
self.url = 'https://passport.weibo.cn/signin/login?entry=mweibo&r=https://m.weibo.cn/'
self.browser = browser
self.wait = WebDriverWait(self.browser, 20)
self.username = username
self.password = password
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
self.scale = 1.25
self.kind = CHAOJIYING_KIND_CLICK
self.font = ImageFont.truetype("msyh.ttc", 28)
self.sliver_text = "请点击阴影凹槽左上角"
def open(self):
"""
打开网页输入用户名密码并点击
:return: None
"""
self.browser.delete_all_cookies()
self.browser.get(self.url)
username = self.wait.until(
EC.presence_of_element_located((By.ID, 'loginName')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'loginPassword')))
submit = self.wait.until(
EC.element_to_be_clickable((By.ID, 'loginAction')))
username.send_keys(self.username)
password.send_keys(self.password)
time.sleep(1)
submit.click()
def password_error(self):
"""
判断是否密码错误
:return:
"""
try:
return WebDriverWait(self.browser, 5).until(
EC.text_to_be_present_in_element((By.ID, 'errorMsg'),
'用户名或密码错误'))
except TimeoutException:
return False
def login_successfully(self):
"""
判断是否登录成功
:return:
"""
try:
print("enter")
return bool(
WebDriverWait(self.browser, 15).until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'lite-iconf-profile'))))
except TimeoutException:
return False
def redirect_geetcode(self):
try:
geetCode_command = WebDriverWait(self.browser, 7).until(
EC.element_to_be_clickable(
(By.CLASS_NAME, 'geetest_radar_tip')))
geetCode_command.click()
return True
except TimeoutException:
print("没有出现极验验证码")
return False
def get_geetCode_image(self, name="captcha.png"):
"""
得到验证码图片
:param name:
:return:
"""
top, bottom, left, right = map(lambda x: x * self.scale,
self.get_geetCode_postion())
screen = self.get_screenshot()
image = screen.crop((left, top, right, bottom))
if self.kind == CHAOJIYING_KIND_SLIVER:
draw = ImageDraw.Draw(image)
draw.text((10, 160),
self.sliver_text,
font=self.font,
fill=(230, 0, 0))
image.save(name)
return image
def get_geetCode_postion(self):
"""
获得图片的相对位置
:return:
"""
element = self.get_geetCode()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return top, bottom, left, right
def get_geetCode(self):
"""
:return:
"""
try:
element_code = None
elements = self.wait.until(
EC.presence_of_all_elements_located((
By.XPATH,
"//div[@class='geetest_fullpage_click_box']/descendant::div[contains(@class,'geetest_slider')]"
)))
self.kind = (len(elements) == 0 and CHAOJIYING_KIND_CLICK
or CHAOJIYING_KIND_SLIVER)
if self.kind == CHAOJIYING_KIND_SLIVER:
element_code = self.wait.until(
EC.presence_of_element_located(
(By.XPATH, "//div[@class='geetest_window']")))
print("当前为滑动验证码")
elif self.kind == CHAOJIYING_KIND_CLICK:
element_code = self.wait.until(
EC.presence_of_element_located(
(By.XPATH,
"//div[@class='geetest_fullpage_click_box']")))
print("当前为点击验证码")
# // div[ @class ='geetest_fullpage_click_box'] / div / div / div
return element_code
except TimeoutException:
print("无法得到验证码图片box")
def get_points(self, result):
"""
得到解析的json文件，解析需要点击的位置
:param result:
:return:
"""
print(self.kind)
if self.kind == CHAOJIYING_KIND_CLICK:
groups = result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(",")]
for group in groups]
return locations
elif self.kind == CHAOJIYING_KIND_SLIVER:
locations = [int(i) for i in result.get('pic_str').split(",")]
return locations
def click_command(self):
if self.is_check():
ele = self.wait.until(
EC.element_to_be_clickable(
(By.XPATH,
"//button[@class='ivu-btn ivu-btn-primary-arrow']")))
ele.click()
def print_point(self, image, locations, kind):
draw = ImageDraw.Draw(image)
if kind == CHAOJIYING_KIND_SLIVER:
print(locations)
draw.ellipse((locations[0] - 10, locations[1] - 10,
locations[0] + 10, locations[1] + 10),
fill=(230, 0, 0))
elif kind == CHAOJIYING_KIND_CLICK:
for i in locations:
draw.ellipse((i[0] - 10, i[1] - 10, i[0] + 10, i[1] + 10),
fill=(230, 0, 0))
image.save("new_pic.png")
def touch_click_words(self, locations):
"""
模拟点击
:param locations:
:return:
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick(), location[0],
location[1]).click().perform()
time.sleep(1)
def click_tou_commit(self):
"""
点击确认
:return:
"""
ele = self.wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//a[@class='geetest_commit']")))
ele.click()
time.sleep(2)
def get_track(self, gap):
track = []
v = 0
t = 0.2
middle = gap * 4 / 5
current = 0
while current < gap:
if current < middle:
a = 2
else:
a = -5
v0 = v
v = v0 + a * t
move = v0 * t + 1 / 2 * a * t * t
current += move
track.append(round(move))
# print("current:",current)
return track
def get_slider(self):
slider = self.wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//div[@class='geetest_slider_button']")))
return slider
def move_to_slider(self, slider, track):
ActionChains(self.browser).click_and_hold(slider).perform()
for i in track:
ActionChains(self.browser).move_by_offset(xoffset=i,
yoffset=0).perform()
ActionChains(self.browser).release().perform()
time.sleep(2)
def crack_geetCode(self):
image = self.get_geetCode_image()
# self.print_point(image, [207,154], CHAOJIYING_KIND_SLIVER)
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
result = self.chaojiying.post_pic(bytes_array.getvalue(), self.kind)
print(result)
locations = self.get_points(result)
if self.kind == CHAOJIYING_KIND_CLICK:
self.print_point(image, locations, CHAOJIYING_KIND_CLICK)
self.touch_click_words(locations)
self.click_tou_commit()
elif self.kind == CHAOJIYING_KIND_SLIVER:
self.print_point(image, locations, CHAOJIYING_KIND_SLIVER)
gap = locations[0] - BORDER
track = self.get_track(gap)
slider = self.get_slider()
self.move_to_slider(slider, track)
self.click_command()
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
try:
img = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'patt-shadow')))
except TimeoutException:
print('未出现验证码')
self.open()
time.sleep(2)
location = img.location
size = img.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
return captcha
def is_pixel_equal(self, image1, image2, x, y):
"""
判断两个像素是否相同
:param image1: 图片1
:param image2: 图片2
:param x: 位置x
:param y: 位置y
:return: 像素是否相同
"""
# 取两个图片的像素点
pixel1 = image1.load()[x, y]
pixel2 = image2.load()[x, y]
threshold = 20
if abs(pixel1[0] - pixel2[0]) < threshold and abs(
pixel1[1] - pixel2[1]) < threshold and abs(
pixel1[2] - pixel2[2]) < threshold:
return True
else:
return False
def same_image(self, image, template):
"""
识别相似验证码
:param image: 待识别验证码
:param template: 模板
:return:
"""
# 相似度阈值
threshold = 0.99
count = 0
for x in range(image.width):
for y in range(image.height):
# 判断像素是否相同
if self.is_pixel_equal(image, template, x, y):
count += 1
result = float(count) / (image.width * image.height)
if result > threshold:
print('成功匹配')
return True
return False
def detect_image(self, image):
"""
匹配图片
:param image: 图片
:return: 拖动顺序
"""
for template_name in listdir(TEMPLATES_FOLDER):
print('正在匹配', template_name)
template = Image.open(TEMPLATES_FOLDER + template_name)
if self.same_image(image, template):
# 返回顺序
numbers = [
int(number)
for number in list(template_name.split('.')[0])
]
print('拖动顺序', numbers)
return numbers
def move(self, numbers):
"""
根据顺序拖动
:param numbers:
:return:
"""
# 获得四个按点
try:
circles = self.browser.find_elements_by_css_selector(
'.patt-wrap .patt-circ')
dx = dy = 0
for index in range(4):
circle = circles[numbers[index] - 1]
# 如果是第一次循环
if index == 0:
# 点击第一个按点
ActionChains(self.browser) \
.move_to_element_with_offset(circle, circle.size['width'] / 2, circle.size['height'] / 2) \
.click_and_hold().perform()
else:
# 小幅移动次数
times = 30
# 拖动
for i in range(times):
ActionChains(self.browser).move_by_offset(
dx / times, dy / times).perform()
time.sleep(1 / times)
# 如果是最后一次循环
if index == 3:
# 松开鼠标
ActionChains(self.browser).release().perform()
else:
# 计算下一次偏移
dx = circles[numbers[index + 1] -
1].location['x'] - circle.location['x']
dy = circles[numbers[index + 1] -
1].location['y'] - circle.location['y']
except:
return False
def get_cookies(self):
"""
获取Cookies
:return:
"""
return self.browser.get_cookies()
def crack_sudoku_code(self):
"""
破解九宫格验证码
:return:
"""
image = self.get_image('captcha.png')
numbers = self.detect_image(image)
self.move(numbers)
def success_return(self):
if self.login_successfully():
cookies = self.get_cookies()
return {'status': 1, 'content': cookies}
def password_error_return(self):
if self.password_error():
return {'status': 2, 'content': '用户名或密码错误'}
def main(self):
"""
破解入口
:return:
"""
self.open()
self.password_error_return()
# 如果不需要验证码直接登录成功
self.success_return()
if not self.redirect_geetcode():
#如果为九宫格验证码
self.crack_sudoku_code()
else:
print("1")
#如果为极验验证码，
if not self.success_return():
# 如果点击极验未成功验证
print("2")
self.crack_geetCode()
if not self.success_return():
print("3")
return {'status': 3, 'content': '登录失败'}
class CrackTouClick():
def __init__(self):
self.url = 'https://passport.douyu.com/member/login?'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def __del__(self):
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
email = self.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'country-phonenum')))
password = self.wait.until(
EC.presence_of_element_located(
(By.XPATH, '//*[@type="password"]')))
# email.send_keys(self.email)
# password.send_keys(self.password)
def get_touclick_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_radar_tip')))
return button
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'geetest_widget')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
print('location:', location)
print('size:', size)
top, bottom, left, right = location['y'] - 22, location['y'] + size[
'height'] - 22, location['x'] - size['width'] / 2, location[
'x'] + size['width'] / 2
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
print('groups', groups)
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'geetest_commit')))
button.click()
def login(self):
"""
登录
:return: None
"""
submit = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'loginbox-sbt')))
submit.click()
time.sleep(10)
print('登录成功')
def crack(self):
"""
破解入口
:return: None
"""
self.open()
# 点击验证按钮
password_login_button = self.wait.until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, '.scancode-link .js-to-link')))
password_login_button.click()
button = self.get_touclick_button()
button.click()
# 获取验证码图片
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
self.touch_click_verify()
# 判定是否成功
success = self.wait.until(
EC.text_to_be_present_in_element(
(By.CLASS_NAME, 'geetest_success_radar_tip_content'), '验证成功'))
print(success)
# 失败后重试
if not success:
self.crack()
else:
self.login()
checkCode = browser.find_element_by_id('txtOldCheckCode')
btnReg = browser.find_element_by_id('ButtonRegister')
user.send_keys('*****@*****.**')
time.sleep(2)
pwd.send_keys('mimamima')
time.sleep(2)
email.send_keys('*****@*****.**')
time.sleep(2)
browser.save_screenshot('./images/zhiwang.png')
img = browser.find_element_by_id('checkcode')
left = img.location['x'] #验证码图片左上角横坐标
top = img.location['y'] #验证码图片左上角纵坐标
right = left + img.size['width'] #验证码图片右下角横坐标
bottom = top + img.size['height'] #验证码图片右下角纵坐标
im = Image.open('./images/zhiwang.png')
im_crop = im.crop((left, top, right, bottom)) #这个im_crop就是从整个页面截图中再截出来的验证码的图片
im_crop.save('./images/zrecaptchar.png')
chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
# 识别验证码
bytes_array = BytesIO()
im_crop.save(bytes_array, format='PNG')
strcode = chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
print(strcode)
checkCode.send_keys(strcode['pic_str'])
#模拟点击注册按钮
#btnReg.click()
class CrackCode:
def __init__(self, driver, class_name, identifying_name):
"""
:param driver: 浏览器对象
:param class_name: 图片元素的class属性名称
:param identifying_name: 判断是否登陆成功的验证信息
"""
self.browser = driver
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
self.name = class_name
self.wait = WebDriverWait(self.browser, 15)
self.identifying_name = identifying_name
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, self.name)))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(0.5)
def crack(self):
"""
破解入口
:return: None
"""
image = self.get_touclick_image() #获得图片对象
bytes_array = BytesIO()
image.save(bytes_array, format='PNG') #将图片以bytes形式写入内存
# 识别验证码
result = self.chaojiying.post_pic(
bytes_array.getvalue(), CHAOJIYING_KIND) #从内存中读取图片bytes，并传到打码平台解析
print(result)
locations = self.get_points(result) #将打码平台返回的结果进行解析，获得坐标
self.touch_click_words(locations)
self.browser.find_element_by_class_name('geetest_commit_tip').click()
time.sleep(5)
data = self.browser.page_source
if self.identifying_name in data: #判断页面是否有个人信息，有就是登陆成功，否则调用自己重新验证
print('登陆成功')
else:
self.crack()
class CrackTouClick():
def __init__(self):
self.url = 'https://fishc.com.cn/forum-173-1.html'
self.option = ChromeOptions()
self.option.add_experimental_option('excludeSwitches',
['enable-automation'])
self.browser = Chrome(options=self.option)
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
email = self.wait.until(
EC.presence_of_element_located((By.ID, 'ls_username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'ls_password')))
email.send_keys(self.email)
password.send_keys(self.password)
button = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'pn'))).click()
try:
slider = self.wait.until(
EC.element_to_be_clickable(
(By.CLASS_NAME, 'td-pop-slidetrigger')))
CHAOJIYING_KIND = 9202
print('这是滑块验证码')
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print('验证码位置', result['pic_str'])
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
print('正在检测错误,此处延迟3秒,以便等待页面加载')
time.sleep(3)
self.img_error(result)
except Exception as e:
print('这是字体验证码', e)
CHAOJIYING_KIND = 9103
# 获取验证码图片
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words2(locations)
print('正在检测错误,此处延迟3秒,以便等待页面加载')
time.sleep(3)
self.img_error(result)
def touch_click_verify(self):
"""
获取滑块按钮
:return: None
"""
slider = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'td-pop-slidetrigger')))
return slider
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'td-bg-img')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击滑块验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).drag_and_drop_by_offset(
self.touch_click_verify(), location[0], location[1]).perform()
time.sleep(1)
def touch_click_words2(self, locations):
"""
点击字体验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def img_error(self, result):
#检测验证码有没有出错,这步老是报出栈错误
#无奈之下只能采取解析式来判断登录前后页面的数据了
#不得不吐槽的是,这里的滑块验证码坐标识别率低到了令人发指的地步
test = etree.HTML(self.browser.page_source)
title = test.xpath('//*[@id="um"]/p[1]/strong/a/@title')
print('爬取登陆前后的数据变化', title)
if title == []:
img_id = result['pic_id']
self.chaojiying.report_error(img_id)
print('登录失败,已发送错误验证码')
self.open()
else:
print('登录成功')
class CrackTouClick():
def __init__(self):
self.url = 'https://kyfw.12306.cn/otn/login/init'
self.browser = webdriver.Chrome(r"E:\myplugins\chromedriver.exe")
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def __del__(self):
print('close')
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
print(self.browser.page_source)
email = self.wait.until(
EC.presence_of_element_located((By.ID, 'username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'password')))
email.send_keys(self.email)
password.send_keys(self.password)
def get_touclick_button(self):
"""
获取初始验证按钮element_to_be_clickable
:return:
touclick-bgimg touclick-reload touclick-reload-normal
"""
button = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'touclick-reload')))
return button
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'touclick-image')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (left, top, right, bottom)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
left, top, right, bottom = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(
EC.element_to_be_clickable((By.CLASS_NAME, 'btn200s')))
button.click()
def login(self):
"""
登录
:return: None
"""
submit = self.wait.until(
EC.element_to_be_clickable((By.ID, 'loginSub')))
submit.click()
time.sleep(10)
print('登录成功')
def crack(self):
"""
破解入口
:return: None
"""
self.open()
time.sleep(2)
# 点击验证码刷新按钮
button = self.get_touclick_button()
button.click()
time.sleep(2)
# 获取验证码图片
image = self.get_touclick_image("./images/12306.png")
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 利用超级鹰识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
self.touch_click_verify()
# 判定是否成功
elem = self.wait.until(
#EC.text_to_be_present_in_element((By.CLASS_NAME, 'touclick-hod-note'), '验证成功'))
EC.presence_of_element_located((By.ID, 'error_msgmypasscode1')))
print(elem.text)
#失败后重试
if len(elem.text) == 0:
print('success!')
#self.login()
else:
print('fail!')
class CrackTouClick():
def __init__(self):
self.url = 'http://admin.touclick.com/login.html'
self.browser = webdriver.Chrome()
self.wait = WebDriverWait(self.browser, 20)
self.email = EMAIL
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
def __del__(self):
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
email = self.wait.until(EC.presence_of_element_located((By.ID, 'email')))
password = self.wait.until(EC.presence_of_element_located((By.ID, 'password')))
email.send_keys(self.email)
password.send_keys(self.password)
def get_touclick_button(self):
"""
获取初始验证按钮
:return:
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-hod-wrap')))
return button
def get_touclick_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, 'touclick-pub-content')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_touclick_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
'width']
return (top, bottom, left, right)
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_touclick_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 图片对象
"""
top, bottom, left, right = self.get_position()
print('验证码位置', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
groups = captcha_result.get('pic_str').split('|')
locations = [[int(number) for number in group.split(',')] for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(self.get_touclick_element(), location[0],
location[1]).click().perform()
time.sleep(1)
def touch_click_verify(self):
"""
点击验证按钮
:return: None
"""
button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'touclick-pub-submit')))
button.click()
def login(self):
"""
登录
:return: None
"""
submit = self.wait.until(EC.element_to_be_clickable((By.ID, '_submit')))
submit.click()
time.sleep(10)
print('登录成功')
def crack(self):
"""
破解入口
:return: None
"""
self.open()
# 点击验证按钮
button = self.get_touclick_button()
button.click()
# 获取验证码图片
image = self.get_touclick_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(), CHAOJIYING_KIND)
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
self.touch_click_verify()
# 判定是否成功
success = self.wait.until(
EC.text_to_be_present_in_element((By.CLASS_NAME, 'touclick-hod-note'), '验证成功'))
print(success)
# 失败后重试
if not success:
self.crack()
else:
self.login()
class Crack12306():
def __init__(self):
self.url = 'https://kyfw.12306.cn/otn/login/init'
self.browser = webdriver.Chrome()
# self.browser.set_window_size(1920, 1080)
self.wait = WebDriverWait(self.browser, 20)
self.username = USERNAME
self.password = PASSWORD
self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD,
CHAOJIYING_SOFT_ID)
def __del__(self):
print('正在关闭浏览器')
time.sleep(10)
self.browser.close()
def open(self):
"""
打开网页输入用户名密码
:return: None
"""
self.browser.get(self.url)
username = self.wait.until(
EC.presence_of_element_located((By.ID, 'username')))
password = self.wait.until(
EC.presence_of_element_located((By.ID, 'password')))
username.send_keys(self.username)
password.send_keys(self.password)
def get_12306_element(self):
"""
获取验证图片对象
:return: 图片对象
"""
element = self.wait.until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, '.touclick .touclick-image')))
return element
def get_position(self):
"""
获取验证码位置
:return: 验证码位置元组
"""
element = self.get_12306_element()
time.sleep(2)
location = element.location
size = element.size
top, bottom, left, right = location['y'], location['y'] + size[
'height'], location['x'], location['x'] + size['width']
return (top, bottom, left, right)
def get_12306_image(self, name='captcha.png'):
"""
获取验证码图片
:return: 裁剪后的图片对象
"""
top, bottom, left, right = self.get_position()
print(' 验证码位置 ', top, bottom, left, right)
screenshot = self.get_screenshot()
captcha = screenshot.crop((left, top, right, bottom))
captcha.save(name)
return captcha
def get_screenshot(self):
"""
获取网页截图
:return: 截图对象
"""
screenshot = self.browser.get_screenshot_as_png()
screenshot = Image.open(BytesIO(screenshot))
return screenshot
def get_points(self, captcha_result):
"""
解析识别结果
:param captcha_result: 识别结果
:return: 转化后的结果
"""
# get_points()将识别结果变成列表的形式。
# 超级鹰识别后返回结果：{'err_no': 0, 'err_str': 'OK', 'pic_id': '9082718423155200001', 'pic_str': '55,152|176,148', 'md5': '508d3222a99aa1a5218ccbfcda3a2857'}
groups = captcha_result.get('pic_str').split('|')
print(groups)
# locations = [[55, 152],[176, 148]]
locations = [[int(number) for number in group.split(',')]
for group in groups]
return locations
def touch_click_words(self, locations):
"""
点击验证图片
:param locations: 点击位置
:return: None
"""
# touch_click_words()方法则通过调用move_to_element_with_offset()方法依次传入解析后的坐标，点击即可。
element = self.get_12306_element()
for location in locations:
print(location)
ActionChains(self.browser).move_to_element_with_offset(
element, location[0], location[1]).click().perform()
time.sleep(1)
def login(self):
"""
登录
:return: None
"""
submit = self.wait.until(
EC.element_to_be_clickable((By.ID, 'loginSub')))
submit.click()
time.sleep(10)
def check_login_success(self):
"""
检查是否登录成功
:return: None
"""
success = False
try:
# 登录成功后的页面是找不到loginSub这个元素的。
self.browser.find_element_by_id('loginSub')
self.chaojiying.report_error(self.pic_id)
except NoSuchElementException:
success = True
return success
def crack(self):
"""
破解入口
:return: None
"""
self.open()
# 获取验证码图片
image = self.get_12306_image()
bytes_array = BytesIO()
image.save(bytes_array, format='PNG')
# 识别验证码
result = self.chaojiying.post_pic(bytes_array.getvalue(),
CHAOJIYING_KIND)
self.pic_id = result.get('pic_id')
print(result)
locations = self.get_points(result)
self.touch_click_words(locations)
# 登录
self.login()
# 失败后重试
success = self.check_login_success()
if not success:
self.crack()
else:
print('登录成功')