密码碰撞可以有多非主流？

void DrawRectangle(/*other params,*/ float x,float y,float width,float height);

void DrawPath(/*other params,*/ Point[] pts)

float[] vertices = {
    -0.5f, -0.5f, 0.0f, // 第一个顶点
     0.5f, -0.5f, 0.0f, // 第二个顶点
     0.0f,  0.5f, 0.0f  // 第三个顶点
};
/* 这里采用的是归一化空间中标(右手坐标系)
 * OpenGL的归一化空间是一个2*2*2的立方体中心是原点坐标。立方体正面和UI界面形成映射关系。
 * 关于归一化空间，这里不做过多介绍。理解为UI窗口左上角是(-1,1,1)右下角是(1,-1,1)就行了。
 */

for(int i = 0;i < vertices.Length;i+=3){
    vertices[i + 1] += 1; // y坐标
}

uint vao = GL.GenVertexArrays();    // 创建VAO，可理解为创建了一个模型对象
GL.BindVertexArray(vao);            // 将此对象绑定到当前操作的上下文

uint vbo = GL.GenBuffers();             // STGL对此函数进行了多个重载
GL.BindBuffer(GL.GL_ARRAY_BUFFER, vbo); // 将对象绑定到Context中 此buffer用于保存顶点数据

GL.BufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW);

GL.BufferData(vbo, GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW);

GL.VertexAttribPointer(         // 指定一个数据处理的规则（针对当前绑定的vbo对象）
    0,                          // 设定一个通道编号 用于在Shader中进行关联
    3,                          // 每一次从vbo中获取3个数据
    GL.GL_FLOAT,                // 数据类型是float
    false,                      // 这个参数目前可以不用管 false就行了
    3 * sizeof(float),          // 下一次获取数据的时候偏移多少数据，也就是每一次取多少字节的数据。
    IntPtr.Zero                 // 第一次获取数据时候偏移多少 很奇怪这个为什么是IntPtr类型？作者也不知道。
    );
GL.EnableVertexAttribArray(0);  // 启用0号通道 下面会做说明

//每一个顶点都会执行一次这个代码 且并行
private static string m_str_vertex_shader = @"
#version 330 core                       // 3.3 版本 使用核心模式

layout (location = 0) in vec3 dotPos;   // 还记得上面的0号通道吗？就是和这里做关联的。
                                        // dotPos就是从0号通道中获取出来的一个3维向量。
void main(){
    gl_Position = vec4(dotPos, 1.0);    // 我们先将3维坐标变成4维。
    // gl_Position是一个内置变量，作为顶点着色器的输出值。也就是预处理后的新顶点。
    // 除了将三维补成四维之外不做任何处理继续传递 这种用n+1维来表示n维的坐标叫做 齐次坐标
}";

//每一个像素点都会执行一次这个代码 且并行
private static string m_str_fragment_shader = @"
#version 330 core

out vec4 fragColor; // 最终需要输出的像素颜色

void main(){
    fragColor = vec4(1.0, 0.5, 0.2, 1.0); //(RGBA)写死 每个像素点的颜色都将是橙色
}";

var gp = GLProgram.Create(str_vertex_shader, str_fragment_shader);
gp.Use();           // 使用当前编译好的着色器 万一有多个可以切换使用

GL.ClearColor(.5f, .5f, .5f, 1f);           // 设置背景颜色
while (/*some code*/) {
    GL.Clear(GL.GL_COLOR_BUFFER_BIT);       // 每次渲染的时候擦除缓存
    // GL.BindVertexArray(vao);             // 绘制前绑定需要绘制的vao
    GL.DrawArrays(GL.GL_TRIANGLES, 0, 3);   // 以三角形方式绘制，一共3个顶点
    // swapbuffer                           // 交换缓冲器 双缓冲
    // other code
}

float[] vertices = {
    -0.5f, -0.5f, 0.0f, // 第一个顶点
     0.5f, -0.5f, 0.0f, // 第二个顶点
    -0.5f,  0.5f, 0.0f, // 第三个顶点

    -0.5f,  0.5f, 0.0f, // 第一个顶点
     0.5f, -0.5f, 0.0f, // 第二个顶点
     0.5f,  0.5f, 0.0f  // 第三个顶点
};
//======================
GL.DrawArrays(
    GL.GL_TRIANGLES,
    0,
    6                       // 一共有6个顶点
    );

void glBufferData(GLenum target, GLsizeiptr size, const void * data, GLenum usage);

GL.VertexAttribPointer(
    0,                  // 依然使用0号通道
    4,                  // 每次获取4个数据
    GL.GL_FLOAT,        // 没错这里继续使用FLOAT类型，作者尝试过GL_UNSIGNED_INT了，得不到正确结果。
                        // 调试发现使用GL_UNSIGNED_INT时候，绑定到uvec4向量的时候采用了FLOAT的内存布局 导致uvec4.xyzw会得到错误值
                        // 也有可能是我虚拟机中的OpenGL版本问题导致的 可能我的OpenGL不支持uint然后使用缺省(FLOAT)的布局方式
                        // 这个值并不是告诉OpenGL我们传入的是什么数据类型，而是希望把我们传入的数据当做什么数据类型使用。
                        // 其实作者也不理解为何顶点着色器中已经指定了通道的数据类型，这里为何还要指定一次。也不太像是历史遗留问题。
    false,
    4 * sizeof(uint),   // 每一份数据的字节宽度，也可以直接写死16 (uint float都是4字节)
    IntPtr.Zero
    );

layout (location = 0) in uvec4 loc_uv4_text; // 4个uint的四维向量
// GLSL的数据类型没有那么自由，使用uvecN是最适合的，而且如果是MD5的话 uint也会方便很多
// uvec4 是一个四维向量分别可以通过 loc_uv4_text.x 获取对应值 一共四个分量(xyzw)每个值是一个uint

GL.VertexAttribPointer(
    0,                  // 依然使用0号通道
    4,
    GL.GL_FLOAT,
    false,
    8 * sizeof(uint),   // 现在每次获取数据是偏移8个uint了
    IntPtr.Zero
    );
GL.VertexAttribPointer(
    1,                  // 1号通道也用起来
    4,
    GL.GL_FLOAT,
    false,
    8 * sizeof(uint),   // 现在每次获取数据是偏移8个uint了
    (IntPtr)(4 * sizeof(uint)) // 第一次获取数据的时候偏移4个uint
    );

layout (location = 0) in uvec4 loc_uv4_text_1;
layout (location = 1) in uvec4 loc_uv4_text_2;

layout (location = 0) in uvec4 loc_uv4_text;

//用于保存最终结果
varying float[16] m_result;
//用于保存MD5密文
uniform uint u_x;
uniform uint u_y;
uniform uint u_z;
uniform uint u_w;

// 着色器代码有点多，我们直接从外部加载
var str_vertex_shader = System.IO.File.ReadAllText("./glsl_md5.vs", Encoding.UTF8);
var str_fragment_shader = System.IO.File.ReadAllText("./glsl_md5.fs", Encoding.UTF8);
var gp = GLProgram.Create(str_vertex_shader, str_fragment_shader);
gp.Use();
// strTargetMd5为目标Md5字符串
uint[] arrs_result = OpenGLMd5.Md5ToUints(strTargetMd5);
gp.SetUniform("u_x", arrs_result[0]);
gp.SetUniform("u_y", arrs_result[1]);
gp.SetUniform("u_z", arrs_result[2]);
gp.SetUniform("u_w", arrs_result[3]);
// 至于怎么将Md5字符串转换成四个uint大家可以各显神通，下面并不是最好的办法，仅仅是方便，反正只执行一次。
public static uint[] Md5ToUints(string strMd5) {
    uint[] ret = new uint[4];
    byte[] by_md5 = new byte[16];
    for (int i = 0; i < 16; i++) {
        by_md5[i] = Convert.ToByte(strMd5.Substring(i << 1, 2), 16);
    }
    unsafe {
        fixed (void* ptr_src = &amp;by_md5[0])
        fixed (void* ptr_dst = &amp;ret[0]) {
            Pointer.Copy(ptr_dst, ptr_src, by_md5.Length < 16 ? by_md5.Length : 16);
        }
    }
    return ret;
}

[原始数据|填充数据|原始数据长度(16字节)].Length % 64 = 0

// GLSL 顶点着色器中的代码片段
// 16个uint刚好就是64字节，所以代码直接写死。
uint[16] MD5_Append(uvec4 uv4){
    // uv4为0号通道获取到的数据
    // 所以uv4是我们的明文数据，我们需要检测明文数据长度，看看那个字节是0
    uint z = uint(0);
    if ((uv4[0] & uint(0x000000FF)) == z) { // 0字节
        return uint[16] ( uint(0x00000080), z, z, z, z, z, z, z, z, z, z, z, z, z, z, z );
    }
    if ((uv4[0] & uint(0x0000FF00)) == z) { // 1字节 后面的uint(8)表原始数据8个bit位
        return uint[16] ( uv4[0] & uint(0x000000FF) | uint(0x00008000), z, z, z, z, z, z, z, z, z, z, z, z, z, uint(8), z );
    }
    // ....
    return uint[16] ( uv4[0], uv4[1], uv4[2], uv4[3], z, z, z, z, z, z, z, z, z, z, uint(128), z ); // 16字节的明文
}

void main(){
    // gl_XXXX开头的都是GLSL内置变量 我不会以三角形方式渲染图像，而是直接绘制顶点
    // 不然使用三角形 鬼知道我们传入的数据会组合成什么样的三角形 而且还会执行栅格化
    gl_PointSize = 1000; //设置顶点大小，其实我们只需要6个像素就够了6 * RGB = 18字节了
    uint arr[16] = MD5_Append(loc_uv4_text);    // 字节补齐
    uint md5[4] = MD5_Trasform(arr);            // 计算md5
    // loc_uv4_text是当前着色器从0号通道获取到的数据，如果计算出来的结果和uniform变量一直
    // 那么我们就将这个明文保存到m_result中并在片段着色器中作为像素值输出
    if(md5[0] == u_x && md5[1] == u_y && md5[2] == u_z && md5[3] == u_w){
        m_result[0] = float((loc_uv4_text.x) & uint(0x000000FF));
        m_result[1] = float((loc_uv4_text.x >> 8) & uint(0x000000FF));
        m_result[2] = float((loc_uv4_text.x >> 16) & uint(0x000000FF));
        m_result[3] = float(loc_uv4_text.x >> 24);

        m_result[4] = float((loc_uv4_text.y) & uint(0x000000FF));
        // ...
        gl_Position = vec4(-1,-1,0,1); // 此坐标在OpenGL归一化空间Z方向投影的左下角
    }else{
        // 此坐标在归一化空间之外会被栅格化裁剪并丢弃 所以不会有像素参数 片段着色器不会触发
        gl_Position = vec4(-2,-2,0,1);
    }
}

#version 330 core
// 片段着色器全部代码
// 此变量与顶点着色器中的同名变量关联 即:结果
varying float[16] m_result;

out vec4 fragColor; //当前像素需要输出的颜色

void main(){
    // 我们在顶点着色器中输出的坐标为(-1,-1,0,1)。即在二维平面的左下角
    // gl_FragCoord 当前着色器输出的颜色位于显示视窗中的那个像素
    // 最终屏幕中的像素是以RGB呈现 所以我们需要6个像素来写入结果
    // 6 * 3 = 18 m_result有16个值
    int x = int(gl_FragCoord.x) * 3;

    if(x < 15){     // 15 = 5 * 3, 也就是前面5个像素
        fragColor = vec4(
            m_result[x] / float(255),       // R
            m_result[x + 1] / float(255),   // G
            m_result[x + 2] / float(255),   // B
            1.0);                           // A
    }else if(x == 15){
        fragColor = vec4(m_result[15] / float(255),0,0,1);
    }else{
        fragColor = vec4(0,0,1,1);          // 其他区域随便给个颜色比如蓝色
    }
}

// nCountForFrame表示没渲染一帧画面 准备送入多少个密码明文到显存
uint[] u_arrs_text_buffer = new uint[nCountForFrame * 4]; //最终要送入显存的数据

int nBufferLen = sizeof(uint) * u_arrs_text_buffer.Length;

uint vbo = GL.GenBuffers();         // 创建一个buffer对象并得到id STGL对此函数进行了多个重载
GL.BindBuffer(GL.GL_ARRAY_BUFFER, vbo); // 将对象绑定到Context中 此buffer用于保存顶点数据
GL.BufferData(GL.GL_ARRAY_BUFFER, nBufferLen, IntPtr.Zero, GL.GL_STREAM_DRAW_ARB);
//GL_STREAM_DRAW_ARB 表示数据是一直在变化的 每一帧数据都会变化
//当时上面的代码并没有拷贝数据，我们将打算使用GL.BufferSubData进行数据拷贝。

using (StreamReader reader = new StreamReader(strDic, Encoding.UTF8)) {
    int nCounter = 0;
    string strLine = string.Empty;
    while ((strLine = reader.ReadLine()) != null) { // 每读取一行写入到vbo需要的buffer中
        OpenGLMd5.TextToBuffer(u_arrs_text_buffer, nCounter << 2, strLine);
        if (++nCounter != nCountForFrame) {         // 到达设定的条数
            continue;
        }   // 然后将数据拷贝至显存
        GL.BufferSubData(GL.GL_ARRAY_BUFFER, IntPtr.Zero, u_arrs_text_buffer);
        GL.DrawArrays(GL.GL_POINTS, 0, nCounter);   // 这里我们直接渲染顶点而不是三角形
        nCounter = 0;                               // 计数清0
        strResult = OpenGLMd5.GetResult(b_arrs_result_buffer); // 每渲染一帧 获取一下像素
        if (strResult != null) return strResult;
    }
    if (nCounter != 0) { // 将剩下的数据送入显存
        GL.BufferSubData(GL.GL_ARRAY_BUFFER, IntPtr.Zero, nCounter * 4 * sizeof(uint), u_arrs_text_buffer);
        GL.DrawArrays(GL.GL_POINTS, 0, nCounter);
        strResult = OpenGLMd5.GetResult(b_arrs_result_buffer);
        if (strResult != null) return strResult;
    }
}
// 同理如何把 strText 写入 buffers 中大家可以各显神通，同样的这不是最好的方法，仅仅是方便。
public static void TextToBuffer(uint[] buffers, int nIndex, string strText) {
    buffers[nIndex] = 0;        // 每个明文数据我们给定16字节 先将数据全部清0
    buffers[nIndex + 1] = 0;    // 在顶点着色器中将通过判断0来确认数据长度
    buffers[nIndex + 2] = 0;
    buffers[nIndex + 3] = 0;
    byte[] byText = Encoding.UTF8.GetBytes(strText);
    unsafe {
        fixed (void* ptr_src = &amp;byText[0])
        fixed (void* ptr_dst = &amp;buffers[nIndex]) {
            Pointer.Copy(ptr_dst, ptr_src, byText.Length < 16 ? byText.Length : 16);
        }
    }
}
// 每渲染一帧读取一下像素。glReadPixels的原点坐标在左下角，读取6个像素就好了
private static string GetResult(byte[] byBuffer) {
    unsafe {
        fixed (byte* ptr = &amp;byBuffer[0]) {
            GL.ReadPixels(0, 0, 6, 1, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, (IntPtr)ptr);
        }
    }
    if (byBuffer[0] != 0) { // 如果左下角有像素被设定，那说明触发片段着色器了。有结果了。
        return Encoding.UTF8.GetString(byBuffer).Trim('\0');
    }
    return null;
}

using (StreamWriter writer = new StreamWriter("./md5_test.txt", false, Encoding.UTF8)) {
    for (int i = 0; i < 10000000; i++) {
        writer.WriteLine(i);
    }
}
// 最后一个是 9999999 MD5: 283f42764da6dba2522412916b031080
// other code
// ...
sw.Start();
var aa = CPUMd5.Run("./md5_test.txt", "283f42764da6dba2522412916b031080");
sw.Stop();
Console.WriteLine("CPU_TIME: " + sw.ElapsedMilliseconds);
Console.WriteLine("CPU_RESULT: " + aa);
Console.WriteLine("=====================================");
sw.Reset();
sw.Start();
// 每次送入400W个明文到显存
var bb = OpenGLMd5.Run("./md5_test.txt", "283f42764da6dba2522412916b031080", 4000000);
sw.Stop();
Console.WriteLine("GL_TIME: " + sw.ElapsedMilliseconds);
Console.WriteLine("GL_RESULT: " + bb);

hashcat -a 0 -m 0 283f42764da6dba2522412916b031080 ./md5_test.txt -O

You can use it in your cracking session by setting the -O option.
Note: Using optimized kernel code limits the maximum supported password length.

hashcat -b -m 0

long nFrameCounter = 0, nPwdCount = by_buffer.Length / 16;
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
long l_time = sw.ElapsedMilliseconds;
while (true) {
    nFrameCounter++;
    // 虽然是重复数据 每一帧还是重新拷贝一次到显存吧
    GL.BufferSubData(GL.GL_ARRAY_BUFFER, IntPtr.Zero, by_buffer);
    GL.DrawArrays(GL.GL_POINTS, 0, (int)nPwdCount);
    strResult = OpenGLMd5_1.GetResult(b_arrs_result_buffer);
    if (strResult != null) return strResult; // 当然不会有正确结果出来
    long l_temp = sw.ElapsedMilliseconds;
    if (l_temp - l_time >= 1000) {
        l_time = l_temp;
        Console.WriteLine("AVG_SPEED: " + (long)((nFrameCounter * nPwdCount) / (sw.ElapsedMilliseconds / 1000f)));
    }
}

public static void CreateDic(string strDicFile, string strOutFile) {
    byte[] by_temp = new byte[16];
    using (FileStream fs_out = new FileStream(strOutFile, FileMode.Create, FileAccess.Write)) {
        using (StreamReader reader = new StreamReader(strDicFile, Encoding.UTF8)) {
            string strLine = string.Empty;
            while ((strLine = reader.ReadLine()) != null) {
                if (strLine == string.Empty) continue;
                var bytes = Encoding.UTF8.GetBytes(strLine);
                for (int i = 0; i < bytes.Length && i < 16; i++) {
                    by_temp[i] = bytes[i];
                }
                for (int i = 0, nLen = 16 - bytes.Length; i < nLen; i++) {
                    by_temp[i + bytes.Length] = 0;
                }
                fs_out.Write(by_temp, 0, by_temp.Length);
            }
        }
    }
}
// CreateDic("md5_test.txt","dic_new");

GL.BufferData(GL.GL_ARRAY_BUFFER, File.ReadAllBytes("dic_new"), GL.GL_STATIC_DRAW);

using (FileStream fs = new FileStream(strDic, FileMode.Open, FileAccess.Read)) {
    int nLen = 0;
    while ((nLen = fs.Read(by_buffer, 0, by_buffer.Length)) != 0) {
        GL.BufferSubData(GL.GL_ARRAY_BUFFER, IntPtr.Zero, by_buffer);
        GL.DrawArrays(GL.GL_POINTS, 0, nLen / 16);
        strResult = OpenGLMd5_1.GetResult(b_arrs_result_buffer);
        if (strResult != null) return strResult;
    }
}