devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

如何使用Java破解滑动验证码_解决滑块验证码java

作者：笔触狂放9 | 2024-03-22 10:15:35

赞

踩

解决滑块验证码java

最近有破解验证码的需求，没开始做之前我认为是比较难的，认为自己不一定能做出来，没想到最后做出来了，所以特地来记录一下这个过程供需要的小伙伴参考（包括我自己）。

使用Java + Selenium + OpenCV实现破解网易易盾滑动验证码

注意：Selenium + OpenCV这两个技术并不像一般的Java技术导入依赖就能直接使用，还需要下载驱动包、库等，所以需要先跟着入门案例来做才不会出问题。

网易易盾地址：
https://dun.163.com/trial/jigsaw

最终的效果是这样的：
自动打开浏览器，自动滑动破解

在这里插入图片描述

文章目录

一、前置工作

1.1 技术介绍

Selenium

Selenium是一个用于自动化Web浏览器操作的开源工具和框架。它提供了一组API和工具，可用于模拟用户在Web应用程序中的交互行为，例如点击按钮、填写表单、导航到不同的页面等操作。

OpenCV

OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和图像处理库。它提供了丰富的图像处理和计算机视觉算法，涵盖了从基本的图像操作到高级的计算机视觉任务的各种功能。

1.2 Selenium入门案例

先讲解一下这个技术是怎么使用的，这个跟一般的Java技术使用步骤不太一样，因为需要操作浏览器，所以需要下载一个驱动包。
使用步骤如下：

1. 下载驱动包

Edge浏览器Selenium驱动包下载地址：

https://msedgewebdriverstorage.z22.web.core.windows.net/

Chrome浏览器驱动包下载地址：

https://registry.npmmirror.com/binary.html?path=chromedriver/

注意：这里的版本要跟自己的浏览器版本对应上
因为Edge浏览器的版本写的比较明确，所以就用Edge了。
在这里插入图片描述
根据自己的操作系统选择对应压缩包
在这里插入图片描述
解压出来将驱动放到一个位置，之后要在程序中引用驱动的路径。

2. 导入依赖
<!-- Selenium WebDriver -->
<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>3.141.59</version>
</dependency>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
3. 在代码中使用

下面是一个非常简单的入门案例，效果就是自动打开浏览器，然后获取百度网页内容，将获取到的内容输出到控制台，大家可以自己运行下试试，就能明白selenium起到的一个作用了。

注意：将这里的驱动位置改为自己的驱动所在的位置，

System.setProperty("webdriver.edge.driver","D:\\codetool\\msedgedriver.exe");

  • 1

代码：

package com.example.demo.testyanz;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.edge.EdgeDriver;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SeleniumTest {


    @Test
    public void test01() throws InterruptedException {
        //设置驱动
        System.setProperty("webdriver.edge.driver","D:\\codetool\\msedgedriver.exe");
        //创建驱动
        WebDriver driver=new EdgeDriver();
        driver.get("https://www.baidu.com");
        //从driver的网页内容中取出class为title-content-title
        driver.findElements(By.className("title-content-title")).forEach(e->{
            System.out.println(e.getText());
        });
        Thread.sleep(5000);
        //关闭
        driver.close();
        //退出
        driver.quit();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

附上驱动使用的一些简单API，可以简单了解一下

相关API

 1.元素选择方式
 
 1）Class选择：driver.findElement(By.className("s_ipt"));
 2）ID选择：   driver.findElement(By.id("kw"));
 3）name选择： driver.findElement(By.name("wd"));
 4）tag选择：  driver.findElements(By.tagName("input"));
 5）link选择： driver.findElement(By.linkText("地图"));
 6）Partial link选择（a标签文本内容模糊匹配）：driver.findElement(By.partialLinkText("使用百"));
 7）css选择器：driver.findElement(By.cssSelector("#kw"));
 8）xpath选择：driver.findElement(By.xpath("//*[@id=\"kw\"]"));

 2.获取单个元素：driver.findElement

 3.获取多个元素：driver.findElements

 4.输入内容：input.sendKeys("java");

 5.元素点击：element.click();

 6.获取元素属性：nextPageEle.getAttribute("class")

 7.获取标签文本内容：titleEle.getText()

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

1.3 OpenCV入门案例

opencv也是要提前下载东西才能使用，
官网的下载地址：
https://opencv.org/releases/page/2/

1、下载文件，解压

在官网下载到的是一个可运行文件，其实就是一个解压程序，直接双击运行即可，运行后会把opencv的相关文件解压到填写的路径
在这里插入图片描述

2、导入依赖
<!-- OpenCV -->
<dependency>
    <groupId>org.openpnp</groupId>
    <artifactId>opencv</artifactId>
    <version>4.5.1-2</version>
</dependency>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
3、在代码中使用

然后就能使用Mat跟Imgcodecs等相关的类了
下面是一个入门案例，效果就是把彩色图片转换成黑白的。
代码中需要改的有三处，需要将这三处的路径改为自己的

    public static String dllPath = "D:/codetool/OpenCV/opencv/build/java/x64/opencv_java451.dll";
    //读取图像
    Mat image = imread("D:\\1689902715777.png");
    //输出图像
    imwrite("D://hello.jpg", grayImage);

  • 1
  • 2
  • 3
  • 4
  • 5
package com.example.demo.testyanz;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.opencv.core.*;
import org.opencv.core.CvType;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.net.URL;

import static org.opencv.highgui.HighGui.imshow;
import static org.opencv.imgcodecs.Imgcodecs.imread;
import static org.opencv.imgcodecs.Imgcodecs.imwrite;
import static org.opencv.imgproc.Imgproc.COLOR_RGB2GRAY;

import static org.opencv.highgui.HighGui.imshow;
import static org.opencv.highgui.HighGui.waitKey;
import static org.opencv.imgcodecs.Imgcodecs.imread;
import static org.opencv.imgcodecs.Imgcodecs.imwrite;
import static org.opencv.imgproc.Imgproc.COLOR_RGB2GRAY;
import static org.opencv.imgproc.Imgproc.cvtColor;

@RunWith(SpringRunner.class)
@SpringBootTest
public class OpencvTest {
    public static String dllPath = "D:/codetool/OpenCV/opencv/build/java/x64/opencv_java451.dll";
    @Test
    public void testopencv() throws Exception {
        //解决awt 报错问题
        System.setProperty("java.awt.headless", "false");
        System.out.println(System.getProperty("java.library.path"));
        //加载动态库
//        URL url = classLoader.getSystemResource("lib/opencv/opencv_java440.dll");

        System.load(dllPath);
        //读取图像
        Mat image = imread("D:\\1689902715777.png");
        if (image.empty()) {
            throw new Exception("image is empty");
        }
        imshow("Original Image", image);
        //创建输出单通道图像
        Mat grayImage = new Mat(image.rows(), image.cols(), CvType.CV_8SC1);
        //进行图像色彩空间转换
        cvtColor(image, grayImage, COLOR_RGB2GRAY);
        imshow("Processed Image", grayImage);
        imwrite("D://hello.jpg", grayImage);
        waitKey();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

二、过程分析

理论上来说，如果能获取到不同网站的这些元素，就能破解验证码，关于这点我并没有尝试，大家可以自己换成自己的目标网站去试一下。

1、获取元素

下图是我们要破解的验证码，我们要拿到验证码的三个元素
1、大的背景图
2、小的拼图
3、鼠标要拖动的滑块
1跟2是要用于分析计算距离的
3是要模拟鼠标点击滑动的
在这里插入图片描述
这里我们可以看到这个img标签中src有图片的url地址
在这里插入图片描述
这里我们使用selenium中的By对象来通过class属性获取到对应的元素，再使用getAttribute方法获取src对应的图片url地址。
这样1跟2就已经获取到了
在这里插入图片描述
下面接着获取滑块元素，

注意：这里是有一个坑的，我们会发现这个滑块对应的div标签的class属性是分两块的，中间用了空格分隔。这样的话我们直接用上面的方式By.className是获取不到这个元素的。
这里我们使用By.cssSelector来获取。
在这里插入图片描述

在这里插入图片描述

补充：By对象获取元素的一些常见用法

  1. 使用元素的 ID 进行定位：By byId = By.id("elementId");

  2. 使用元素的类名进行定位：By byClassName = By.className("className");

  3. 使用元素的标签名进行定位：By byTagName = By.tagName("tagName");

  4. 使用元素的名称进行定位：By byName = By.name("name");

  5. 使用元素的链接文本进行定位（适用于 <a> 标签）：By byLinkText = By.linkText("linkText");

  6. 使用元素的部分链接文本进行定位（适用于 <a> 标签）：By byPartialLinkText = By.partialLinkText("partialLinkText");

  7. 使用元素的 CSS 选择器进行定位：By byCssSelector = By.cssSelector("cssSelector");

  8. 使用元素的 XPath 进行定位：By byXPath = By.xpath("xpathExpression");

可以根据需要选择合适的定位方式，并使用相应的 By 对象进行元素定位。

2、方法调用

1、首先要调用这个getDistance方法，传入上面获取到的背景图和拼图的url，计算出滑动距离
在这里插入图片描述

2、调用waitWebElement方法，传入浏览器驱动对象，By 对象（也就是使用By获取到的滑块元素），重试次数（随便传一个即可，我直接在外部进行判断了，因为目标网站不同，成功时候的判断也就不同）
在这里插入图片描述
3、调用模拟移动滑块，进行滑块的移动，传入浏览器驱动对象，waitWebElement方法返回的对象，跟distance距离
在这里插入图片描述

3、结果判断

我们在拖动滑块的过程中会发现，这个div的class是一直在变化的
这是未拖动时的状态：
在这里插入图片描述
这是已经验证成功了的状态：
在这里插入图片描述
因此，我们可以将这个条件作为已经验证成功了的条件判断

List<WebElement> successElements = driver.findElements(By.cssSelector(".yidun.yidun-custom.yidun--light.yidun--float.yidun--size-small.yidun--jigsaw.yidun--success"));
            if (!successElements.isEmpty()) {
                System.out.println("验证码验证成功！");
                // 验证成功后跳出循环
                success = true;
            } else {
                System.out.println("验证码验证失败！");
                // 验证失败后继续循环执行
            }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

三、完整代码

工具类

使用时将工具类注入到需要使用的类中，调用里面的方法即可。

package com.example.demo.utils;


import org.apache.commons.io.FileUtils;
import org.opencv.core.*;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;
import org.springframework.stereotype.Component;
import sun.misc.BASE64Decoder;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
@Component
public class Yanzhengma {

    public static String dllPath = "D:/codetool/OpenCV/opencv/build/java/x64/opencv_java451.dll";

    /**
     * 获取网易验证滑动距离
     * @param bUrl 大图像url
     * @param sUrl 小图像url
     * @return
     */
    public double getDistance(String bUrl, String sUrl) {
        System.load(dllPath);
        File bFile = new File("D:/EasyDun_b.png");
        File sFile = new File("D:/EasyDun_s.png");
        try {
            FileUtils.copyURLToFile(new URL(bUrl), bFile);
            FileUtils.copyURLToFile(new URL(sUrl), sFile);
            BufferedImage bgBI = ImageIO.read(bFile);
            BufferedImage sBI = ImageIO.read(sFile);
            // 裁剪
            cropImage(bgBI, sBI, bFile, sFile);
            Mat s_mat = Imgcodecs.imread(sFile.getPath());
            Mat b_mat = Imgcodecs.imread(bFile.getPath());

            //阴影部分为黑底时需要转灰度和二值化，为白底时不需要
            // 转灰度图像
            Mat s_newMat = new Mat();
            Imgproc.cvtColor(s_mat, s_newMat, Imgproc.COLOR_BGR2GRAY);
            // 二值化图像
            binaryzation(s_newMat);
            Imgcodecs.imwrite(sFile.getPath(), s_newMat);

            int result_rows = b_mat.rows() - s_mat.rows() + 1;
            int result_cols = b_mat.cols() - s_mat.cols() + 1;
            Mat g_result = new Mat(result_rows, result_cols, CvType.CV_32FC1);
            Imgproc.matchTemplate(b_mat, s_mat, g_result, Imgproc.TM_SQDIFF); // 归一化平方差匹配法TM_SQDIFF 相关系数匹配法TM_CCOEFF

            Core.normalize(g_result, g_result, 0, 1, Core.NORM_MINMAX, -1, new Mat());
            Point matchLocation = new Point();
            Core.MinMaxLocResult mmlr = Core.minMaxLoc(g_result);
            matchLocation = mmlr.maxLoc; // 此处使用maxLoc还是minLoc取决于使用的匹配算法
            Imgproc.rectangle(b_mat, matchLocation, new Point(matchLocation.x + s_mat.cols(), matchLocation.y + s_mat.rows()), new Scalar(0, 255, 0, 0));
            Imgcodecs.imwrite(bFile.getPath(), b_mat);
            return matchLocation.x + s_mat.cols() - sBI.getWidth() + 12;
        } catch (Throwable e) {
            e.printStackTrace();
            return 0;
        } finally {
            bFile.delete();
            sFile.delete();
        }
    }

    /**
     * 图片亮度调整
     *
     * @param image
     * @param param
     * @throws IOException
     */
    public void bloding(BufferedImage image, int param) throws IOException {
        if (image == null) {
            return;
        } else {
            int rgb, R, G, B;
            for (int i = 0; i < image.getWidth(); i++) {
                for (int j = 0; j < image.getHeight(); j++) {
                    rgb = image.getRGB(i, j);
                    R = ((rgb >> 16) & 0xff) - param;
                    G = ((rgb >> 8) & 0xff) - param;
                    B = (rgb & 0xff) - param;
                    rgb = ((clamp(255) & 0xff) << 24) | ((clamp(R) & 0xff) << 16) | ((clamp(G) & 0xff) << 8) | ((clamp(B) & 0xff));
                    image.setRGB(i, j, rgb);

                }
            }
        }
    }

    // 判断a,r,g,b值，大于256返回256，小于0则返回0,0到256之间则直接返回原始值
    private int clamp(int rgb) {
        if (rgb > 255)
            return 255;
        if (rgb < 0)
            return 0;
        return rgb;
    }

    /**
     * 生成半透明小图并裁剪
     *
     * @param
     * @return
     */
    private void cropImage(BufferedImage bigImage, BufferedImage smallImage, File bigFile, File smallFile) {
        int y = 0;
        int h_ = 0;
        try {
            // 2 生成半透明图片
            bloding(bigImage, 75);
            for (int w = 0; w < smallImage.getWidth(); w++) {
                for (int h = smallImage.getHeight() - 2; h >= 0; h--) {
                    int rgb = smallImage.getRGB(w, h);
                    int A = (rgb & 0xFF000000) >>> 24;
                    if (A >= 100) {
                        rgb = (127 << 24) | (rgb & 0x00ffffff);
                        smallImage.setRGB(w, h, rgb);
                    }
                }
            }
            for (int h = 1; h < smallImage.getHeight(); h++) {
                for (int w = 1; w < smallImage.getWidth(); w++) {
                    int rgb = smallImage.getRGB(w, h);
                    int A = (rgb & 0xFF000000) >>> 24;
                    if (A > 0) {
                        if (y == 0)
                            y = h;
                        h_ = h - y;
                        break;
                    }
                }
            }
            smallImage = smallImage.getSubimage(0, y, smallImage.getWidth(), h_);
            bigImage = bigImage.getSubimage(0, y, bigImage.getWidth(), h_);
            ImageIO.write(bigImage, "png", bigFile);
            ImageIO.write(smallImage, "png", smallFile);
        } catch (Throwable e) {
            System.out.println(e.toString());
        }
    }

    /**
     * @param mat 二值化图像
     */
    public static void binaryzation(Mat mat) {
        int BLACK = 0;
        int WHITE = 255;
        int ucThre = 0, ucThre_new = 127;
        int nBack_count, nData_count;
        int nBack_sum, nData_sum;
        int nValue;
        int i, j;
        int width = mat.width(), height = mat.height();
        // 寻找最佳的阙值
        while (ucThre != ucThre_new) {
            nBack_sum = nData_sum = 0;
            nBack_count = nData_count = 0;

            for (j = 0; j < height; ++j) {
                for (i = 0; i < width; i++) {
                    nValue = (int) mat.get(j, i)[0];

                    if (nValue > ucThre_new) {
                        nBack_sum += nValue;
                        nBack_count++;
                    } else {
                        nData_sum += nValue;
                        nData_count++;
                    }
                }
            }
            nBack_sum = nBack_sum / nBack_count;
            nData_sum = nData_sum / nData_count;
            ucThre = ucThre_new;
            ucThre_new = (nBack_sum + nData_sum) / 2;
        }
        // 二值化处理
        int nBlack = 0;
        int nWhite = 0;
        for (j = 0; j < height; ++j) {
            for (i = 0; i < width; ++i) {
                nValue = (int) mat.get(j, i)[0];
                if (nValue > ucThre_new) {
                    mat.put(j, i, WHITE);
                    nWhite++;
                } else {
                    mat.put(j, i, BLACK);
                    nBlack++;
                }
            }
        }
        // 确保白底黑字
        if (nBlack > nWhite) {
            for (j = 0; j < height; ++j) {
                for (i = 0; i < width; ++i) {
                    nValue = (int) (mat.get(j, i)[0]);
                    if (nValue == 0) {
                        mat.put(j, i, WHITE);
                    } else {
                        mat.put(j, i, BLACK);
                    }
                }
            }
        }
    }



    /**
     *     延时加载
     * @param driver 浏览器驱动对象，用于与浏览器进行通信和控制。
     * @param by By 对象，用于指定要查找的元素的定位方式（如 ID、CSS 选择器、XPath 等）。
     * @param count 重试次数，表示在超时之前最多重试的次数。
     * @return
     * @throws Exception
     */
    public static WebElement waitWebElement(WebDriver driver, By by, int count) throws Exception {
        WebElement webElement = null;
        boolean isWait = false;
        for (int k = 0; k < count; k++) {
            try {
                webElement = driver.findElement(by);
                if (isWait)
                    System.out.println(" ok!");
                return webElement;
            } catch (org.openqa.selenium.NoSuchElementException ex) {
                isWait = true;
                if (k == 0)
                    System.out.print("waitWebElement(" + by.toString() + ")");
                else
                    System.out.print(".");
                Thread.sleep(50);
            }
        }
        if (isWait)
            System.out.println(" outTime!");
        return null;
    }


    /**
     * 模拟人工移动
     *
     * @param driver 浏览器驱动对象，用于与浏览器进行通信和控制。
     * @param element  页面滑块
     * @param distance 需要移动距离
     */
    public static void move(WebDriver driver, WebElement element, int distance) throws InterruptedException {
        int randomTime = 0;
        if (distance > 90) {
            randomTime = 250;
        } else if (distance > 80 && distance <= 90) {
            randomTime = 150;
        }
        List<Integer> track = getMoveTrack(distance - 2);
        int moveY = 1;
        try {
            Actions actions = new Actions(driver);
            actions.clickAndHold(element).perform();
            Thread.sleep(200);
            for (int i = 0; i < track.size(); i++) {
                actions.moveByOffset(track.get(i), moveY).perform();
                Thread.sleep(new Random().nextInt(300) + randomTime);
            }
            Thread.sleep(200);
            actions.release(element).perform();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据距离获取滑动轨迹
     *
     * @param distance 需要移动的距离
     * @return
     */
    public static List<Integer> getMoveTrack(int distance) {
        List<Integer> track = new ArrayList<>();// 移动轨迹
        Random random = new Random();
        int current = 0;// 已经移动的距离
        int mid = (int) distance * 4 / 5;// 减速阈值
        int a = 0;
        int move = 0;// 每次循环移动的距离
        while (true) {
            a = random.nextInt(10);
            if (current <= mid) {
                move += a;// 不断加速
            } else {
                move -= a;
            }
            if ((current + move) < distance) {
                track.add(move);
            } else {
                track.add(distance - current);
                break;
            }
            current += move;
        }
        return track;
    }


}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321

测试类

package com.example.demo.testyanz;

import com.example.demo.utils.Yanzhengma;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.edge.EdgeDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

import static org.openqa.selenium.By.cssSelector;

@RunWith(SpringRunner.class)
@SpringBootTest
public class YanzhengmaTest2 {

    @Autowired
    private Yanzhengma yanzhengma;

    public static String dllPath = "D:/codetool/OpenCV/opencv/build/java/x64/opencv_java451.dll";

    //滑动验证码破解
    @Test
    public void testSomeMethod() throws Exception {
        // 设置驱动路径
        System.setProperty("webdriver.edge.driver", "D:\\codetool\\msedgedriver.exe");
        // 创建驱动
        WebDriver driver = new EdgeDriver();
        // 连接目标网站
        driver.get("https://dun.163.com/trial/jigsaw");



        // 最大尝试次数
        int maxRetries = 5;
        int retryCount = 0;
        double distance = 0;
        WebElement webElement = null;
        boolean success = false;

        while (retryCount < maxRetries && !success) {
            // 从driver的网页内容中取出大图跟小图的url
            WebElement bimageElement = driver.findElement(By.className("yidun_bg-img"));
            String bimageURL = bimageElement.getAttribute("src");

            WebElement simageElement = driver.findElement(By.className("yidun_jigsaw"));
            String simageURL = simageElement.getAttribute("src");
            // 大图像url
            String bUrl = bimageURL;
            // 小图像url
            String sUrl = simageURL;

            // 获取网易验证滑动距离
            distance = yanzhengma.getDistance(bUrl, sUrl);
            System.out.println(distance + "distance++++++++++++++++++");

            // 等待页面加载完成
            Thread.sleep(5000);

            // 根据类名定位滑块元素
            By sliderByClassName = By.cssSelector(".yidun_slider.yidun_slider--hover");
            webElement = Yanzhengma.waitWebElement(driver, sliderByClassName, 3);
            //System.out.println(webElement + "webElement+++++++++++++");

            // 模拟人工移动
            int distance1 = (int) distance;
            Yanzhengma.move(driver, webElement, distance1);
            Thread.sleep(5000);
            
            List<WebElement> successElements = driver.findElements(By.cssSelector(".yidun.yidun-custom.yidun--light.yidun--float.yidun--size-small.yidun--jigsaw.yidun--success"));
            if (!successElements.isEmpty()) {
                System.out.println("验证码验证成功！");
                // 验证成功后跳出循环
                success = true;
            } else {
                System.out.println("验证码验证失败！");
                // 验证失败后继续循环执行
            }
            Thread.sleep(5000);
            // 尝试次数加1
            retryCount++;
        }
        driver.quit();
    }


}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/287161?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号