验证码破解技术四部曲之环境搭建篇（一）-老徐小屋

项目源码：https://github.com/nladuo/cap… (可以帮我点个star(^__^))
开发语言：python(编写爬虫),c++(编写图像处理部分以及机器学习算法)
开发环境：ubuntu 14.04
依赖库：
Python：PIL、BeautifulSoup4、requests
C++：boost、opencv2、tesseract-ocr

环境搭建

安装opencv 2.4.12

sudo apt-get install build-essential cmake libgtk2.0-dev pkg-config python-dev python-numpy libavcodec-dev libavformat-dev libswscale-dev

wget https://codeload.github.com/Itseez/opencv/zip/2.4.12

unzip opencv-2.4.12.zip

cd opencv-2.4.12 ; mkdir release ; cd release

cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..

make -j8

sudo make install

安装tesseract-ocr

1	sudo apt-get install tesseract-ocr tesseract-ocr-dev

安装boost

1	sudo apt-get install libboost-dev

安装python的PIL库

1	sudo apt-get install python-imaging

安装python的BeautifulSoup4、requests库

sudo apt-get install python-pip

sudo pip install bs4

sudo pip install requests

下载项目源码

1	git clone https://github.com/nladuo/captcha-break.git

本节的代码可以通过此处进行下载。

图像直方图

首先看验证码的样子，

可以看到这几个验证码最大的特点就是字母比较深，而周围的背景很浅，把图像转换成黑白颜色，可以显示的更加的明显。

//按黑白读取图像

Mat mat = imread("test1.jpg", 0);

cv::imshow("initial_mat", mat);

cv::waitKey(0);

可以看到所有背景的灰度值，都会小于字母的灰度值，为了让tesseract更准确的识别，可以把图像进行二值化，也就是把背景都改成纯白色，把字母都搞成纯黑色。那么如何确定分割的阈值呢？比较好的方法是画出图像的直方图。

//画出直方图

Histogram1D histogram1d;

cv::imshow("histogram1d", histogram1d.getHistogramImage(mat));

cv::waitKey(0);

直方图的横坐标代表灰度值，纵坐标代表指定灰度值的点数。

图像阈值

接下来，开始对图像进行阈值，这里选择的灰度值位150，灰度下于150的设置为白色，灰度大于150的设置为黑色。

//阈值

Mat threshold_mat;

cv::threshold(mat, threshold_mat, 150, 255, cv::THRESH_BINARY);

cv::imshow("threshold_mat", threshold_mat);

cv::waitKey(0);

Tesseract识别

把图片进行阈值后，就可以进行识别了，直接调用tesseract的API就好了。

//使用tesseract识别

char buffer[255];

OCRDecoder decoder;

decoder.decodeGrayMat(threshold_mat, buffer);

cout&lt;&lt;"result:"&lt;&lt;buffer&lt;&lt;endl;

运行程序，可以看到识别出了结果：

前言

在上一节中，我们使用了google的开源OCR库来对字符进行识别，这一节以及下一节我们将要使用机器学习算法来识别验证码。本节的代码都在https://github.com/nladuo/captcha-break/tree/master/csdn可以找到。

下载验证码

在这一节中，将要对CSDN下载的验证码进行破解，就是在http://download.csdn.net/下载东西的时候，短时间内下载次数过多弹出来的验证码。

做机器学习的第一个步骤就是采集数据，构建训练样本。首先，来看一下CSDN下载中出现的验证码。

在每次刷新的时候，会有以上这两种验证码出现。在本节中，为了方便学习K近邻算法（简称为：KNN），选择第二种来进行破解，因为第二种的字母分割十分容易，每个字母的位置都是固定的。

由于两种验证码的图片大小不一样，所以可以使用图片大小来判断哪个是第一种验证码，哪个是第二种验证码，这里使用python进行验证码下载。

# coding:utf-8

import requests

import uuid

from PIL import Image

import os

url = "http://download.csdn.net/index.php/rest/tools/validcode/source_ip_validate/10.5711163911089325"

for i in range(100):

resp = requests.get(url)

filename = "./captchas/" + str(uuid.uuid4()) + ".png"

with open(filename, 'wb') as f:

for chunk in resp.iter_content(chunk_size=1024):

if chunk: # filter out keep-alive new chunks

f.write(chunk)

f.flush()

f.close()

im = Image.open(filename)

if im.size != (48, 20):

os.remove(filename)

else:

print filename

分割字符

下载过后，就需要对字母进行分割。机器学习虽然牛逼，但是也需要对样本进行预处理，这里的预处理就是把字母分割出来，并且分割成同样的尺寸。分割的方式可以使用代码分割，当然也可以通过人用PS等工具进行手动分割。

我这里使用代码分割，字母分割的代码在spliter文件夹下，我使用了boost库来来读取所有下载的验证码，对图片进行二值化后，进行定点分割，可以看到分割好的字母如下。

之后，需要人工对字母进行分类，分类好的图片见recognizer/dataset，我这里每个字母需要6个样本，10个字母，总共60个样本。

算法原理

K近邻算法的定义十分简单，在百度百科上有这样的解释：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

也就是说，需要找到要识别的字母在训练样本中K个最近的字母，然后找出这K个字母中最多的是某个类的？要识别的图片也就是该类的。

实现KNN

计算距离

首先，先定义一下距离如何计算，这里可以用各种数学上的距离，欧式距离、马氏距离等等。。

由于我们的图片已经进行了二值化，为了简便起见，这里把两张图片的距离定义为：两张图片灰度不同的像素点个数。也就是逐个比较图片的相对位置上的灰度值，如果不相同，距离就加一。

int count_distance(Mat mat1, Mat mat2)

{

assert(mat1.size().height == mat2.size().height);

assert(mat1.size().width == mat2.size().width);

assert(mat1.channels() == 1 && mat2.channels() == 1);

int distance = 0;

for(int i = 0; i < mat1.size().width; i++){

for(int j = 0; j < mat1.size().height; j++){

if(mat1.at(j, i) != mat2.at(j, i)){//不相等就加1

distance++;

}

return distance;

}

加载数据

数据的加载需要一个图片数组和一个标签数组，来记录图片数组相应位置的类别。

加载样本数据：

void load_dataset(Mat dataset[])

{

string dataset_dir = "../recognizer/dataset/";

for(int i = 0; i < 6*10; i++){

char buffer[255];

sprintf(buffer, "%d", i/6);

string image_path = dataset_dir + string(buffer);

sprintf(buffer, "%d", i%6 + 1);

image_path += string(buffer) + ".png";

dataset[i] = imread(image_path, CV_LOAD_IMAGE_GRAYSCALE);

}

加载样本数据标签：

void create_labels(int labels[])

{

for(int i = 0; i < 6*10; i++){

labels[i] = i/6;

}

算法实现

加载完数据后，就可以开始实现KNN分类了。

1、计算输入图片和所有其他图片的距离

int distances[6*10];

int sorted_distances[6*10];

//count distances

for(int i = 0; i < 6*10 ;i++){

distances[i] = count_distance(letter, dataset[i]);

sorted_distances[i] = distances[i];

}

2、对距离进行排序

1	sort(sorted_distances, sorted_distances+6*10);

3、获取K个距离最近的图片的类别

int* k_nearest = new int[k];

for(int i = 0; i < k; i++){

for(int j = 0; j < 6*10 ; j++){

if(distances[j] == sorted_distances[i]){

k_nearest[i] = labels[j];

break;

}

4、利用map记录所有类别中出现k_nearest的次数

map<int, int> labels_map;

for(int i = 0; i < k; i++){

if(labels_map.find(k_nearest[i]) == labels_map.end())

labels_map[k_nearest[i]] = 0;

else

labels_map[k_nearest[i]]++;

}

5、得到出现最多的类别

int max_label = -1;

labels_map[max_label] = -1;

map<int,int>::iterator it;

for(it=labels_map.begin();it!=labels_map.end();++it){

if(it->second > labels_map[max_label]){

max_label = it->first;

}

delete[] k_nearest;

return max_label;

识别验证码

最后，我们把验证码的4个字母分割出来，再进行K近邻分类，就可以得到识别结果了。

void recognize(string path, Mat dataset[], int labels[])

{

Mat test_image = imread(path, CV_LOAD_IMAGE_GRAYSCALE);

threshold(test_image, test_image, 100, 255, cv::THRESH_BINARY);

Range col_ranges[4] = {

Range(5, 5+8),

Range(14, 14+8),

Range(23, 23+8),

Range(32, 32+8)

};

cout<<"Result:";

for(int i = 0; i < 4; i++){

Mat letter = test_image.colRange(col_ranges[i]);

cout << knn_classify(letter, dataset, labels, 5);

}

cout<<endl;

}

效果

识别图片:

识别结果:

练习

通过以上，我们破解了CSDN下载的第二种验证码，第一种验证码的识别过程也是可以使用KNN的，但是第一种和第二种的分割字母的方式不同，读者可以尝试使用opencv的findCountours函数对字母进行分割，或者使用垂直投影的方式进行分割，需要注意的是第一种验证码有一个黑色的边框，如果不处理会影响findCountours函数的效果。

前言

在这节，我将用卷积神经网络（简称：CNN）破解新浪微博手机端的验证码(http://login.weibo.cn/login/)，验证码如下。

本节的代码可以在https://github.com/nladuo/captcha-break/tree/master/weibo.cn找到。

关于神经网络的原理很难在一节讲清楚。在这里，只需要把神经网络当成一个黑匣子，输入是一个图片，输出一个label，也就是类别。

LeNet5

本节使用的神经网络是国外学者Yann LeCun的LeNet5，该神经网络以32×32的图片作为输入，对于字符的变形、旋转、干扰线等扭曲都可以很好的识别，可以实现以下效果。

更多的效果可以在http://yann.lecun.com/exdb/lenet/上查看，具体原理可以查看Yann LeCun的论文。

字符下载

字符下载和上节差不多，这里需要注意的是新浪微博的验证码下载下来是gif格式的，opencv不支持读取gif的读取，需要用PIL把验证码转换成png格式。

另外，新浪微博的验证码明显比CSDN下载的验证码要复杂得多，所以需要大量的样本，至少要下载上千个验证码。

字符分割

新浪微博的验证码需要进行去除椒盐噪声、去除干扰线、二值化后，才能很好的进行垂直投影分割，我算法写的不是很好，就不在这里展开了，代码可以在spliter中找到。LeNet5的输入是32×32像素，所以为了不对神经网络进行大量修改，也需要将每个字母都方法32*32的模板中，分割后如下：

分割好之后，需要开始大量的人工操作了，经过了几个小时的努力，成功完成了5000多样本的分类，结果放在了trainer/training_set中。

这里每个文件夹都是一个分类，共有14个分类（除了ERROR），点进文件夹后可以看到每个文件夹内都有300多张图片。

训练

构建网络

我这里使用的神经网络库是tiny-cnn（现在已改名叫tiny-dnn）。

训练相关的代码都在trainer/main.cpp中，首先看一下神经网络的构造函数。

void construct_net(network&amp; nn) {

// connection table [Y.Lecun, 1998 Table.1]

#define O true

#define X false

static const bool tbl[] = {

O, X, X, X, O, O, O, X, X, O, O, O, O, X, O, O,

O, O, X, X, X, O, O, O, X, X, O, O, O, O, X, O,

O, O, O, X, X, X, O, O, O, X, X, O, X, O, O, O,

X, O, O, O, X, X, O, O, O, O, X, X, O, X, O, O,

X, X, O, O, O, X, X, O, O, O, O, X, O, O, X, O,

X, X, X, O, O, O, X, X, O, O, O, O, X, O, O, O

};

#undef O

#undef X

// construct nets

nn &lt;&lt; convolutional_layer(32, 32, 5, 1, 6) // C1, 1@32x32-in, 6@28x28-out

&lt;&lt; average_pooling_layer(28, 28, 6, 2) // S2, 6@28x28-in, 6@14x14-out

&lt;&lt; convolutional_layer(14, 14, 5, 6, 16,

connection_table(tbl, 6, 16)) // C3, 6@14x14-in, 16@10x10-in

&lt;&lt; average_pooling_layer(10, 10, 16, 2) // S4, 16@10x10-in, 16@5x5-out

&lt;&lt; convolutional_layer(5, 5, 5, 16, 120) // C5, 16@5x5-in, 120@1x1-out

&lt;&lt; fully_connected_layer(120, 14); // F6, 120-in, 14-out

}

这里可以看到有六层神经网络，C1、S2、C3、S4、C5、F6。其实不用仔细的了解神经网络的构造，只需要把它想象成一个黑匣子，黑匣子的输入就是C1层的输入（C1, 1@32×32-in），黑匣子的输出就是F6层（F6,14-out）。32×32对应着图片的大小，14对应着类的个数。比如说要训练MINST数据集（一个手写字符的数据集）的话，需要把fully_connected_layer<tan_h>(120, 14)改成fully_connected_layer<tan_h>(120, 10)，因为MINST中有十类字符(0-9十种数字)。

（注：这里只能修改F6层的参数而不能修改C1层的参数，修改C1参数会影响到其他层的输入。）

加载数据集

接下来，通过boost库加载数据集，其中五分之四的样本作为训练，还有五分之一的作为测试训练的正确性。

std::string label_strs[14] = {

"3", "C", "D", "E", "F", "H", "J", "K", "L", "M", "N", "W", "X", "Y"

};

void load_dataset(std::vector &amp;train_labels,

std::vector &amp;train_images,

std::vector &amp;test_labels,

std::vector &amp;test_images)

{

for (int i = 0; i &lt; 14; ++i){

std::vector images;

fs::directory_iterator end_iter;

fs::path path("./training_set/"+label_strs[i]);

for (fs::directory_iterator iter(path); iter != end_iter; ++iter){

if (fs::extension(*iter)==".png"){

images.push_back(iter-&gt;path().string());

}

//train_set.size() : test_set.size() = 4:1

int flag = 0;

std::vector::iterator itr = images.begin();

for (;itr != images.end(); ++itr){

vec_t data;

convert_image(*itr, -1.0, 1.0, 32, 32, data);

if (flag &lt;= 4){

train_labels.push_back(i);

train_images.push_back(data);

}else{

test_labels.push_back(i);

test_images.push_back(data);

flag = 0;

}

flag++;

}

参数设置

卷积神经网络使用的是随机梯度下降进行训练，涉及一些数学知识，这里就不展开了。

这里只要把它理解为：神经网络会自己不断的对数据集进行学习(不断的迭代，每次迭代都会对识别率有所改进)。学习的过程会有一个学习速率optimizer.alpha，这里选择的是默认的；还有每次学习多少个数据(minibatch_size)，这里设置每次对100个数据进行学习；还有一个学习的时间(num_epochs)，这里学习了50次之后，学习效果就没有了。也就是识别率达到了峰值。

int minibatch_size = 100; //每批量的数量

int num_epochs = 50; //迭代次数

// optimizer.alpha *= std::sqrt(minibatch_size); 使用默认的学习速率

<span class="hljs-comment">// optimizer.alpha *= std::sqrt(minibatch_size); 使用默认的学习速率</span>

保存结果

神经网络的训练之后，需要保存神经网络的权重，把权重输出到”weibo.cn-nn-weights”中。

// save networks

std::ofstream ofs("weibo.cn-nn-weights");

ofs &lt;&lt; nn;

运行程序

运行trainer后，可以看到开始加载数据，并且进行一次一次的迭代，每一次迭代都会根据测试数据来进行验证，显示正确识别的字符数目。

从上面可以看到，一共有3934个训练样本和972个测试样本，正确识别的字符数目随着迭代次数不断的增加，从72->120->142->223….，识别率不断增加。

训练到最后(第四十几次迭代)，可以看到数据已经差不多饱和了,维持在860、870左右，也就是单个字符有89%的识别率，单个验证码有0.89^4=0.64左右的识别率。(如果训练了很多次后，发现识别率还没有饱和，可以增大迭代次数num_epochs或者增大学习速率optimizer.alpha)

识别

最后，可以通过训练好的“weibo.cn-nn-weights”来进行识别，把trainer/weibo.cn-nn-weights放到recognizer文件夹下。

接下来看看神经网络是如何进行识别的，在recognizer/main.cpp中查看recognize函数。

int recognize(const std::string&amp; dictionary, cv::Mat &amp;img) {

network nn;

construct_net(nn);

// load nets

ifstream ifs(dictionary.c_str());

ifs &gt;&gt; nn;

// convert cvMat to vec_t

vec_t data;

convert_mat(img, -1.0, 1.0, 32, 32, data);

// recognize

auto res = nn.predict(data);

vector&lt;pair&lt;double, int&gt; &gt; scores;

for (int i = 0; i &lt; 14; i++)

scores.emplace_back(rescale(res[i]), i);

// sort and get the result

sort(scores.begin(), scores.end(), greater&lt;pair&lt;double, int&gt;&gt;());

return scores[0].second;

}

在神经网络的最后一层中输出的是一个14维的向量，分别对应着每个类的概率，所以通过sort函数，找出概率最大的类就是识别结果了。

测试图片：

测试识别结果：

验证码破解技术四部曲之环境搭建篇（一）

环境搭建

安装opencv 2.4.12

安装tesseract-ocr

安装boost

安装python的PIL库

安装python的BeautifulSoup4、requests库

下载项目源码

图像直方图

图像阈值

Tesseract识别

前言

下载验证码

分割字符

算法原理

实现KNN

计算距离

加载数据

算法实现

识别验证码

效果

练习

前言

LeNet5

字符下载

字符分割

训练

构建网络

加载数据集

参数设置

保存结果

运行程序

识别

相关推荐

热门文章

分类目录

近期文章