最近有破解验证码的需求，没开始做之前我认为是比较难的，认为自己不一定能做出来，没想到最后做出来了，所以特地来记录一下这个过程供需要的小伙伴参考（包括我自己）。
使用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>
3. 在代码中使用
下面是一个非常简单的入门案例，效果就是自动打开浏览器，然后获取百度网页内容，将获取到的内容输出到控制台，大家可以自己运行下试试，就能明白selenium起到的一个作用了。
注意：将这里的驱动位置改为自己的驱动所在的位置，
System.setProperty("webdriver.edge.driver","D:\\codetool\\msedgedriver.exe");
代码：
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();
}
}
附上驱动使用的一些简单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.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>
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);
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、获取元素
下图是我们要破解的验证码，我们要拿到验证码的三个元素
1、大的背景图
2、小的拼图
3、鼠标要拖动的滑块
1跟2是要用于分析计算距离的
3是要模拟鼠标点击滑动的
这里我们可以看到这个img标签中src有图片的url地址
这里我们使用selenium中的By对象来通过class属性获取到对应的元素，再使用getAttribute方法获取src对应的图片url地址。
这样1跟2就已经获取到了
下面接着获取滑块元素，
注意：这里是有一个坑的，我们会发现这个滑块对应的div标签的class属性是分两块的，中间用了空格分隔。这样的话我们直接用上面的方式By.className是获取不到这个元素的。
这里我们使用By.cssSelector来获取。
补充：By对象获取元素的一些常见用法
-
使用元素的 ID 进行定位：
By byId = By.id("elementId"); -
使用元素的类名进行定位：
By byClassName = By.className("className"); -
使用元素的标签名进行定位：
By byTagName = By.tagName("tagName"); -
使用元素的名称进行定位：
By byName = By.name("name"); -
使用元素的链接文本进行定位（适用于
<a>标签）：By byLinkText = By.linkText("linkText"); -
使用元素的部分链接文本进行定位（适用于
<a>标签）：By byPartialLinkText = By.partialLinkText("partialLinkText"); -
使用元素的 CSS 选择器进行定位：
By byCssSelector = By.cssSelector("cssSelector"); -
使用元素的 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("验证码验证失败！");
// 验证失败后继续循环执行
}
三、完整代码
工具类
使用时将工具类注入到需要使用的类中，调用里面的方法即可。
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;
}
}
测试类
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();
}
}
2338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
