I received a job today. I recognized a simple verification code. This verification code is straightforward. It has very little interference information. So just get the information for comparison. It is easy to identify.

But everything won’t be so smooth. Maybe it’s for me. I think what I do is very tortuous…

This captcha image is generated using ASP. It is, of course, a BMP format.

But for PHP, this is a soft injury because PHP’s GD library does not include BMP at all. Although there is wbmp, it is still different.

So I googled it. The result made me feel a bit of joy. There is a ready-made class that recognizes 256-color BMP. It is very exciting. It is not a matter of white money!!

The result is disappointing. The 256-color BMP and 24-bit color are two concepts. This means that I have to rewrite it..

It seems that there are no ready-made libraries and functions. You can only write it yourself. Analyze the BMP header with the most primitive open. A byte read.

All went to google BMP 24-bit color head analysis.. so long article… immediately disappointed..

So boring to go through the manual.. Look at the imagecreatefromgif imagecreatefromjpeg, imagecreatefrompng, imagecreatefromwbmp and so on. There is no imagecreatefrombmp

So suddenly whimsy. Go to google about imagecreatefrombmp what will be the result. Sure enough, I did not expect. There have been people who wrote this function..

1. function imagecreatefrombmp($file)
2. {
3.     global  $CurrentBit, $echoMode;
5.     $f=fopen($file,“r”);
6.     $Header=fread($f,2);
8.     if($Header==“BM”)
9.     {
10.         $Size=freaddword($f);
11.         $Reserved1=freadword($f);
12.         $Reserved2=freadword($f);
13.         $FirstByteOfImage=freaddword($f);
15.         $SizeBITMAPINFOHEADER=freaddword($f);
16.         $Width=freaddword($f);
17.         $Height=freaddword($f);
18.         $biPlanes=freadword($f);
19.         $biBitCount=freadword($f);
20.         $RLECompression=freaddword($f);
21.         $WidthxHeight=freaddword($f);
22.         $biXPelsPerMeter=freaddword($f);
23.         $biYPelsPerMeter=freaddword($f);
24.         $NumberOfPalettesUsed=freaddword($f);
25.         $NumberOfImportantColors=freaddword($f);
27.         if($biBitCount<24)
28.         {
29.             $img=imagecreate($Width,$Height);
30.             $Colors=pow(2,$biBitCount);
31.             for($p=0;$p<$Colors;$p++)
32.             {
33.                 $B=freadbyte($f);
34.                 $G=freadbyte($f);
35.                 $R=freadbyte($f);
36.                 $Reserved=freadbyte($f);
37.                 $Palette[]=imagecolorallocate($img,$R,$G,$B);
38.             };
43.             if($RLECompression==0)
44.             {
45.                 $Zbytek=(4-ceil(($Width/(8/$biBitCount)))%4)%4;
47.                 for($y=$Height-1;$y>=0;$y–)
48.                 {
49.                     $CurrentBit=0;
50.                     for($x=0;$x<$Width;$x++)
51.                     {
52.                         $C=freadbits($f,$biBitCount);
53.                         imagesetpixel($img,$x,$y,$Palette[$C]);
54.                     };
55.                     if($CurrentBit!=0) {freadbyte($f);};
56.                     for($g=0;$g<$Zbytek;$g++)
57.                     freadbyte($f);
58.                 };
60.             };
61.         };
64.         if($RLECompression==1) //$BI_RLE8
65.         {
66.             $y=$Height;
68.             $pocetb=0;
70.             while(true)
71.             {
72.                 $ and -;
73.                 $prefix=freadbyte($f);
74.                 $suffix=freadbyte($f);
75.                 $pocetb+=2;
77.                 $echoit=false;
79.                 if($echoit)echo “Prefix: $prefix Suffix: $suffix<BR>”;
80.                 if(($prefix==0)and($suffix==1)) break;
81.                 if(feof($f)) break;
83.                 while(!(($prefix==0)and($suffix==0)))
84.                 {
85.                     if($prefix==0)
86.                     {
87.                         $pocet=$suffix;
88.                         $Data.=fread($f,$pocet);
89.                         $ pocetb + = $ number ;
90.                         if($pocetb%2==1) {freadbyte($f); $pocetb++;};
91.                     };
92.                     if($prefix>0)
93.                     {
94.                         $ count = $ prefix ;
95.                         for($r=0;$r<$pocet;$r++)
96.                         $Data.=chr($suffix);
97.                     };
98.                     $prefix=freadbyte($f);
99.                     $suffix=freadbyte($f);
100.                     $pocetb+=2;
101.                     if($echoit) echo “Prefix: $prefix Suffix: $suffix<BR>”;
102.                 };
104.                 for($x=0;$x<strlen($Data);$x++)
105.                 {
106.                     imagesetpixel($img,$x,$y,$Palette[ord($Data[$x])]);
107.                 };
108.                 $Data=“”;
110.             };
112.         };
115.         if($RLECompression==2) //$BI_RLE4
116.         {
117.             $y=$Height;
118.             $pocetb=0;
120.             /*while(!feof($f))
121.             echo freadbyte($f).”_”.freadbyte($f).”<BR>”;*/
122.             while(true)
123.             {
124.                 //break;
125.                 $ and -;
126.                 $prefix=freadbyte($f);
127.                 $suffix=freadbyte($f);
128.                 $pocetb+=2;
130.                 $echoit=false;
132.                 if($echoit)echo “Prefix: $prefix Suffix: $suffix<BR>”;
133.                 if(($prefix==0)and($suffix==1)) break;
134.                 if(feof($f)) break;
136.                 while(!(($prefix==0)and($suffix==0)))
137.                 {
138.                     if($prefix==0)
139.                     {
140.                         $pocet=$suffix;
142.                         $CurrentBit=0;
143.                         for($h=0;$h<$pocet;$h++)
144.                         $Data.=chr(freadbits($f,4));
145.                         if($CurrentBit!=0) freadbits($f,4);
146.                         $ pocetb + = ceil (( $ number / 2));
147.                         if($pocetb%2==1) {freadbyte($f); $pocetb++;};
148.                     };
149.                     if($prefix>0)
150.                     {
151.                         $ count = $ prefix ;
152.                         $i=0;
153.                         for($r=0;$r<$pocet;$r++)
154.                         {
155.                             if($i%2==0)
156.                             {
157.                                 $Data.=chr($suffix%16);
158.                             }
159.                             else
160.                             {
161.                                 $Data.=chr(floor($suffix/16));
162.                             };
163.                             $i++;
164.                         };
165.                     };
166.                     $prefix=freadbyte($f);
167.                     $suffix=freadbyte($f);
168.                     $pocetb+=2;
169.                     if($echoit) echo “Prefix: $prefix Suffix: $suffix<BR>”;
170.                 };
172.                 for($x=0;$x<strlen($Data);$x++)
173.                 {
174.                     imagesetpixel($img,$x,$y,$Palette[ord($Data[$x])]);
175.                 };
176.                 $Data=“”;
178.             };
180.         };
183.         if($biBitCount==24)
184.         {
185.             $img=imagecreatetruecolor($Width,$Height);
186.             $Zbytek=$Width%4;
188.             for($y=$Height-1;$y>=0;$y–)
189.             {
190.                 for($x=0;$x<$Width;$x++)
191.                 {
192.                     $B=freadbyte($f);
193.                     $G=freadbyte($f);
194.                     $R=freadbyte($f);
195.                     $color=imagecolorexact($img,$R,$G,$B);
196.                     if($color==-1) $color=imagecolorallocate($img,$R,$G,$B);
197.                     imagesetpixel($img,$x,$y,$color);
198.                 }
199.                 for($z=0;$z<$Zbytek;$z++)
200.                 freadbyte($f);
201.             };
202.         };
203.         return $img;
205.     };
208.     fclose($f);
211. };
213. function freadbyte($f)
214. {
215.     return ord(fread($f,1));
216. };
218. function freadword($f)
219. {
220.     $b1=freadbyte($f);
221.     $b2=freadbyte($f);
222.     return $b2*256+$b1;
223. };
225. function freaddword($f)
226. {
227.     $b1=freadword($f);
228.     $b2=freadword($f);
229.     return $b2*65536+$b1;
230. };

The process of this function is like this: Open the file with fopen. Read one byte and one byte. Read the BMP header first. Then read the pixel line by line. Then use imagecreatetruecolor to create an image. Just read the pixel. Then draw one by one to the image you just created.
Finally return the resource of this image.

It is estimated that everyone is like me. I was scared by such a long function at the beginning. In fact, don’t be afraid. Analyze it. We want to analyze the 24-bit color BMP. So most of the above functions do not use .if($biBitCount= =24) The following are the key:

$B=freadbyte($f);
$G=freadbyte($f);
$R=freadbyte($f);

These three lines are for reading pixels. All we need is to put each pixel into an array. This is easy to manipulate.

$array[] = sprintf(“%03d”,$R).sprintf(“%03d”,$G).sprintf(“%03d”,$B);

So we put each pixel in the array of $array. But this is not enough. Because we have to identify the pixel. So I think so. Change the white (255255255) to 0. The other colors are changed to 1. This is because my verification code is relatively simple. And the interference color is very small..

The resulting $array is similar to this.

0001111000   0001111000   0001111000   0000101000
0010000100   0010000100   0010000100   0000100000
0010000100   0010000100   0010000100   0000100000
0010110100   0000000100   0000000100   0000100000
0010110100   0000101000   0000000100   0000100000
0010110100   0000110000   0011000100   0000010000
0010110100   0000001000   0010111000   0000010000
0010000100   0010000100   0010000000   0010001000
0011000100   0010000110   0010000000   0010001000
0001111000   0001111000   0011111100   0011111100

Of course, the reason why this is formed is what I processed when I output it.
It is easy to see clearly. This is 0357..

Some people will ask why it is down? This is because the BMP is stored upside down when storing images. Compare BT.
But don’t worry about this. We don’t have to give him a hard time coming over. Because we are doing comparisons. This comparison code is also upside down.

In order to more clearly explain how this array is stored in white. I will give you a detailed description. Just follow the example above.

Array subscript 0 1 2 3 4 5 6 7 8 9 10….. 39
Storage contents 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 0 0 First line

Array subscript 40 41 …. …79Store
contents 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 second line

I will not write it for the sake of omission. It is easy to see. This is a one-dimensional array. There are 399 elements in total.. But in order to identify the verification code, we have to take each of them out.

0-9 40-49 80-89 … is a group of
10-19 50-59 90-99 … for a group of
20-29 60-69 100-109… for a group of
30-39 70-79 110-119.. As a group

You can write your own algorithm:

After sorting this out, it is an array of 4 elements.
Each element has 100 digits of 0 and 1.

The element is taken out. Who is it to compare with?? Yes. We have to find a reference object..
Finding the reference object is physical strength..
Return to the above process.. Constantly refresh the verification code.. until 0 -9 has appeared. For each. Write down his appearance, say 0 is like this

0001111000
0010000100
0010000100
0010110100
0010110100
0010110100
0010110100
0010000100
0011000100
0001111000

It becomes a string. 0 is like this. 0001111000001000010000100001000010110100001011010000101101000010110100001000010000110001000001111000
is also placed in the above order in a row.

After 0-9 is written down, we can put it in an array, called $key.

This is a one-to-one correspondence with the elements we generated.

The next step is to start comparing.

Looping is inevitable. The trick is to compare the similar_text and reference objects one by one. Put the Acacia percentage into an array.
Then take the largest percentage of the array. The corresponding index value (this index value is not automatically generated) Is the number we have identified.
The following code value describes the important part

Foreach ($keys as $key => $value) { //$key is the comparison reference group
similar_text($value, $validValue, $p);
$maxArr[$key] = $p; // put all the odds Go to the array
}
and then take out the largest index value of $maxArr. This is the number we identified.

At this point, the verification code is considered complete.

But when deployed to the user, I found that his machine used fopen to open the remote URL. Only 30% chance is obtained. Other cases are HTTP Request failed…
Many methods have been changed or not. The result is my solution. .
using CURL to save local codes. then fopen to open the local images 100% OK it ..

As for the detailed code, I will not post it. Because the code is sold to others. In order to protect the interests of others, so don’t open your mouth with me. I have already given the idea. I believe you can write it.