精华内容
下载资源
问答
  • cmd下md5值计算命令
    2021-05-16 15:55:19

    1. win10系统怎么用cmd计算文件md5

    1、点击任务栏左下角的搜索,输入cmd。

    2、搜索结果中第一条是【命令提示符】(桌面应用),右键以管理员权限打开。

    3、粘贴下面的命令,然后回车即可。

    复制内容到剪贴板

    cmd /k reg add "HKEY_CLASSES_ROOT\Directory\Background\shellex\ContextMenuHandlers\New" /ve /t REG_SZ /d {D969A300-E7FF-11d0-A93B-00A0C90F2719} /f

    注意事项:CMD要用管理员权限打开。不能直接WIN+R运行。

    2. 如何计算一个文件的md5值

    文件校验和完整性验证程序 (FCIV) 实用程序可以用于计算 MD5 或 sha-1 加密哈希值的文件。

    有关文件校验和完整性验证程序 (FCIV) 实用程序的其他信息,请单击下面的文章编号,以查看 Microsoft 知识库中相应的文章: 841290可用性和文件校验和完整性验证程序实用程序的说明 若要计算在 MD5 和文件的 sha-1 哈希值,请在命令行键入以下命令: FCIV-md5-sha1 path\filename.ext 例如对于计算 Shdocvw.dll 文件 %Systemroot% \System32 文件夹中的 MD5 和 sha-1 哈希值,键入以下命令: FCIV-md5-sha1 c:\windows\system32\shdocvw.dll。

    3. 求代码

    char buff[1024];

    typedef int (WINAPI ICEPUB_GETMD5FROMFILE)(char *strFilePath,char *strResult);

    ICEPUB_GETMD5FROMFILE*icePub_getMD5FromFile = 0;

    HINSTANCE hDLLDrv = LoadLibrary("icePubDll.dll");

    if(hDLLDrv)

    {

    icePub_getMD5FromFile=(ICEPUB_GETMD5FROMFILE *)GetProcAddress(hDLLDrv,"icePub_getMD5FromFile");

    }

    if(icePub_getMD5FromFile)

    icePub_getMD5FromFile("D:\\icePubDLL.dll",buff);

    if(hDLLDrv)

    FreeLibrary(hDLLDrv);

    AfxMessageBox(buff);

    4. 怎么在CMD的计算器命令是什么

    SET /A expression

    /A 命令行开关指定等号右边的字符串为被评估的数字表达式。该表达式

    评估器很简单并以递减的优先权顺序支持下列操作:

    () - 分组

    ! ~ - - 一元运算符

    * / % - 算数运算符

    + - - 算数运算符

    > - 逻辑移位

    - 按位“与”

    ^ - 按位“异”

    | - 按位“或”

    = *= /= %= += -= - 赋值

    &= ^= |= >=

    - 表达式分隔符

    如果您使用任何逻辑或取余操作符, 您需要将表达式字符串用

    引号扩起来。在表达式中的任何非数字字符串键作为环境变量

    名称,这些环境变量名称的值已在使用前转换成数字。如果指定

    了一个环境变量名称,但未在当前环境中定义,那么值将被定为

    零。这使您可以使用环境变量值做计算而不用键入那些 % 符号

    来得到它们的值。如果 SET /A 在命令脚本外的命令行执行的,

    那么它显示该表达式的最后值。该分配的操作符在分配的操作符

    左边需要一个环境变量名称。除十六进制有 0x 前缀,八进制

    有 0 前缀的,数字值为十进位数字。因此,0x12 与 18 和 022

    相同。请注意八进制公式可能很容易搞混: 08 和 09 是无效的数字,

    因为 8 和 9 不是有效的八进制位数。(& )

    5. 如何计算一个文件的md5值

    文件校验和完整性验证程序 (FCIV) 实用程序可以用于计算 MD5 或 sha-1 加密哈希值的文件。 有关文件校验和完整性验证程序 (FCIV) 实用程序的其他信息,请单击下面的文章编号,以查看 Microsoft 知识库中相应的文章:

    841290可用性和文件校验和完整性验证程序实用程序的说明

    若要计算在 MD5 和文件的 sha-1 哈希值,请在命令行键入以下命令:

    FCIV-md5-sha1 path\filename.ext

    例如对于计算 Shdocvw.dll 文件 %Systemroot% \System32 文件夹中的 MD5 和 sha-1 哈希值,键入以下命令:

    FCIV-md5-sha1 c:\windows\system32\shdocvw.dll

    6. 如何查看获取MD5和SHA1值

    首先:1.我们进入到通过cmd打开控制台,进入cmd定位到.Android文件夹下。

    2.输入keytool -list -v -keystore debug.keystore得到三种指纹证书,选取SHA1类型的证书,密匙口令是android,就可以获取到MD5和SHA1(注意如果不输入-v的话就只会出现SHA1的值)

    这里我们就拿到了调试用的MD5和SHA1值,如果对命令使用不会的情况可以使用keytool查看使用帮助的指令。

    7. linux命令下md5怎么使用方法

    MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。

    MD5全称是报文摘要算法(Message-Digest Algorithm5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位)的指纹(或称报文摘要),不同的文件产生相同的报文摘要的可能性是非常非常之小的。在linux或Unix上,md5sum是用来计算和校验文件报文摘要的工具程序。

    一般来说,安装了linux后,就会有md5sum这个工具,直接在命令行终端直接运行。1、使用md5sum来产生指纹(报文摘要)命令如下:md5sum file > file.md5或者md5sum file >>file.md5也可以把多个文件的报文摘要输出到一个md5文件中,这要使用通配符*,比如某目录下有几个iso文件,要把这几个iso文件的摘要输出到iso.md5文件中,命令如下:md5sum *.iso > iso.md52、使用md5报文摘要验证文件,方法有二:把下载的文件file和该文件的file.md5报文摘要文件放在同一个目录下,然后用如下命令进行验证:md5sum -c file.md5然后如果验证成功,则会输出:正确md5sum passwd passwd.bak /etc/passwd。

    8. CMD的计算器命令是什么

    set /A 算式

    例set /A 3*9

    具体用法

    () - 分组

    ! ~ - - 一元运算符

    * / % - 算数运算符

    + - - 算数运算符

    > - 逻辑移位

    & - 按位“与”

    ^ - 按位“异”

    | - 按位“或”

    = *= /= %= += -= - 赋值

    &= ^= |= >=

    - 表达式分隔符

    更多相关内容
  • 多线程hash计算工具。安全可靠,电子数据提取固定必备。支持多线程MD5、SHA256、SHA512等多种hash计算支持批量计算
  • MD5 File Hasher是一款非常实用的MD5值生成工具,不仅如此它还可以用来校验MD5码。... 剪贴板 已经计算MD5散列需要手工进行复制。散列可以毫不费力地被复制到剪贴板,然后可以插入,如到电子邮件的正
  • 本程序主要用于计算文件的MD5 SHA1 CRC32三项校验 也叫摘要或指纹 支持超大文件 相较其他软件强大之处在于:1. 可以计算文件分片 即只计算文件的前部分字节(百度网盘的slicemd5为前256KB) 2. 计算结果有文本形式和...
  • 计算文件 MD5

    千次阅读 2019-09-16 15:19:22
    本篇文章的重点:拿到 File 对象之后,如何计算文件的 md5 ?几千个文件同时计算,页面卡顿崩溃怎么解决?

    1 效果展示

    在这里插入图片描述

    本篇文章的重点:拿到 File 对象之后,如何计算文件的 md5 值?几千个文件同时计算,页面卡顿崩溃怎么解决?

    不知道如何获取 File 对象可以看这篇文章:上传三合一:拖拽上传、上传文件、上传文件夹,一次搞定!,这里不再复述了。

    2 分析

    懒了,不一步步说明了,直接放结论。

    2.1 计算 MD5

    直接用轮子 js-spark-md5

    2.2 解决页面卡顿问题

    同时计算很多文件,页面卡顿崩溃,怎么办?

    主要有两方面的压力:计算压力和渲染压力。

    2.2.1 计算压力:

    缓解计算压力,有下面三种策略:

    策略
    分块缓解大文件造成的计算压力
    文件很大时,一次性读取整个文件非常非常耗时,而且读取时页面会卡死。
    所以必须要分块读取文件,并计算md5。( js-spark-md5 支持分块)
    排队缓解文件多造成的计算压力
    同一时刻,只允许运行最多 n 个计算任务,后来的在等待队列中排队。
    多线程使用 Web Worker 多线程计算md5。(安装 worker-loader 包以在 webpack 中使用 Web Worker)
    注意worker用完必须杀掉。不然数量多了之后,即使没在执行计算任务,浏览器也会崩

    分块和排队都必须用。多线程可用可不用。

    2.2.2 渲染压力:

    如果像开头的效果图一样,把所有文件都展示在页面上。那么文件一多,渲染压力就会很大。

    在真实的业务中,渲染压力会更大。举例说一个场景:

    • 选择要上传的文件后,先计算MD5,之后分块上传文件。
    • 上传列表中要展示所有文件的状态,是正在校验可用空间,还是正在排队算MD5等等。(这会导致,每个文件的每次状态改变,浏览器都要重新渲染)
    • 因为是分块上传,所以有上传进度,进度百分比也要在上传列表中展示。(这会导致,每个任务的上传进度每次改变,浏览器都要重新渲染)

    这个场景下,浏览器在上传过程中每时每刻都在不停地重新渲染,卡卡卡。

    计算压力可以通过分块、排队、多线程来缓解,但渲染压力就没办法了。无论如何,几百几千个div一下子添加进来,并且一直在变化,浏览器肯定会卡的。

    解决方法只有一个,就是不要显示太多文件。可以限制单次上传数量,或者上传列表添加分页功能,等等。

    3 代码

    ComputingMd5Factory.js:负责排队,给每个任务安排一个 Web Worker

    
    import ComputingMd5Worker from 'worker-loader!./ComputingMd5Worker.js';
    
    class ComputingMd5Factory{
        constructor() {
            // 等待队列
            this.waitingList = [];
            // 正在工作的数量
            this.workingCount = 0;
            // 最大同时工作的数量
            this.maxWorkingCount = 1;
        }
        addTask(file) {
            if (this.workingCount < this.maxWorkingCount) {
                this.workingCount++;
                this.computeMd5(file);
            } else {
                this.waitingList.push(file);
            }
        }
        // 用 worker 计算 md5
        computeMd5(file) {
            const worker = new ComputingMd5Worker();
            worker.postMessage({ file });
            worker.addEventListener("message", e => {
                if (e.data.isSuccessful) {
                    file.md5 = e.data.md5;
                    if (this.waitingList.length > 0) {
                        // 不释放 workingCount ,直接把等待队列第一个拿进来.
                        // 这样做是为了防止:释放 workingCount 后的瞬间有新任务 addTask ,插队了
                        let newTask = this.waitingList.shift();
                        this.computeMd5(newTask);
                    } else {
                        this.workingCount--;
                    }
                    // 立刻终止worker
                    worker.terminate();
                } else if (e.data.isFailed) {
                    // 立刻终止worker
                    worker.terminate();
                }
            });
        }
    }
    export default ComputingMd5Factory;
    

    ComputingMd5Worker.js:worker文件,分块读取文件计算 md5。

    
    import SparkMD5 from 'spark-md5'
    
    const blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;
    
    // Read in chunks of 2MB
    const chunkSize = 1024 * 1024 * 1024;
    
    self.addEventListener("message", e => {
        computeMd5(e.data.file).then(md5 => {
            self.postMessage({
                isSuccessful: true,
                md5: md5
            });
        }).catch(message => {
            self.postMessage({
                isFailed: true,
                message
            });
        })
    });
    
    function computeMd5(file) {
        return new Promise((resolve, reject) => {
            var chunksCount = Math.ceil(file.size / chunkSize);
            var currentChunk = 0;
            var spark = new SparkMD5.ArrayBuffer();
            var fileReader = new FileReader();
            fileReader.onload = e => {
                spark.append(e.target.result);
                currentChunk++;
                if (currentChunk < chunksCount) {
                    loadNext();
                } else {
                    const md5 = spark.end();
                    // 成功了
                    resolve(md5);
                }
            };
            fileReader.onerror = e => {
                // 出错了
                reject("Something went wrong when reading the file");
            };
            function loadNext() {
                var start = currentChunk * chunkSize;
                var end = Math.min(start + chunkSize, file.size);
    
                fileReader.readAsArrayBuffer(blobSlice.call(file, start, end));
            }
            loadNext();
        });
    }
    
    展开全文
  • Hash是一款小巧好用的哈希计算器,可以用于文件的MD5校验,它支持多个文件或文件夹拖放操作,计算速度很快,也支持保存个人设置等,非常的方便好用。 1、只支持常用的MD5、SHA1、CRC32算法;  2、支持多个文件或...
  • C# 获取MD5 (MD5计算MD5小工具)

    千次阅读 2016-11-12 14:46:53
    拖拽文件或文件夹至getMD5.exe上,可自动计算文件或文件夹下所有文件的MD5值,保存至文件MD5.txt中 方式三: 通过cmd命令调用(类似方式二) REM 获取1.txt和files目录下所有文件的MD5值 getMD5.exe &...

    方式一:

    双击运行,输入字符串计算MD5值;或拖动任意文件或文件夹到到工具上,自动计算MD5值。

     

    方式二:

    拖拽文件或文件夹至getMD5.exe上,可自动计算文件或文件夹下所有文件的MD5值,保存至文件MD5.txt中

     

    方式三:

    通过cmd命令调用(类似方式二)

     

    REM 获取1.txt和files目录下所有文件的MD5值
    getMD5.exe "D:\tmp\1.txt;C:\Users\Administrator\Desktop\files"

     

     

     

    MD5计算工具下载

     

    工具源码

     
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace getMD5
    {
        //示例: 
        // MD5.Encrypt("a");                        // 计算字符串MD5值
        // MD5.Encrypt(new FileInfo("D:\\1.rar"));  // 计算文件MD5值
        // MD5.Encrypt(byte[] Bytes);               // 计算Byte数组MD5值
    
        //MD5 ("") = d41d8cd98f00b204e9800998ecf8427e   
        //MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661   
        //MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72   
        //MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0   
        //MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b  
        class MD5
        {
    
            #region MD5调用接口
    
            /// <summary>
            /// 计算data的MD5值
            /// </summary>
            public static string Encrypt(string data)
            {
                uint[] X = To16Array(data);
                return calculate(X);
            }
    
            /// <summary>
            /// 计算byte数组的MD5值
            /// </summary>
            public static string Encrypt(byte[] Bytes)
            {
                uint[] X = To16Array(Bytes);
                return calculate(X);
            }
    
            /// <summary>
            /// 计算文件的MD5值
            /// </summary>
            public static string Encrypt(FileInfo file)
            {
                uint[] X = To16Array(file);
                return calculate(X);
            }
    
            #endregion
    
    
            #region MD5计算逻辑
    
            /// <summary>
            /// 转化byte数组为uint数组,数组长度为16的倍数
            /// 
            /// 1、字符串转化为字节数组,每4个字节转化为一个uint,依次存储到uint数组
            /// 2、附加0x80作为最后一个字节
            /// 3、在uint数组最后位置记录文件字节长度信息
            /// </summary>
            public static uint[] To16Array(byte[] Bytes)
            {
                uint DataLen = (uint)Bytes.Length;
    
                // 计算FileLen对应的uint长度(要求为16的倍数、预留2个uint、最小为16)
                uint ArrayLen = (((DataLen + 8) / 64) + 1) * 16;     
                uint[] Array = new uint[ArrayLen];
    
                uint ArrayPos = 0;
                int pos = 0;
                uint ByteCount = 0;
                for (ByteCount = 0; ByteCount < DataLen; ByteCount++)
                {
                    // 每4个Byte转化为1个uint
                    ArrayPos = ByteCount / 4;
                    pos = (int)(ByteCount % 4) * 8;
                    Array[ArrayPos] = Array[ArrayPos] | ((uint)Bytes[ByteCount] << pos);
                }
    
                // 附加0x80作为最后一个字节,添加到uint数组对应位置
                ArrayPos = ByteCount / 4;
                pos = (int)(ByteCount % 4) * 8;
                Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);
    
                // 记录总长度信息
                Array[ArrayLen - 2] = (DataLen << 3);
                Array[ArrayLen - 1] = (DataLen >> 29);
    
                return Array;
            }
    
            /// <summary>
            /// 转化字符串为uint数组,数组长度为16的倍数
            /// 
            /// 1、字符串转化为字节数组,每4个字节转化为一个uint,依次存储到uint数组
            /// 2、附加0x80作为最后一个字节
            /// 3、在uint数组最后位置记录文件字节长度信息
            /// </summary>
            public static uint[] To16Array(string data)
            {
                byte[] datas = System.Text.Encoding.Default.GetBytes(data);
                return To16Array(datas);
            }
    
            /// <summary>
            /// 转化文件为uint数组,数组长度为16的倍数
            /// 
            /// 1、读取文件字节信息,每4个字节转化为一个uint,依次存储到uint数组
            /// 2、附加0x80作为最后一个字节
            /// 3、在uint数组最后位置记录文件字节长度信息
            /// </summary>
            public static uint[] To16Array(FileInfo info)
            {
                FileStream fs = new FileStream(info.FullName, FileMode.Open);// 读取方式打开,得到流
                int SIZE = 1024 * 1024 * 10;        // 10M缓存
                byte[] datas = new byte[SIZE];      // 要读取的内容会放到这个数组里
                int countI = 0;
                long offset = 0;
    
                // 计算FileLen对应的uint长度(要求为16的倍数、预留2个uint、最小为16)
                uint FileLen = (uint)info.Length;
                uint ArrayLen = (((FileLen + 8) / 64) + 1) * 16;     
                uint[] Array = new uint[ArrayLen];
    
                int pos = 0;
                uint ByteCount = 0;
                uint ArrayPos = 0;
                while (ByteCount < FileLen)
                {
                    if (countI == 0)
                    {
                        fs.Seek(offset, SeekOrigin.Begin);// 定位到指定字节
                        fs.Read(datas, 0, datas.Length);
    
                        offset += SIZE;
                    }
    
                    // 每4个Byte转化为1个uint
                    ArrayPos = ByteCount / 4;
                    pos = (int)(ByteCount % 4) * 8;
                    Array[ArrayPos] = Array[ArrayPos] | ((uint)datas[countI] << pos);
    
                    ByteCount = ByteCount + 1;
    
                    countI++;
                    if (countI == SIZE) countI = 0;
                }
    
                // 附加0x80作为最后一个字节,添加到uint数组对应位置
                ArrayPos = ByteCount / 4;
                pos = (int)(ByteCount % 4) * 8;
                Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);
    
                // 记录总长度信息
                Array[ArrayLen - 2] = (FileLen<< 3);
                Array[ArrayLen - 1] = (FileLen>>29);
    
                fs.Close();
                return Array;
            }
    
    
    
            private static uint F(uint x, uint y, uint z)
            {
                return (x & y) | ((~x) & z);
            }
            private static uint G(uint x, uint y, uint z)
            {
                return (x & z) | (y & (~z));
            }
    
            // 0^0^0 = 0
            // 0^0^1 = 1
            // 0^1^0 = 1
            // 0^1^1 = 0
            // 1^0^0 = 1
            // 1^0^1 = 0
            // 1^1^0 = 0
            // 1^1^1 = 1
            private static uint H(uint x, uint y, uint z)
            {
                return (x ^ y ^ z);
            }
            private static uint I(uint x, uint y, uint z)
            {
                return (y ^ (x | (~z)));
            }
    
            // 循环左移
            private static uint RL(uint x, int y)
            {
                y = y % 32;
                return (x << y) | (x >> (32 - y));
            }
    
            private static void md5_FF(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
            {
                uint f = F(b, c, d);
                a = x + ac + a + f;
    
                a = RL(a, s);
                a = a + b;
            }
            private static void md5_GG(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
            {
                uint g = G(b, c, d);
                a = x + ac + a + g;
    
                a = RL(a, s);
                a = a + b;
            }
            private static void md5_HH(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
            {
                uint h = H(b, c, d);
                a = x + ac + a + h;
    
                a = RL(a, s);
                a = a + b;
            }
            private static void md5_II(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
            {
                uint i = I(b, c, d);
                a = x + ac + a + i;
    
                a = RL(a, s);
                a = a + b;
            }
    
            private static string RHex(uint n)
            {
                string S = Convert.ToString(n, 16);
                return ReOrder(S);
            }
    
            // 16进制串重排序 67452301 -> 01234567
            private static string ReOrder(String S)
            {
                string T = "";
                for (int i = S.Length - 2; i >= -1; i = i - 2)
                {
                    if (i == -1) T = T + "0" + S[i + 1];
                    else T = T + "" + S[i] + S[i + 1];
                }
                return T;
            }
    
    
            /// <summary>
            /// 对长度为16倍数的uint数组,执行md5数据摘要,输出md5信息
            /// </summary>
            public static string calculate(uint[] x)
            {
                //uint time1 = DateTime.Now.Ticks;
    
                // 7   12  17   22
                // 5   9   14   20
                // 4   11  16   23
                // 6   10  15   21
                const int S11 = 7;
                const int S12 = 12;
                const int S13 = 17;
                const int S14 = 22;
                const int S21 = 5;
                const int S22 = 9;
                const int S23 = 14;
                const int S24 = 20;
                const int S31 = 4;
                const int S32 = 11;
                const int S33 = 16;
                const int S34 = 23;
                const int S41 = 6;
                const int S42 = 10;
                const int S43 = 15;
                const int S44 = 21;
    
                uint a = 0x67452301;
                uint b = 0xEFCDAB89;
                uint c = 0x98BADCFE;
                uint d = 0x10325476;
    
                for (int k = 0; k < x.Length; k += 16)
                {
                    uint AA = a;
                    uint BB = b;
                    uint CC = c;
                    uint DD = d;
    
                    md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);  // 3604027302
                    md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);  // 877880356
                    md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);  // 2562383102
                    md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
                    md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
                    md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
                    md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
                    md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
                    md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
                    md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
                    md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
                    md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
                    md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
                    md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
                    md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
                    md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821); //3526238649
                    md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
                    md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);  //1572812400
                    md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
                    md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
                    md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
                    md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
                    md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
                    md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
                    md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
                    md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
                    md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
                    md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
                    md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
                    md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
                    md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
                    md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
                    md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);  // 3750198684 2314002400 1089690627 990001115 0 4 -> 2749600077
                    md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);  // 990001115
                    md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122); // 1089690627
                    md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C); // 2314002400
                    md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);  // 555633090
                    md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
                    md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
                    md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
                    md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
                    md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
                    md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
                    md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
                    md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
                    md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
                    md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
                    md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);  // 1444303940
                    md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);  // 808311156
                    md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);
                    md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
                    md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);
                    md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
                    md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
                    md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
                    md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);
                    md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
                    md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
                    md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
                    md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);
                    md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
                    md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
                    md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
                    md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);  // 4120542881
    
                    a = a + AA; //3844921825
                    b = b + BB;
                    c = c + CC;
                    d = d + DD;
                }
    
                string MD5 = RHex(a) + RHex(b) + RHex(c) + RHex(d);
    
                //uint time2 = DateTime.Now.Ticks;
                //MessageBox.Show("MD5计算耗时:" + ((time2 - time1) / 10000000f) + "秒");
    
                return MD5;
            }
    
            #endregion
    
        }
    }
    

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace getMD5
    {
        static class Program
        {
            /// <summary>
            /// 应用程序的主入口点。
            /// </summary>
            [STAThread]
            static void Main(string[] args)
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
    
                if (args.Length == 0) Application.Run(new Form_MD5());
                else if (args.Length == 1)
                {
                    string[] files = args[0].Split(';');
                    string filesNames = Form_MD5.toSubDirFileNames(files);
                    files = filesNames.Split(';');
    
                    string tmp = Form_MD5.getFilesMD5(files);   // 计算文件MD5值
                    Form_MD5.SaveProcess(tmp);
                }
            }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace getMD5
    {
        public partial class Form_MD5 : Form
        {
            public Form_MD5()
            {
                InitializeComponent();
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                textBox1.Text = MD5.Encrypt(textBox1.Text, 32);
            }
    
            private void Form_DragEnter(object sender, DragEventArgs e)
            {
                dragEnter(e);
            }
    
            private void Form_DragDrop(object sender, DragEventArgs e)
            {
                TextBox textBox = sender as TextBox;
                textBox.Text = dragDrop(e);                 // 获取拖入的文件
                string[] files = textBox.Text.Split(';');
    
                string tmp = getFilesMD5(files);            // 计算文件MD5值
                textBox1.Text = tmp;
                SaveProcess(tmp, "MD5.txt");
            }
    
    
            // 计算各文件对应的MD5值
            public static String getFilesMD5(string[] files)
            {
                string tmp = "";
    
                foreach (string file in files)
                {
                    if (System.IO.File.Exists(file))
                    {
                        string data = fileToString(file);
                        string md5 = MD5.Encrypt(data, 32);
                        tmp += "\r\n" + file + "(" + md5 + ")";
                    }
                }
    
                return tmp;
            }
    
            #region 文件读取与保存
    
            /// <summary>  
            /// 获取文件中的数据串  
            /// </summary>  
            public static string fileToString(String filePath)
            {
                string str = "";
    
                //获取文件内容  
                if (System.IO.File.Exists(filePath))
                {
                    System.IO.StreamReader file1 = new System.IO.StreamReader(filePath, Encoding.Default);//读取文件中的数据  
                    str = file1.ReadToEnd();                                            //读取文件中的全部数据  
    
                    file1.Close();
                    file1.Dispose();
                }
                return str;
            }
    
            /// <summary>
            /// 保存数据data到文件处理过程,返回值为保存的文件名
            /// </summary>  
            public static String SaveProcess(String data, String name = "", String CurDir = "")
            {
                if (CurDir.Equals("")) CurDir = System.AppDomain.CurrentDomain.BaseDirectory;           //设置当前目录  
                if (name.Equals("")) name = "MD5.txt";
                if (!System.IO.Directory.Exists(CurDir)) System.IO.Directory.CreateDirectory(CurDir);   //该路径不存在时,在当前文件目录下创建文件夹"导出.."  
    
                //不存在该文件时先创建  
                String filePath = CurDir + name;
                System.IO.StreamWriter file1 = new System.IO.StreamWriter(filePath, false);     //文件已覆盖方式添加内容  
    
                file1.Write(data);                                                              //保存数据到文件  
    
                file1.Close();                                                                  //关闭文件  
                file1.Dispose();                                                                //释放对象  
    
                return filePath;
            }
    
            #endregion
    
    
            # region 文件拖拽
    
            /// <summary>  
            /// 文件拖进事件处理:  
            /// </summary>  
            public void dragEnter(DragEventArgs e)
            {
                if (e.Data.GetDataPresent(DataFormats.FileDrop))    //判断拖来的是否是文件  
                    e.Effect = DragDropEffects.Link;                //是则将拖动源中的数据连接到控件  
                else e.Effect = DragDropEffects.None;
            }
    
            /// <summary>  
            /// 文件放下事件处理:  
            /// 放下, 另外需设置对应控件的 AllowDrop = true;   
            /// 获取的文件名形如 "d:\1.txt;d:\2.txt"  
            /// </summary>  
            public string dragDrop(DragEventArgs e)
            {
                Array file = (System.Array)e.Data.GetData(DataFormats.FileDrop);//将拖来的数据转化为数组存储
                return toSubDirFileNames(file);
            }
    
            // 获取所有files目录下的所有文件,转化为单个串
            public static string toSubDirFileNames(Array files)
            {
                StringBuilder filesName = new StringBuilder("");
    
                foreach (object I in files)
                {
                    string str = I.ToString();
    
                    System.IO.FileInfo info = new System.IO.FileInfo(str);
                    //若为目录,则获取目录下所有子文件名  
                    if ((info.Attributes & System.IO.FileAttributes.Directory) != 0)
                    {
                        str = getAllFiles(str);
                        if (!str.Equals("")) filesName.Append((filesName.Length == 0 ? "" : ";") + str);
                    }
                    //若为文件,则获取文件名  
                    else if (System.IO.File.Exists(str))
                        filesName.Append((filesName.Length == 0 ? "" : ";") + str);
                }
    
                return filesName.ToString();
            }
    
            /// <summary>  
            /// 判断path是否为目录  
            /// </summary>  
            public bool IsDirectory(String path)
            {
                System.IO.FileInfo info = new System.IO.FileInfo(path);
                return (info.Attributes & System.IO.FileAttributes.Directory) != 0;
            }
    
            /// <summary>  
            /// 获取目录path下所有子文件名  
            /// </summary>  
            public static string getAllFiles(String path)
            {
                StringBuilder str = new StringBuilder("");
                if (System.IO.Directory.Exists(path))
                {
                    //所有子文件名  
                    string[] files = System.IO.Directory.GetFiles(path);
                    foreach (string file in files)
                        str.Append((str.Length == 0 ? "" : ";") + file);
    
                    //所有子目录名  
                    string[] Dirs = System.IO.Directory.GetDirectories(path);
                    foreach (string dir in Dirs)
                    {
                        string tmp = getAllFiles(dir);  //子目录下所有子文件名  
                        if (!tmp.Equals("")) str.Append((str.Length == 0 ? "" : ";") + tmp);
                    }
                }
                return str.ToString();
            }
    
            # endregion
    
        }
    }
    
    namespace getMD5
    {
        partial class Form_MD5
        {
            /// <summary>
            /// 必需的设计器变量。
            /// </summary>
            private System.ComponentModel.IContainer components = null;
    
            /// <summary>
            /// 清理所有正在使用的资源。
            /// </summary>
            /// <param name="disposing">如果应释放托管资源,为 true;否则为 false。</param>
            protected override void Dispose(bool disposing)
            {
                if (disposing && (components != null))
                {
                    components.Dispose();
                }
                base.Dispose(disposing);
            }
    
            #region Windows 窗体设计器生成的代码
    
            /// <summary>
            /// 设计器支持所需的方法 - 不要
            /// 使用代码编辑器修改此方法的内容。
            /// </summary>
            private void InitializeComponent()
            {
                this.components = new System.ComponentModel.Container();
                this.button1 = new System.Windows.Forms.Button();
                this.textBox1 = new System.Windows.Forms.TextBox();
                this.toolTip1 = new System.Windows.Forms.ToolTip(this.components);
                this.SuspendLayout();
                // 
                // button1
                // 
                this.button1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
                this.button1.Location = new System.Drawing.Point(182, 308);
                this.button1.Name = "button1";
                this.button1.Size = new System.Drawing.Size(75, 23);
                this.button1.TabIndex = 0;
                this.button1.Text = "计算MD5";
                this.button1.UseVisualStyleBackColor = true;
                this.button1.Click += new System.EventHandler(this.button1_Click);
                // 
                // textBox1
                // 
                this.textBox1.AllowDrop = true;
                this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
                | System.Windows.Forms.AnchorStyles.Left) 
                | System.Windows.Forms.AnchorStyles.Right)));
                this.textBox1.Location = new System.Drawing.Point(0, 0);
                this.textBox1.Margin = new System.Windows.Forms.Padding(0);
                this.textBox1.Multiline = true;
                this.textBox1.Name = "textBox1";
                this.textBox1.ScrollBars = System.Windows.Forms.ScrollBars.Both;
                this.textBox1.Size = new System.Drawing.Size(257, 305);
                this.textBox1.TabIndex = 1;
                this.toolTip1.SetToolTip(this.textBox1, "可拖动文件至此,查看文件的MD5值");
                this.textBox1.DragDrop += new System.Windows.Forms.DragEventHandler(this.Form_DragDrop);
                this.textBox1.DragEnter += new System.Windows.Forms.DragEventHandler(this.Form_DragEnter);
                // 
                // Form1
                // 
                this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
                this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                this.ClientSize = new System.Drawing.Size(257, 335);
                this.Controls.Add(this.textBox1);
                this.Controls.Add(this.button1);
                this.Name = "Form1";
                this.Text = "MD5";
                this.ResumeLayout(false);
                this.PerformLayout();
    
            }
    
            #endregion
    
            private System.Windows.Forms.Button button1;
            private System.Windows.Forms.TextBox textBox1;
            private System.Windows.Forms.ToolTip toolTip1;
        }
    }

     

     

    工具源码下载

    开源地址

     

    展开全文
  • md5校验工具非常小巧,占内存,它可以用来读取文件的信息,或是校验两个文件的hash是否不同,并支持多种导出文件格式,和哈希比较。还可支持多个文件或文件夹拖放操作,计算速度很快,也支持保存个人设置等,...
  • Hash(MD5校验工具)支持多个文件或文件夹拖放操作,计算速度很快,也支持保存个人设置等,非常的方便好用。功能介绍1、只支持常用的MD5、SHA1、CRC32算法;2、支持多个文件或文件夹拖放操作;3、支持参数启动(参数为...

    Hash(MD5校验工具)是一款小巧好用的哈希计算器,可以用于文件的MD5校验。Hash(MD5校验工具)支持多个文件或文件夹拖放操作,计算速度很快,也支持保存个人设置等,非常的方便好用。

    a0ed6d87d4cbd5e5f405bf8ca0a238aa.png

    功能介绍

    1、只支持常用的MD5、SHA1、CRC32算法;

    2、支持多个文件或文件夹拖放操作;

    3、支持参数启动(参数为一个或多个文件或文件夹路径);

    4、支持保存个人设置(默认保存在注册表,如果存在同名ini文件,则保存在ini文件);

    5、支持哈希值比较(实际上是字符串查找功能);

    6、支持停止、重新开始计算操作;

    7、支持Windows7任务栏进度条效果;

    使用方法

    1、打开Hash(MD5校验工具),把你下载的软件拖进Hash窗口,或者点击浏览,找到你需要查看的软件;

    a3dbfc56a82a02e9a41709eb9ba2385a.png

    2、打开后系统会自动得出你这个文件的MD5码,如果和服务器上人家之前生成的MD5码不同那么说明你下载的这个文件不完整,或是被别人动过手脚,反之则说明没有问题。

    d52de243f58d40985173a075fb9c0559.png

    常见问题

    1、MD5校验工具是用来干什么的?

    MD5校验工具用MD5算法根据下载的文件数据算出来一个校验字符串,然后和服务器上人家之前生成的对比,看看是不是一样,目的是为了验证下载后的文件数据和服务器上的原始文件数据有没有偏差。

    2、MD5校验工具怎么用?

    首先打开MD5校验工具,然后下载的软件拖到该软件内,最后将MD5软件生成的校验码与我们官网上公布的校验码做对比。有变差则说明被改动,不建议安装使用。

    展开全文
  • HashTools 是一款优秀的hash值计算工具 包含文件: 1.0 HashTools 4.1版本(需要.net 4.5) 2.0 HashTools 2.0版本(绿色版) 3.0 制作sfv校验文件 ... 2.0 支持算法:crc32\md5\sha1\sha256\sha384\sha512
  • md校验工具

    2018-06-26 22:56:18
    小巧的md校验工具,亲测好用。 1、只支持常用的MD5、SHA1、CRC32算法;... 5支持哈希比较(实际上是字符串查找功能);  6、支持停止、重新开始计算操作;  7、支持Windows7任务栏进度条效果;
  • MD5、SHA1校验工具

    千次下载 热门讨论 2010-11-15 20:33:03
    本工具用于计算文本或文件的校验码(计算文件的消息摘要), 目前系统支持MD5(128位)/SHA1(160位) /SHA256(256位)/SHA384(384位)/SHA512(512位)/RIPEMD160(160位)算法. 简单地理解, 可以认为, 消息摘要算法就是将一...
  • Hash md5校验工具 是一款小巧好用的哈希计算器 Hash也是一款md5校验工具 Hash支持文件拖放 速度很快 可以计算文件的 MD5 SHA1 CRC32 的 软件特色: 支持多个文件或文件夹拖放操作; 支持参数启动 参数为一个...
  • 一款免费的文件MD5校验工具MD5 Checksum Tool,可以计算校验文件的哈希,校验MD5/SHA1/SHA256/SHA384/SHA512。能扫描指定的文件夹内的所有文件,并创建该校校验报告。支持校验选择文件的MD5值,可以比较两个...
  • MD5密文破解实验

    千次阅读 2021-10-24 20:12:28
    2、使用MD5Crack工具进行MD5解密 3、使用网络资源对密文进行在线破解 4、认真阅读并掌握本实验相关的知识点 5、上机实现实验所提到的工具和操作,得到实验结果,并填写实验报告 预备知识 MD5介绍 1991年,...
  • MD5较验工具 v3.0.zip

    2019-07-13 06:27:51
    支持MD5查询、SHA1查询、CRC32查询校验,并且支持显示文件版本、时间参数,支持文件与文件夹鼠标拖放功能。 该工具可对文件进行批量校验,免去多个文件校验时的麻烦。 主要用途:验证下载后的文件是否与服务器上的...
  • 今天查了一下,发现windows10的PowerShell命令自带的Get-FileHash命令可以直接用来计算文件的HashMD5、SHA1、SHA256等),这样就不用再使用第三方软件了,直接一条命令搞定。 windows10打开PowerShell命令窗口的...
  • 实现步骤前言一、C# hash代码一、C++ hash代码1....这里先看C# 怎么计算hash的。 代码如下(示例): mport numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnin.
  • 亚普md5校验工具

    2011-12-11 15:54:25
        一个 MD5 校验和(checksum)通过对接收的传输数据执行散列运算来检查数据的正确性。计算出的散列拿来和随数据传输的散列...支持批量导入文件夹和文件,支持拖拽,可以自动计算文件MD5值和大小。
  • 平时下载文件,下载页面会有一个哈希,用于校验文件是否正确,比如我们平时用磁链下载文件的时候经常看见MD5,那么哈希是什么? 哈希是将数据经过计算,生成一串由随机字母或数字组成的字符串,不同的哈希...
  • 使用Windows自带的工具计算文件的 MD5 SHA1 SHA256   很多网站会提供下载文件的校验码信息,在下载文件之后,如何方便地计算MD5 SHA1 SHA256等校验和呢?之前我常用的工具是Hash_1.0.4这个小工具,但是这个工具...
  • Hash Verification哈希校验工具是一款小巧的绿色版哈希校验工具,可以快速校验任意文件的MD5、SHA1、SHA256、CRC32校验码。程序提供2种校验算法,分别是内置哈希算法和Windows哈希算法,两种算法的结果应该一致...
  • MD5批量较验工具V3.0

    2011-05-13 21:44:47
    支持MD5查询、SHA1查询、CRC32查询校验,并且支持显示文件版本、时间参数,支持文件与文件夹鼠标拖放功能。 该工具可对文件进行批量校验,免去多个文件校验时的麻烦。 主要用途:验证下载后的文件是否与服务器上的...
  • 表示无法计算MD5值 3、a8a9的应用是基于事先备份基础上,如果没有备份文件BackupMD5.txt,就谈上核对了。 ------------------------------------- ccwm 2008.04.26 Email:2008music@gmail.com
  • win10 自带hash值计算工具工具很好用

    千次阅读 2020-05-24 08:08:13
    命令:certutil -hashfile .\demo-113-2u4g-dc-disk1.vmdk SHA256 支持的哈希算法:MD2 MD4 MD5 SHA1 SHA256 SHA384 SHA512
  • 校验大师是一款免费、快速、小巧易用的对文件进行MD4,MD5,Haval256,RipeMD128,RipeMD160,SHA1,SHA256,SHA384,SHA512,Tiger192等值验证、计算的软件,可快速验证文件的MD5,CRC32等值,确保它们没有被更改过...
  • 最近碰到一个奇葩的问题。用vs2010编译程序调试运行,跟踪到一个函数的时候提示“源文件与模块生成时的文件不同,是否希望调试器使用它?...选择“否”使用该文档调试,弹出来“无可用源”一个界面,界
  • 缓存技术_redis和MD5加密

    千次阅读 2017-02-22 11:12:10
    ##NoSQL 简介## NoSQL,指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写,是对不同于传统的关系型数据库的数据库管理系统的统称。 ... NoSQL的优点/缺点 ...- 分布式计算 - 低成本 - 架构的灵活性,半
  • 计算文件哈希

    万次阅读 2018-12-10 08:39:00
    哈希(hash values)是使用哈希函数(hash function)计算得到的。哈希函数是是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要,使得数据量变小,将数据的格式固定下来。就是根据...
  • 一、简介md5sum计算检验MD5效验码。MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。MD5全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,472
精华内容 7,388
关键字:

文件夹不支持md5值计算

友情链接: 44415498561416.rar