爬虫验证码：破解【点击旋转验证码】

蔚落 2022-02-13 11:13 1202阅读 0赞

这里破解某某动漫的点击翻转验证码为例：在这里插入图片描述
分析页面的源码发现，这些翻转的图片，我们可以下载下来，既然可以获取到这些图片，那么这个的破解思路为：

  1. 获取1000张样本集合： 用selenium访问，通过截屏，以及切片，一次获取四张图片，然后点击”换一组”，依次循环1000次

  2. 对获取的图片进行去重： 通过图片的rbg总值来去重，rgb总值相差3000以为，基本认为这是同一张图片，就只保留一张。

  3. 人为手动给去重的图片进行调整。

  4. 通过selenium来模拟登录，输入账号和密码

  5. 截屏，截取验证码图片

  6. 翻转每张验证码，记录翻转次数，通过和样本基本的每张图片的rgb进行一一比较，如果每个像素的rgb都小于100，那么这个翻转后的图片就是正确的位置，返回翻转次数。

  7. 依次翻转，记录各个图片需要翻转的次数

  8. 点击对应图片的元素，进行翻转

  9. 点击提交按钮，进行登录

  10. 判断是否登录成功

获取1000张样本集的代码：

  1. from selenium import webdriver
  2. from selenium.webdriver.support.ui import WebDriverWait
  3. from selenium.webdriver.support import expected_conditions as EC
  4. from selenium.webdriver.common.by import  By
  5. from PIL import Image
  6. import random
  7. from io import BytesIO
  8. import time
  11. class Crack(object):
  12.     def __init__(self, start_number, count):
  13.         self.login_url = "http://www.1kkk.com/"
  14.         self.start_number = start_number
  15.         self.count = count
  16.         self.chrome_options = webdriver.ChromeOptions()
  17.         self.chrome_options.add_argument("--healess")
  18.         self.browser = webdriver.Chrome()
  19.         self.browser.maximize_window()
  20.         self.wait = WebDriverWait(self.browser, 30)
  22.     def login(self):
  23.         """
  24.         输入账号，密码
  25.         :return:None
  26.         """
  27.         self.browser.get(self.login_url)
  28.         self.browser.find_element_by_class_name("header-avatar").click()
  29.         # 获取所有图片
  30.         for num in range(self.start_number, self.start_number+self.count):
  31.             self.image_png(num)
  32.             self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, "rotate-refresh"))).click()
  33.             time.sleep(0.5)
  35.     def save_screen_png(self):
  36.         """
  37.         获取网页截图
  38.         :return: 截图对象
  39.         """
  40.         self.wait.until(EC.presence_of_all_elements_located((By.CLASS_NAME, "rotate-background")))
  41.         screen_image = self.browser.get_screenshot_as_png()
  42.         screenshot = Image.open(BytesIO(screen_image))
  43.         screenshot.save("screenshot{}.png".format(random.randint(1, 5)))
  44.         return screenshot
  46.     def image_png(self, num):
  47.         """
  48.         通过获取网页截图，然后进行切片，返回四张图片
  49.         :return:
  50.         """
  51.         screenshot = self.save_screen_png()
  52.         images = []
  53.         for num_2 in range(1, 5):
  54.             # 依次获取5张图片，存入iamges列表中
  55.             images.append(self.get_image_position(screenshot, num, num_2))
  56.         # 获取整体四张图片的坐标
  57.         # 进行切片
  59.     def get_image_position(self, screenshot, number, number_2):
  60.         """
  61.         获取四张图片的下标
  62.         :return: left, top, right, bottom
  63.         """
  64.         image = self.wait.until(EC.presence_of_element_located((By.XPATH, "//div[@class='rotate-background'][{}]".format(number_2))))
  65.         location = image.location
  66.         size = image.size
  67.         top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
  68.             'width']
  69.         image = screenshot.crop((left, top, right, bottom))
  70.         image.save("./static/total_images/image{}_{}.png".format(number, number_2))
  71.         return image
  73.     def __del__(self):
  74.         self.browser.quit()
  77. def download(start_number, count):
  78.     """
  79.     初始化登录类，下载图片
  80.     :param start_number:开启位置
  81.     :param count: 数量
  82.     :return:
  83.     """
  84.     c = Crack(start_number, count)
  85.     c.login()
  86.     del c
  89. def main():
  90.     download(1, 1000)
  93. if __name__ == '__main__':
  94.     main()

图片去重的代码：

  1. from PIL import Image
  2. import os
  3. import gevent
  4. from gevent import monkey
  7. monkey.patch_all()
  9. # 图片数量
  10. gCount = 0
  12. # 列表,用来保存rgb
  13. rgb_dif_list = []
  15. # 当前保存图片的名称
  16. gNumber = 0
  19. def sum_rgb(image):
  20.     """
  21.     计算rgb的值
  22.     :param images: 图片
  23.     :return: rgb的值
  24.     """
  25.     num = 0
  26.     for i in range(image.size[0]):
  27.         for y in range(image.size[1]):
  28.             pixel = image.load()[i, y]
  29.             num = num + image.load()[i, y][0] + image.load()[i, y][1] + image.load()[i, y][2]
  30.     return num
  33. def check_have_in(num):
  34.     """
  35.     通过rgb的总值，来判断是否已经存在列表
  36.     :param num: Ture or False
  37.     :return: 
  38.     """
  39.     global rgb_dif_list
  40.     if num in rgb_dif_list:
  41.         # 如果存在，就得删除
  42.         return True
  43.     else:
  44.         # 否则就将rgb存入列表中，更改名字，并返回False
  45.         return False
  48. def delete(image_url):
  49.     """
  50.     删除图片
  51.     :param image_url: 图片的url
  52.     :return:
  53.     """
  54.     print("删除图片:", image_url)
  55.     os.remove(image_url)
  58. def start_check(start_number, count):
  59.     global rgb_dif_list
  60.     global gCount
  61.     global gNumber
  62.     images_url = "./static/total_images/{}"
  63.     save_url = "./static/images/{}"
  64.     for number_1 in range(start_number, start_number + count):
  65.         for number_2 in range(1, 5):
  66.             image_url = images_url.format("image{}_{}.png".format(number_1, number_2))
  67.             if os.path.isfile(image_url):
  68.                 image = Image.open(image_url)
  69.                 # 通过元素的rgb三个值相加的总数，通过列表保存，如果在列表中存在就添加，否则就删除
  70.                 rgb_num = sum_rgb(image)
  71.                 print("image{}_{}.png".format(number_1, number_2), rgb_num)
  72.                 # 判断该图片的rgb是否已经存在列表中
  73.                 if rgb_num > 4000000:
  74.                     continue
  75.                 for num in range(rgb_num-3000, rgb_num+3000):
  76.                     check_result = check_have_in(num)
  77.                     # 判断结果，做响应处理
  78.                     if check_result:
  79.                         # 存在情况，退出
  80.                         break
  81.                 else:
  82.                     rgb_dif_list.append(rgb_num)
  83.                     gCount += 1
  84.                     # 不存在情况，更改名字
  85.                     gNumber += 1
  86.                     image.save(save_url.format("images{}.png".format(gNumber)))
  87.     if start_number+count == 501:
  88.         print("剩余图片总数为", gCount)
  91. def main():
  92.     gevent.joinall([
  93.         gevent.spawn(start_check, 1, 100),
  94.         gevent.spawn(start_check, 101, 100),
  95.         gevent.spawn(start_check, 201, 100),
  96.         gevent.spawn(start_check, 301, 100),
  97.         gevent.spawn(start_check, 401, 100),
  98.     ])
  99.     # start_check(1, 10)
  102. if __name__ == "__main__":
  103.     main()

验证码破解：

  1. from selenium import webdriver
  2. from selenium.webdriver.common.by import By
  3. from selenium.webdriver.support.ui import WebDriverWait
  4. from selenium.webdriver.support import expected_conditions as EC
  5. from selenium.common.exceptions import TimeoutException
  6. import time
  7. import os
  8. from PIL import Image
  9. from io import BytesIO
  12. class Crack(object):
  13.     def __init__(self):
  14.         self.login_url = "http://www.1kkk.com/"
  15.         # self.chrome_options = webdriver.ChromeOptions()
  16.         # self.chrome_options.add_argument("--healess")
  17.         self.browser = webdriver.Chrome()
  18.         self.browser.maximize_window()
  19.         self.wait = WebDriverWait(self.browser, 10)
  20.         self.browser.get(self.login_url)
  21.         time.sleep(2)
  23.     def login(self):
  24.         """
  25.         输入账号，密码
  26.         :return:None
  27.         """
  28.         try:
  29.             self.wait.until(EC.presence_of_element_located((By.CLASS_NAME, "header-avatar"))).click()
  30.         except TimeoutException:
  31.             self.browser.refresh()
  32.             self.login()
  33.             return
  34.         # self.browser.find_element_by_class_name("header-avatar").click()
  35.         name_page = self.browser.find_element_by_name("txt_name")
  36.         name_page.send_keys("18218299414")
  37.         password_page = self.browser.find_element_by_name("txt_password")
  38.         password_page.send_keys("shao0812")
  39.         true_or_false = True
  40.         while true_or_false:
  41.             true_or_false = False
  42.             # 获取四张需要旋转的图片
  43.             images = self.image_png()
  44.             # 获取整体四张图片的几次
  45.             turn_num_list = []
  46.             for image in images:
  47.                 turn_num_list.append(self.image_turn_num(image))
  48.             # print(turn_num_list)
  49.             for i in turn_num_list:
  50.                 if i == 5:
  51.                     self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'rotate-refresh'))).click()
  52.                     time.sleep(3)
  53.                     true_or_false = True
  54.         # 根据上面得到的旋转次数点击图片
  55.         self.click_image(turn_num_list)
  56.         # 结果正确，点击登录按钮
  57.         self.click_submit()
  58.         # todo: 如果旋转出问题，就得重新.来
  59.         # try:
  60.         if self.browser.find_element_by_css_selector(".tip.color-main").text == "请点击下方图片，旋转至正确方向~":
  61.             # 如果登录不成功，将重新刷新页面登录
  62.             self.browser.refresh()
  63.             self.login()
  64.         time.sleep(5)
  66.     def click_image(self, turn_num_list):
  67.         """
  68.         通过算出来的点击次数，来点击图片
  69.         :param turn_num_list: 四张图需要点击的次数
  70.         :return: None
  71.         """
  72.         for i in range(0, len(turn_num_list)):
  73.             if turn_num_list[i] == 0:
  74.                 continue
  75.             image = self.wait.until(
  76.                 EC.presence_of_element_located((By.XPATH, "//div[@class='rotate-background'][{}]".format(i+1))))
  77.             for _ in range(turn_num_list[i]):
  78.                 image.click()
  79.                 time.sleep(1)
  81.     def save_screen_png(self):
  82.         """
  83.         获取网页截图
  84.         :return: 截图对象
  85.         """
  86.         screen_image = self.browser.get_screenshot_as_png()
  87.         screenshot = Image.open(BytesIO(screen_image))
  88.         # screenshot.save("screenshot.png")
  89.         return screenshot
  91.     def image_png(self):
  92.         """
  93.         通过获取网页截图，然后进行切片，返回四张图片
  94.         :return:
  95.         """
  96.         screenshot = self.save_screen_png()
  97.         images = []
  98.         for num in range(1, 5):
  99.             # 依次获取4张图片，存入iamges列表中
  100.             images.append(self.get_image(screenshot, num))
  101.         return images
  103.     def get_image(self, screenshot, number):
  104.         """
  105.         获取四张图片的下标
  106.         :return: left, top, right, bottom
  107.         """
  108.         image = self.wait.until(EC.presence_of_element_located((By.XPATH, "//div[@class='rotate-background'][{}]".format(number))))
  109.         location = image.location
  110.         size = image.size
  111.         top, bottom, left, right = location['y'], location['y'] + size['height'], location['x'], location['x'] + size[
  112.             'width']
  113.         image = screenshot.crop((left, top, right, bottom))
  114.         # image.save("image{}.png".format(number))
  115.         return image
  117.     def image_turn_num(self, image):
  118.         """
  119.         用获取的图片跟图片库的图片比较，
  120.         :param image: 原图
  121.         :return:
  122.         """
  123.         for i in range(0, 4):
  124.             # 原图最多转三次
  125.             dir_path = "./static/images/"
  126.             change_image = image.rotate(-90*i)
  127.             # change_image.save("change{}.png".format(i))
  128.             for or_path in os.listdir(dir_path):
  129.                 or_image = Image.open(os.path.join(dir_path, or_path))
  130.                 result = self.examine_pixel(or_image, change_image)
  131.                 if result:
  132.                     return i
  133.         return 5
  135.     def examine_pixel(self, image1, image2):
  136.         """
  137.         判断来个图片是否相等
  138.         :param image1: 图片1
  139.         :param image2: 图片2
  140.         :return:
  141.         """
  142.         thredhold = 100
  143.         for x in range(image1.size[0]):
  144.             for y in range(image1.size[1]):
  145.                 pixel1 = image1.load()[x, y]
  146.                 pixel2 = image2.load()[x, y]
  147.                 if not (abs(pixel1[0] - pixel2[0]) < thredhold and abs(pixel1[1] - pixel2[1]) < thredhold and abs(pixel1[2] - pixel2[2]) < thredhold):
  148.                     return False
  149.         return True
  151.     def click_submit(self):
  152.         """
  153.         点击登录按钮
  154.         :return: None
  155.         """
  156.         submit = self.wait.until(EC.element_to_be_clickable((By.ID, "btnLogin")))
  157.         submit.click()
  159.     def __del__(self):
  160.         self.browser.quit()
  163. def main():
  164.     """pass"""
  165.     c = Crack()
  166.     c.login()
  169. if __name__ == "__main__":
  170.     main()

发表评论

表情：
评论列表 （有 1 条评论，1202人围观）
蒲公英云3657FA
蒲公英云3657FAV铁粉 2022-12-12 16:49
这个地方免费的羊毛可以薅几百次，http://halo-dev.org/archives/ra

相关阅读

    相关 java爬虫破解滑块验证码

    > 使用技术：java+Selenium > > 废话： > > 有爬虫，自然就有反爬虫，就像病毒和杀毒软件一样，有攻就有防，两者彼此推进发展。而目前最流行的反爬技术验证码

    Dear 丶Dear 丶/ 0 赞/ 133 阅读

    相关 破解滑动验证码

    一、介绍 一些网站会在正常的账号密码认证之外加一些验证码，以此来明确地区分人/机行为，从一定程度上达到反爬的效果，对于简单的校验码Tesserocr就可以搞定，如下 !

    旧城等待，旧城等待，/ 0 赞/ 133 阅读

    相关 springboot文字图片点击验证码

    说明：因为刷新的图标和点击图片文字的时候需要在图片上生成图标，为了美观，所以我引入Font Awesome图标库，如果你需要的话需引入该图标库方可使用 先上验证码效果图：

    朱雀朱雀/ 0 赞/ 588 阅读