精华内容
下载资源
问答
  • 在PHP中,字符函数 sha1 () 用于计算个字符SHA-1 散列sha1 () 函数 函数语法: sha1(string$str[,bool$raw_output=false]):string 函数参数说明: 参数 描述 string 必需。规定要计算...

    在PHP中,字符串函数 sha1 () 用于计算一个字符串的 SHA-1 散列值。

        sha1 () 函数   

        函数语法:

    sha1 ( string $str [, bool $raw_output = false ] ) : string

        函数参数说明:

    参数 描述
    string 必需。规定要计算的字符串。
    raw_output 可选。规定十六进制或二进制输出格式:
    • TRUE - 原始 20 字符二进制格式

    • FALSE - 默认。40 字符十六进制数

        sha1() 函数使用美国 Secure Hash 算法 1。如果成功则返回已计算的 SHA-1 散列,如果失败则返回 FALSE。

        SHA-1 产生一个名为报文摘要的 160 位的输出。报文摘要可以被输入到一个可生成或验证报文签名的签名算法。对报文摘要进行签名,而不是对报文进行签名,这样可以提高进程效率,因为报文摘要的大小通常比报文要小很多。数字签名的验证者必须像数字签名的创建者一样,使用相同的散列算法。

        提示:如需计算文件的 SHA-1 散列,请使用 sha1_file() 函数。

        举例,计算字符串的 sha1 散列值(raw_output使用默认值false):   

    <?php
    
    $str = 'hello';
    
    echo sha1($str); // 计算字符串的sha-1散列值

        以上代码输出如下(默认情况下,输出40字符的十六进制数):

    aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d

        举例,计算字符串的 sha1 散列值(raw_output使用值true)   

    <?php
    
    $str = 'hello';
    
    echo sha1($str, true); // 计算字符串的sha-1散列值

        以上代码输出如下(输出20字符的字符串):

    ������ھ�;H,ٮ�CM
    展开全文
  • PHP计算MD5和SHA1

    千次阅读 2013-11-13 08:54:46
    MD5的计算分为计算字符和文件的MD5SHA1的计算分为计算字符和文件的SHA1。  1.md5 (PHP 4, PHP 5) md5 — 计算字符的 MD5 散列 Report a bug  说明 string md5 ( string $str [, bool...

        最近开发项目,需要用到文件的MD5和SHA1值,这里简单地记录下,备忘。MD5的计算分为计算字符串和文件的MD5值,SHA1的计算分为计算字符串和文件的SHA1值。

        1.md5

    (PHP 4, PHP 5)

    md5 — 计算字符串的 MD5 散列值

    reject note 说明

    string md5 ( string $str [, bool $raw_output = false ] )

    使用 » RSA 数据安全公司的 MD5 报文算法计算 str 的 MD5 散列值。

    reject note 参数

    str

    原始字符串。

    raw_output

    如果可选的 raw_output 被设置为 TRUE,那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。

    reject note 返回值

    以 32 字符十六进制数字形式返回散列值。

    reject note 更新日志

    版本 说明
    5.0.0 新增 raw_output 参数。

    reject note 范例

    Example #1 md5() 范例

    <?php
    $str 
    'apple';

    if (
    md5($str) === '1f3870be274f6c49b3e31a0c6728957f') {
        echo 
    "Would you like a green or red apple?";
    }
    ?>

    reject note 注释

    NoteSecure password hashing

    由于此函数依赖的算法已不足够复杂,不推荐使用此函数对明文密码加密。详细内容参见这里

    reject note 参见

    • md5_file() - 计算指定文件的 MD5 散列值
    • sha1_file() - 计算文件的 sha1 散列值
    • crc32() - 计算一个字符串的 crc32 多项式
    • sha1() - 计算字符串的 sha1 散列值
    • hash() - Generate a hash value (message digest)
    原文地址:点击打开链接

        2.md5_file

    (PHP 4 >= 4.2.0, PHP 5)

    md5_file — 计算指定文件的 MD5 散列值

    reject note 说明

    string md5_file ( string $filename [, bool $raw_output = false ] )

    使用 » RSA 数据安全公司的 MD5 报文算法计算 filename 文件的 MD5 散列值并返回。该散列值为 32 字符的十六进制数字。

    reject note 参数

    filename

    文件名

    raw_output

    如果被设置为 TRUE,那么报文摘要将以原始的 16 位二进制格式返回。

    reject note 返回值

    成功返回字符串,否则返回 FALSE

    reject note 更新日志

    版本 说明
    5.0.0 新增 raw_output 参数。
    5.1.0 函数改用流 API。这意味着能够配合封装器使用该函数,比如 md5_file('http://example.com/..')

    reject note 范例

    Example #1 md5_file() 使用范例

    <?php
    $file 
    'php-5.3.0alpha2-Win32-VC9-x64.zip';

    echo 
    'MD5 file hash of ' $file ': ' md5_file($file);
    ?>

    reject note 参见

    • md5() - 计算字符串的 MD5 散列值
    • sha1_file() - 计算文件的 sha1 散列值
    • crc32() - 计算一个字符串的 crc32 多项式
    原文地址:点击打开链接

        3.sha1

    (PHP 4 >= 4.3.0, PHP 5)

    sha1 — 计算字符串的 sha1 散列值

    reject note 说明

    string sha1 ( string $str [, bool $raw_output = false ] )

    利用» 美国安全散列算法 1 计算字符串的 sha1 散列值。

    reject note 参数

    str

    输入字符串。

    raw_output

    如果可选的 raw_output 参数被设置为 TRUE,那么 sha1 摘要将以 20 字符长度的原始格式返回,否则返回值是一个 40 字符长度的十六进制数字。

    reject note 返回值

    返回 sha1 散列值字符串。

    reject note 更新日志

    版本 说明
    5.0.0 新增 raw_output 参数。

    reject note 范例

    Example #1 sha1() 范例

    <?php
    $str 
    'apple';

    if (
    sha1($str) === 'd0be2dc421be4fcd0172e5afceea3970e2f3d940') {
        echo 
    "Would you like a green or red apple?";
    }
    ?>

    reject note 注释

    NoteSecure password hashing

    由于此函数依赖的算法已不足够复杂,不推荐使用此函数对明文密码加密。详细内容参见这里

    reject note 参见

    • sha1_file() - 计算文件的 sha1 散列值
    • crc32() - 计算一个字符串的 crc32 多项式
    • md5() - 计算字符串的 MD5 散列值
    • hash() - Generate a hash value (message digest)
    原文地址:点击打开链接

        4.sha1_file

    (PHP 4 >= 4.3.0, PHP 5)

    sha1_file — 计算文件的 sha1 散列值

    reject note 说明

    string sha1_file ( string $filename [, bool $raw_output = false ] )

    利用» 美国安全散列算法 1,计算并返回由 filename 指定的文件的 sha1 散列值。该散列值是一个 40 字符长度的十六进制数字。

    reject note 参数

    filename

    要散列的文件的文件名。

    raw_output

    如果被设置为 TRUE,sha1 摘要将以 20 字符长度的原始格式返回。

    reject note 返回值

    成功返回一个字符串,否则返回 FALSE

    reject note 范例

    Example #1 sha1_file() 范例

    <?php
    foreach(glob('/home/Kalle/myproject/*.php') as $ent)
    {
        if(
    is_dir($ent))
        {
            continue;
        }

        echo 
    $ent ' (SHA1: ' sha1_file($ent) . ')'PHP_EOL;
    }
    ?>

    reject note 更新日志

    版本 说明
    5.0.0 新增 raw_output 参数。
    5.1.0 改变函数以使用流 API。这意味着可以使用包装器,比如 sha1_file('http://example.com/..')

    reject note 参见

    • sha1() - 计算字符串的 sha1 散列值
    • md5_file() - 计算指定文件的 MD5 散列值
    • crc32() - 计算一个字符串的 crc32 多项式

    原文地址:点击打开链接

        

    展开全文
  • SHA256算法原理详解

    万次阅读 多人点赞 2018-07-03 23:07:30
    SHA-2,名称来自于安全散列算法2(英语:Secure Hash Algorithm 2)的缩写,种密码散列函数算法标准,由美国国家安全局研发,属于SHA算法之,是SHA-1的后继者。 SHA-2下又可再分为六个不同的算法标准 包括了:...

    1. SHA256简介

    SHA256是SHA-2下细分出的一种算法

    SHA-2,名称来自于安全散列算法2(英语:Secure Hash Algorithm 2)的缩写,一种密码散列函数算法标准,由美国国家安全局研发,属于SHA算法之一,是SHA-1的后继者。

    SHA-2下又可再分为六个不同的算法标准

    包括了:SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。

    这些变体除了生成摘要的长度 、循环运行的次数等一些微小差异外,算法的基本结构是一致的。

    回到SHA256上,说白了,它就是一个哈希函数。

    哈希函数,又称散列算法,是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要,使得数据量变小,将数据的格式固定下来。该函数将数据打乱混合,重新创建一个叫做散列值(或哈希值)的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。

    对于任意长度的消息,SHA256都会产生一个256bit长的哈希值,称作消息摘要。

    这个摘要相当于是个长度为32个字节的数组,通常用一个长度为64的十六进制字符串来表示

    来看一个例子:

    干他100天成为区块链程序员,红军大叔带领着我们,fighting!

    这句话,经过哈希函数SHA256后得到的哈希值为:

    A7FCFC6B5269BDCCE571798D618EA219A68B96CB87A0E21080C2E758D23E4CE9

    这里找到了一个SHA256在线验证工具,可以用来进行SHA256哈希结果的验证,后面也可以用来检验自己的SHA256代码是否正确。用起来很方便,不妨感受下。


    2. SHA256原理详解

    为了更好的理解SHA256的原理,这里首先将算法中可以单独抽出的模块,包括常量的初始化信息预处理使用到的逻辑运算分别进行介绍,甩开这些理解上的障碍后,一起来探索SHA256算法的主体部分,即消息摘要是如何计算的。

    2.1 常量初始化

    SHA256算法中用到了8个哈希初值以及64个哈希常量

    其中,SHA256算法的8个哈希初值如下:

    h0 := 0x6a09e667
    h1 := 0xbb67ae85
    h2 := 0x3c6ef372
    h3 := 0xa54ff53a
    h4 := 0x510e527f
    h5 := 0x9b05688c
    h6 := 0x1f83d9ab
    h7 := 0x5be0cd19
    

    这些初值是对自然数中前8个质数(2,3,5,7,11,13,17,19)的平方根的小数部分取前32bit而来

    举个例子来说,$ \sqrt{2} $小数部分约为0.414213562373095048,而
    0.4142135623730950486161+a162+0163+... 0.414213562373095048 \approx 6*16^{-1} + a*16^{-2} + 0*16^{-3} + ...
    于是,质数2的平方根的小数部分取前32bit就对应出了0x6a09e667

    在SHA256算法中,用到的64个常量如下:

    428a2f98 71374491 b5c0fbcf e9b5dba5
    3956c25b 59f111f1 923f82a4 ab1c5ed5
    d807aa98 12835b01 243185be 550c7dc3
    72be5d74 80deb1fe 9bdc06a7 c19bf174
    e49b69c1 efbe4786 0fc19dc6 240ca1cc
    2de92c6f 4a7484aa 5cb0a9dc 76f988da
    983e5152 a831c66d b00327c8 bf597fc7
    c6e00bf3 d5a79147 06ca6351 14292967
    27b70a85 2e1b2138 4d2c6dfc 53380d13
    650a7354 766a0abb 81c2c92e 92722c85
    a2bfe8a1 a81a664b c24b8b70 c76c51a3
    d192e819 d6990624 f40e3585 106aa070
    19a4c116 1e376c08 2748774c 34b0bcb5
    391c0cb3 4ed8aa4a 5b9cca4f 682e6ff3
    748f82ee 78a5636f 84c87814 8cc70208
    90befffa a4506ceb bef9a3f7 c67178f2
    

    和8个哈希初值类似,这些常量是对自然数中前64个质数(2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97…)的立方根的小数部分取前32bit而来。

    2.2 信息预处理(pre-processing)

    SHA256算法中的预处理就是在想要Hash的消息后面补充需要的信息,使整个消息满足指定的结构。

    信息的预处理分为两个步骤:附加填充比特附加长度

    STEP1:附加填充比特

    在报文末尾进行填充,使报文长度在对512取模以后的余数是448

    填充是这样进行的:先补第一个比特为1,然后都补0,直到长度满足对512取模后余数是448。

    需要注意的是,信息必须进行填充,也就是说,即使长度已经满足对512取模后余数是448,补位也必须要进行,这时要填充512个比特。

    因此,填充是至少补一位,最多补512位。

    :以信息“abc”为例显示补位的过程。

    a,b,c对应的ASCII码分别是97,98,99

    于是原始信息的二进制编码为:01100001 01100010 01100011

    补位第一步,首先补一个“1” : 0110000101100010 01100011 1

    补位第二步,补423个“0”:01100001 01100010 01100011 10000000 00000000 … 00000000

    补位完成后的数据如下(为了简介用16进制表示):

    61626380 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000
    

    为什么是448?

    因为在第一步的预处理后,第二步会再附加上一个64bit的数据,用来表示原始报文的长度信息。而448+64=512,正好拼成了一个完整的结构。

    STEP2:附加长度值

    附加长度值就是将原始数据(第一步填充前的消息)的长度信息补到已经进行了填充操作的消息后面。

    wiki百科中给出的原文是:append length of message (before pre-processing), in bits, as 64-bit big-endian integer

    SHA256用一个64位的数据来表示原始消息的长度。

    因此,通过SHA256计算的消息长度必须要小于$ 2^64 $,当然绝大多数情况这足够大了。

    长度信息的编码方式为64-bit big-endian integer

    关于Big endian的含义,文末给出了补充

    回到刚刚的例子,消息“abc”,3个字符,占用24个bit

    因此,在进行了补长度的操作以后,整个消息就变成下面这样了(16进制格式)

    61626380 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000 00000000 00000018
    

    2.3 逻辑运算

    SHA256散列函数中涉及的操作全部是逻辑的位运算

    包括如下的逻辑函数:

    Ch(x,y,z)=(xy)(¬xz) Ch(x,y,z) = (x \land y) \oplus (\neg x \land z)
    Ma(x,y,z)=(xy)(xz)(yz) Ma(x,y,z) = (x \land y) \oplus (x \land z) \oplus (y \land z)
    Σ0(x)=S2(x)S13(x)S22(x) \Sigma_{0}(x) = S^{2}(x) \oplus S^{13}(x) \oplus S^{22}(x)
    Σ1(x)=S6(x)S11(x)S25(x) \Sigma_{1}(x) = S^{6}(x) \oplus S^{11}(x) \oplus S^{25}(x)
    σ0(x)=S7(x)S18(x)R3(x) \sigma_{0}(x) = S^{7}(x) \oplus S^{18}(x) \oplus R^{3}(x)
    σ1(x)=S17(x)S19(x)R10(x) \sigma_{1}(x) = S^{17}(x) \oplus S^{19}(x) \oplus R^{10}(x)
    其中:

    逻辑运算 含义
    \land 按位“与”
    ¬ \neg 按位“补”
    \oplus 按位“异或”
    Sn S^{n} 循环右移n个bit
    Rn R^{n} 右移n个bit

    2.4 计算消息摘要

    现在来介绍SHA256算法的主体部分,即消息摘要是如何计算的。

    首先:将消息分解成512-bit大小的块

    (break message into 512-bit chunks)

    图::消息分为n个块1

    假设消息M可以被分解为n个块,于是整个算法需要做的就是完成n次迭代,n次迭代的结果就是最终的哈希值,即256bit的数字摘要。

    一个256-bit的摘要的初始值H0,经过第一个数据块进行运算,得到H1,即完成了第一次迭代

    H1经过第二个数据块得到H2,……,依次处理,最后得到Hn,Hn即为最终的256-bit消息摘要

    将每次迭代进行的映射用$ Map(H_{i-1}) = H_{i} $表示,于是迭代可以更形象的展示为:

    图::迭代过程2

    图中256-bit的Hi被描述8个小块,这是因为SHA256算法中的最小运算单元称为“字”(Word),一个字是32位。

    此外,第一次迭代中,映射的初值设置为前面介绍的8个哈希初值,如下图所示:

    图::哈希初值3

    下面开始介绍每一次迭代的内容,即映射$ Map(H_{i-1}) = H_{i} $的具体算法

    STEP1:构造64个字(word)

    break chunk into sixteen 32-bit big-endian words w[0], …, w[15]

    对于每一块,将块分解为16个32-bit的big-endian的字,记为w[0], …, w[15]

    也就是说,前16个字直接由消息的第i个块分解得到

    其余的字由如下迭代公式得到:

    Wt=σ1(Wt2)+Wt7+σ0(Wt15)+Wt16 W_{t} = \sigma_{1}(W_{t-2}) + W_{t-7} + \sigma_{0}(W_{t-15}) + W_{t-16}

    STEP2:进行64次循环

    映射 $ Map(H_{i-1}) = H_{i} $ 包含了64次加密循环

    即进行64次加密循环即可完成一次迭代

    每次加密循环可以由下图描述:

    图::加密循环4

    图中,ABCDEFGH这8个字(word)在按照一定的规则进行更新,其中

    深蓝色方块是事先定义好的非线性逻辑函数,上文已经做过铺垫

    红色田字方块代表 mod $ 2^{32} $ addition,即将两个数字加在一起,如果结果大于$ 2^{32} ,你必须除以 2^{32} $并找到余数。

    ABCDEFGH一开始的初始值分别为$ H_{i-1}(0),H_{i-1}(1),…,H_{i-1}(7) $

    Kt是第t个密钥,对应我们上文提到的64个常量

    Wt是本区块产生第t个word。原消息被切成固定长度512-bit的区块,对每一个区块,产生64个word,通过重复运行循环n次对ABCDEFGH这八个字循环加密。

    最后一次循环所产生的八个字合起来即是第i个块对应到的散列字符串$ H_{i} $

    由此变完成了SHA256算法的所有介绍


    3. SHA256算法伪代码

    现在我们可以结合SHA256算法的伪代码,将上述的所有步骤进行梳理整合:

    Note: All variables are unsigned 32 bits and wrap modulo 232 when calculating
    
    
    Initialize variables
    (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
    h0 := 0x6a09e667
    h1 := 0xbb67ae85
    h2 := 0x3c6ef372
    h3 := 0xa54ff53a
    h4 := 0x510e527f
    h5 := 0x9b05688c
    h6 := 0x1f83d9ab
    h7 := 0x5be0cd19
    
    
    Initialize table of round constants
    (first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
    k[0..63] :=
       0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
       0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
       0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
       0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
       0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
       0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
       0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
       0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
    
    
    Pre-processing:
    append the bit '1' to the message
    append k bits '0', where k is the minimum number >= 0 such that the resulting message
        length (in bits) is congruent to 448(mod 512)
    append length of message (before pre-processing), in bits, as 64-bit big-endian integer
    
    
    Process the message in successive 512-bit chunks:
    break message into 512-bit chunks
    for each chunk
        break chunk into sixteen 32-bit big-endian words w[0..15]
    
        Extend the sixteen 32-bit words into sixty-four 32-bit words:
        for i from 16 to 63
            s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3)
            s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10)
            w[i] := w[i-16] + s0 + w[i-7] + s1
    
        Initialize hash value for this chunk:
        a := h0
        b := h1
        c := h2
        d := h3
        e := h4
        f := h5
        g := h6
        h := h7
    
        Main loop:
        for i from 0 to 63
            s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22)
            maj := (a and b) xor (a and c) xor(b and c)
            t2 := s0 + maj
            s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)
            ch := (e and f) xor ((not e) and g)
            t1 := h + s1 + ch + k[i] + w[i]
            h := g
            g := f
            f := e
            e := d + t1
            d := c
            c := b
            b := a
            a := t1 + t2
    
        Add this chunk's hash to result so far:
        h0 := h0 + a
        h1 := h1 + b
        h2 := h2 + c
        h3 := h3 + d
        h4 := h4 + e
        h5 := h5 + f
        h6 := h6 + g
        h7 := h7 + h
    
    Produce the final hash value (big-endian):
    digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
    

    4. 参考文献

    本篇笔记主要参考整合的资料如下:

    SHA-2 wiki

    比特币算法——SHA256算法介绍

    SHA-256算法实现

    操作指南:验证SHA256


    知识填补

    大端和小端(Big endian and Little endian)

    对于整型、长整型等数据类型,都存在字节排列的高低位顺序问题。

    Big endian 认为第一个字节是最高位字节(按照从低地址到高地址的顺序存放数据的高位字节到低位字节)

    而 Little endian 则相反,它认为第一个字节是最低位字节(按照从低地址到高地址的顺序存放据的低位字节到高位字节)。

    例如,假设从内存地址 0x0000 开始有以下数据:

    地址 数据
    0x0000 0x12
    0x0001 0x34
    0x0002 0xab
    0x0003 0xcd

    假设我们去读取一个地址为 0x0000 的四个字节变量

    若字节序为big-endian,则读出结果为0x1234abcd;

    若字节序为little-endian,则读出结果为0xcdab3412。

    如果我们将0x1234abcd 写入到以 0x0000 开始的内存中,则Little endian 和 Big endian 模式的存放结果如下:

    地址 0x0000 0x0001 0x0002 0x0003
    big-Big_endian 0x12 0x34 0xab 0xcd
    little-endian 0xcd 0xab 0x34 0x12

    参考文献

    点击返回正文

    展开全文
  • C语言获取文件的SHA1哈希

    万次阅读 2014-05-12 00:17:43
    安全哈希算法(Secure Hash Algorithm)主要适用于...对于长度小于2^64位的消息,SHA1会产生个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,

    安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,那么这时候就会产生不同的消息摘要。 SHA1有如下特性:不可以从消息摘要中复原信息;两个不同的消息不会产生同样的消息摘要。

    SHA1 C语言实现

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <assert.h>
    #include <errno.h>
    
    #undef BIG_ENDIAN_HOST
    typedef unsigned int u32;
    
    /****************
    * Rotate a 32 bit integer by n bytes
    */
    #if defined(__GNUC__) && defined(__i386__)
    static inline u32
    	rol( u32 x, int n)
    {
    	__asm__("roll %%cl,%0"
    		:"=r" (x)
    		:"0" (x),"c" (n));
    	return x;
    }
    #else
    #define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
    #endif
    
    
    typedef struct {
    	u32  h0,h1,h2,h3,h4;
    	u32  nblocks;
    	unsigned char buf[64];
    	int  count;
    } SHA1_CONTEXT;
    
    
    
    void
    	sha1_init( SHA1_CONTEXT *hd )
    {
    	hd->h0 = 0x67452301;
    	hd->h1 = 0xefcdab89;
    	hd->h2 = 0x98badcfe;
    	hd->h3 = 0x10325476;
    	hd->h4 = 0xc3d2e1f0;
    	hd->nblocks = 0;
    	hd->count = 0;
    }
    
    
    /****************
    * Transform the message X which consists of 16 32-bit-words
    */
    static void
    	transform( SHA1_CONTEXT *hd, unsigned char *data )
    {
    	u32 a,b,c,d,e,tm;
    	u32 x[16];
    
    	/* get values from the chaining vars */
    	a = hd->h0;
    	b = hd->h1;
    	c = hd->h2;
    	d = hd->h3;
    	e = hd->h4;
    
    #ifdef BIG_ENDIAN_HOST
    	memcpy( x, data, 64 );
    #else
    	{
    		int i;
    		unsigned char *p2;
    		for(i=0, p2=(unsigned char*)x; i < 16; i++, p2 += 4 ) 
    		{
    			p2[3] = *data++;
    			p2[2] = *data++;
    			p2[1] = *data++;
    			p2[0] = *data++;
    		}
    	}
    #endif
    
    
    #define K1  0x5A827999L
    #define K2  0x6ED9EBA1L
    #define K3  0x8F1BBCDCL
    #define K4  0xCA62C1D6L
    #define F1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )
    #define F2(x,y,z)   ( x ^ y ^ z )
    #define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
    #define F4(x,y,z)   ( x ^ y ^ z )
    
    
    #define M(i) ( tm =   x[i&0x0f] ^ x[(i-14)&0x0f] \
    	^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f] \
    	, (x[i&0x0f] = rol(tm,1)) )
    
    #define R(a,b,c,d,e,f,k,m)  do { e += rol( a, 5 )     \
    	+ f( b, c, d )  \
    	+ k	      \
    	+ m;	      \
    	b = rol( b, 30 );    \
    	} while(0)
    	R( a, b, c, d, e, F1, K1, x[ 0] );
    	R( e, a, b, c, d, F1, K1, x[ 1] );
    	R( d, e, a, b, c, F1, K1, x[ 2] );
    	R( c, d, e, a, b, F1, K1, x[ 3] );
    	R( b, c, d, e, a, F1, K1, x[ 4] );
    	R( a, b, c, d, e, F1, K1, x[ 5] );
    	R( e, a, b, c, d, F1, K1, x[ 6] );
    	R( d, e, a, b, c, F1, K1, x[ 7] );
    	R( c, d, e, a, b, F1, K1, x[ 8] );
    	R( b, c, d, e, a, F1, K1, x[ 9] );
    	R( a, b, c, d, e, F1, K1, x[10] );
    	R( e, a, b, c, d, F1, K1, x[11] );
    	R( d, e, a, b, c, F1, K1, x[12] );
    	R( c, d, e, a, b, F1, K1, x[13] );
    	R( b, c, d, e, a, F1, K1, x[14] );
    	R( a, b, c, d, e, F1, K1, x[15] );
    	R( e, a, b, c, d, F1, K1, M(16) );
    	R( d, e, a, b, c, F1, K1, M(17) );
    	R( c, d, e, a, b, F1, K1, M(18) );
    	R( b, c, d, e, a, F1, K1, M(19) );
    	R( a, b, c, d, e, F2, K2, M(20) );
    	R( e, a, b, c, d, F2, K2, M(21) );
    	R( d, e, a, b, c, F2, K2, M(22) );
    	R( c, d, e, a, b, F2, K2, M(23) );
    	R( b, c, d, e, a, F2, K2, M(24) );
    	R( a, b, c, d, e, F2, K2, M(25) );
    	R( e, a, b, c, d, F2, K2, M(26) );
    	R( d, e, a, b, c, F2, K2, M(27) );
    	R( c, d, e, a, b, F2, K2, M(28) );
    	R( b, c, d, e, a, F2, K2, M(29) );
    	R( a, b, c, d, e, F2, K2, M(30) );
    	R( e, a, b, c, d, F2, K2, M(31) );
    	R( d, e, a, b, c, F2, K2, M(32) );
    	R( c, d, e, a, b, F2, K2, M(33) );
    	R( b, c, d, e, a, F2, K2, M(34) );
    	R( a, b, c, d, e, F2, K2, M(35) );
    	R( e, a, b, c, d, F2, K2, M(36) );
    	R( d, e, a, b, c, F2, K2, M(37) );
    	R( c, d, e, a, b, F2, K2, M(38) );
    	R( b, c, d, e, a, F2, K2, M(39) );
    	R( a, b, c, d, e, F3, K3, M(40) );
    	R( e, a, b, c, d, F3, K3, M(41) );
    	R( d, e, a, b, c, F3, K3, M(42) );
    	R( c, d, e, a, b, F3, K3, M(43) );
    	R( b, c, d, e, a, F3, K3, M(44) );
    	R( a, b, c, d, e, F3, K3, M(45) );
    	R( e, a, b, c, d, F3, K3, M(46) );
    	R( d, e, a, b, c, F3, K3, M(47) );
    	R( c, d, e, a, b, F3, K3, M(48) );
    	R( b, c, d, e, a, F3, K3, M(49) );
    	R( a, b, c, d, e, F3, K3, M(50) );
    	R( e, a, b, c, d, F3, K3, M(51) );
    	R( d, e, a, b, c, F3, K3, M(52) );
    	R( c, d, e, a, b, F3, K3, M(53) );
    	R( b, c, d, e, a, F3, K3, M(54) );
    	R( a, b, c, d, e, F3, K3, M(55) );
    	R( e, a, b, c, d, F3, K3, M(56) );
    	R( d, e, a, b, c, F3, K3, M(57) );
    	R( c, d, e, a, b, F3, K3, M(58) );
    	R( b, c, d, e, a, F3, K3, M(59) );
    	R( a, b, c, d, e, F4, K4, M(60) );
    	R( e, a, b, c, d, F4, K4, M(61) );
    	R( d, e, a, b, c, F4, K4, M(62) );
    	R( c, d, e, a, b, F4, K4, M(63) );
    	R( b, c, d, e, a, F4, K4, M(64) );
    	R( a, b, c, d, e, F4, K4, M(65) );
    	R( e, a, b, c, d, F4, K4, M(66) );
    	R( d, e, a, b, c, F4, K4, M(67) );
    	R( c, d, e, a, b, F4, K4, M(68) );
    	R( b, c, d, e, a, F4, K4, M(69) );
    	R( a, b, c, d, e, F4, K4, M(70) );
    	R( e, a, b, c, d, F4, K4, M(71) );
    	R( d, e, a, b, c, F4, K4, M(72) );
    	R( c, d, e, a, b, F4, K4, M(73) );
    	R( b, c, d, e, a, F4, K4, M(74) );
    	R( a, b, c, d, e, F4, K4, M(75) );
    	R( e, a, b, c, d, F4, K4, M(76) );
    	R( d, e, a, b, c, F4, K4, M(77) );
    	R( c, d, e, a, b, F4, K4, M(78) );
    	R( b, c, d, e, a, F4, K4, M(79) );
    
    	/* Update chaining vars */
    	hd->h0 += a;
    	hd->h1 += b;
    	hd->h2 += c;
    	hd->h3 += d;
    	hd->h4 += e;
    }
    
    
    /* Update the message digest with the contents
    * of INBUF with length INLEN.
    */
    static void
    	sha1_write( SHA1_CONTEXT *hd, unsigned char *inbuf, size_t inlen)
    {
    	if( hd->count == 64 ) { /* flush the buffer */
    		transform( hd, hd->buf );
    		hd->count = 0;
    		hd->nblocks++;
    	}
    	if( !inbuf )
    		return;
    	if( hd->count ) {
    		for( ; inlen && hd->count < 64; inlen-- )
    			hd->buf[hd->count++] = *inbuf++;
    		sha1_write( hd, NULL, 0 );
    		if( !inlen )
    			return;
    	}
    
    	while( inlen >= 64 ) {
    		transform( hd, inbuf );
    		hd->count = 0;
    		hd->nblocks++;
    		inlen -= 64;
    		inbuf += 64;
    	}
    	for( ; inlen && hd->count < 64; inlen-- )
    		hd->buf[hd->count++] = *inbuf++;
    }
    
    
    /* The routine final terminates the computation and
    * returns the digest.
    * The handle is prepared for a new cycle, but adding bytes to the
    * handle will the destroy the returned buffer.
    * Returns: 20 bytes representing the digest.
    */
    
    static void
    	sha1_final(SHA1_CONTEXT *hd)
    {
    	u32 t, msb, lsb;
    	unsigned char *p;
    
    	sha1_write(hd, NULL, 0); /* flush */;
    
    	t = hd->nblocks;
    	/* multiply by 64 to make a byte count */
    	lsb = t << 6;
    	msb = t >> 26;
    	/* add the count */
    	t = lsb;
    	if( (lsb += hd->count) < t )
    		msb++;
    	/* multiply by 8 to make a bit count */
    	t = lsb;
    	lsb <<= 3;
    	msb <<= 3;
    	msb |= t >> 29;
    
    	if( hd->count < 56 ) { /* enough room */
    		hd->buf[hd->count++] = 0x80; /* pad */
    		while( hd->count < 56 )
    			hd->buf[hd->count++] = 0;  /* pad */
    	}
    	else { /* need one extra block */
    		hd->buf[hd->count++] = 0x80; /* pad character */
    		while( hd->count < 64 )
    			hd->buf[hd->count++] = 0;
    		sha1_write(hd, NULL, 0);  /* flush */;
    		memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
    	}
    	/* append the 64 bit count */
    	hd->buf[56] = msb >> 24;
    	hd->buf[57] = msb >> 16;
    	hd->buf[58] = msb >>  8;
    	hd->buf[59] = msb	   ;
    	hd->buf[60] = lsb >> 24;
    	hd->buf[61] = lsb >> 16;
    	hd->buf[62] = lsb >>  8;
    	hd->buf[63] = lsb	   ;
    	transform( hd, hd->buf );
    
    	p = hd->buf;
    #ifdef BIG_ENDIAN_HOST
    #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
    #else /* little endian */
    #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;	 \
    	*p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
    #endif
    	X(0);
    	X(1);
    	X(2);
    	X(3);
    	X(4);
    #undef X
    }

    控制台调用函数:

    /*输出文件的SHA1值
    * FileNameInPut:文件路径
    */
    void GetFileSHA1(char *FileNameInPut)
    {
    	if(FileNameInPut==NULL) 
    	{
    		printf("\nUsage:\n     <EXEFILE> <FILENAME>\n ");
    		return;
    	}
    	FILE *fp;
    	char buffer[4096];
    	size_t n;
    	SHA1_CONTEXT ctx;
    	int i;
    
    	fopen_s (&fp, FileNameInPut, "rb");
    	if (!fp)			
    	{
    		printf("打开文件“%s”失败\n", FileNameInPut);
    		return;
    	}
    	sha1_init (&ctx);
    	while ( (n = fread (buffer, 1, sizeof buffer, fp)))		sha1_write (&ctx, (unsigned char *)buffer, n);
    	if (ferror (fp))
    	{
    		printf("读取文件“%s”失败\n", FileNameInPut);
    		return;
    	}
    	sha1_final (&ctx);
    	fclose (fp);
    
    	for ( i=0; i < 20; i++)
    	{
    		printf("%02x",ctx.buf[i]);
    	}
    }

    适合程序中调用的返回值方式:

    /*获取文件的SHA1值,如果发生错误则将错误信息写入outError
    * FileNameInPut:文件路径
    * outSHA1:SHA1输出变量
    * outError:错误信息输出变量
    * returns:outSHA1
    */
    char *GetFileSHA1(char *FileNameInPut, char *outSHA1, char *outError)
    {
    	if(FileNameInPut==NULL) 
    	{
    		if (outError != NULL)
    		{
    			sprintf(outError, "%s", "FileNameInPut Is NULL");
    		}
    		return outSHA1;
    	}
    	FILE *fp;
    	char buffer[4096];
    	size_t n;
    	SHA1_CONTEXT ctx;
    	int i;
    
    	fopen_s (&fp, FileNameInPut, "rb");
    	if (!fp)			
    	{
    		if (outError != NULL)
    		{
    			sprintf(outError, "打开文件“%s”失败\n", FileNameInPut);
    		}
    		return outSHA1;
    	}
    	sha1_init (&ctx);
    	while ( (n = fread (buffer, 1, sizeof buffer, fp)))		sha1_write (&ctx, (unsigned char *)buffer, n);
    	if (ferror (fp))
    	{
    		if (outError != NULL)
    		{
    			sprintf(outError, "读取文件“%s”失败\n", FileNameInPut);
    		}
    		return outSHA1;
    	}
    	sha1_final (&ctx);
    	fclose (fp);
    
    	for ( i=0; i < 20; i++)
    	{
    		sprintf(outSHA1 + 2*i, "%02x", (unsigned char)ctx.buf[i]);
    	}
    	outSHA1[2*i] = '\0';
    	return outSHA1;
    }
    水平有限,此方法只是简单的实现,还有些问题没有解决,希望高手指点一二,小弟不胜感激!

    用法示例:

    //用法实例:
    int main (int argc, char **argv)
    {
    	GetFileSHA1(*(argv+1));
    
    	printf("\r\n");
    	char sha1[41] = { 0 };
    	char eror[256] = { 0 };
    	printf("%s\r\n", GetFileSHA1(*(argv+1), sha1, NULL));
    	if (strlen(eror) != 0)
    	{
    		printf("获取SHA1发生错误:%s\r\n", eror);
    	}
    
    	printf("%s\r\n", GetFileSHA1(*(argv+1), sha1, eror));
    	if (strlen(eror) != 0)
    	{
    		printf("获取SHA1发生错误:%s\r\n", eror);
    	}
    	getchar();
    	return 0;
    }

    命令提示符下用法:


    源码下载:http://download.csdn.net/detail/testcs_dn/7332933

    展开全文
  • SHA1 - 生成sha1散列

    千次阅读 2014-06-20 11:11:11
    SHA 是 Secure Hash Algorithm (安全散列算法) 的缩写,它用来产生 20 个字节 (160位) 的散列,该算法常用于数字签名,以防止数据遭到篡改。 这里介绍 openssl 提供 API 计算数据的 SHA1 。实际上,该 API 有...
  • Windows系统中通过 “certutil -hashfile 文件名 hash算法” dos命令可以查看文件的MD5,SHA1,SHA256 哈希校验,无需第三方工具。并推荐个在线查看文件的各种哈希校验: ...
  • Android代码查看sha1

    千次阅读 2018-03-16 13:42:06
    SHA1 编辑安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生...
  • 计算MD5和SHA哈希 Groovy为String类添加了许多有用的方法。 从Groovy 2.5.0开始,我们甚至可以使用md5和digest方法计算MD5和SHA哈希。 md5方法使用MD5算法创建哈希。 digest方法接受算法的名称作为。 这些...
  • 数字签名算法MD5和SHA-1的比较

    千次阅读 2018-04-17 15:17:37
    还有拿单个ISO文件的MD5,SHA-1讯问是不是原版的问题,在这里,对以上问题做个终结解释!了解hashHash,一般翻译做“散列”,也有直接音译为”哈希”的,就是把任意长度的输入(又叫做预映射,pre-image),通过...
  • 离线二维码的技术原型是在行业中广泛使用的次性口令(OTP, One-time Password),使用了该技术的产品除了有支付宝和微信,还有银行U盾、游戏...2、 打开付款码时,本地生成段含有token与当前时时间戳的哈希,如
  • 数字摘要算法工具类 含(Hamc)MD5/SHA1/SHA256/SHA512以及PBKDF2
  • PowerShell获取文件的SHA1

    千次阅读 2010-07-17 01:22:00
    对于长度小于2^64位的消息,SHA1会产生个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,那么这时候就会产生不同的消息摘要。 SHA1有如下...
  • java 数字签名 算法解析(干货)欢迎使用Markdown编辑器数字签名算法概述功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入段漂亮的代码片生成个适合你的列表创建个表格...
  • SHA 安全哈希算法(Secure Hash Algorithm)主要适用于...对于长度小于2^64位的消息,SHA1会产生个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善,并被广泛使用。该算法的思想是接收段明文...
  • 数字货币开发使用椭圆曲线算法生成公钥和私钥,选择的是secp256k1曲线。生成的公钥是33字节的大数,私钥是32字节的大数,钱包文件wallet.dat中直接保存了公钥和私钥。我们在接收和发送比特币时用到的比特币地址是...
  • 对于任意长度的消息,SHA-256都会产生个256bit长的哈希,称作消息摘要。这个摘要相当于是个长度为32个字节的数组,通常用个长度为64的十六进制字符来表示。 String password = "123"; StringBuilder sb = ...
  • SHA1WithRSA 验证数字签名

    万次阅读 2008-03-22 10:00:00
    public class SignProvider { private SignProvider() { } /** * * Description:校验数字签名,此方法不会抛出任务异常,成功返回true,失败返回false,要求全部参数不能为空 * * @param pubKeyText * ...
  • SHA1加密

    万次阅读 2016-09-14 17:16:36
    SHA简介: 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准...SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串
  • linux下验证软件md5SHA1

    千次阅读 2011-10-29 09:25:52
     问:我发现很多软件下载站在提供软件本身的下载外,还经常提供由一串字符和数字组成的MD5和一个验证文件,请问,到底什么是MD5,与这个软件有什么关系?    答:MD5就是软件的指纹,用户可以通过软件...
  • Message Digest(信息摘要,也被称为cryptographic checksum校验和加密、cryptography hashcode哈希加密) 就是一串数字,通过一个很难被逆向推到的公式 算出来的hash code。 将不确定长度的输入(文
  • Java加密算法---SHA

    千次阅读 2016-09-20 17:09:05
    SHA算法介绍:SHA即Secure Hash Algorithm(安全哈希算法),用于数字签名标准(DSS)里面定义的数字签名算法(DSA)。SHA数字签名等密码学应用中重要的...SHA算法详解:SHA算法是接收段明文,然后以种不可逆的方
  • SHA简介

    2019-10-23 22:13:26
    SHA256是SHA-2下细分出的种算法 SHA-2,名称来自于安全散列算法2(英语:Secure Hash Algorithm 2)的缩写,种密码散列函数算法标准,由美国国家安全局研发,属于SHA算法之,是SHA-1的后继者。 SHA-2下又可...
  • SHA256

    千次阅读 2019-06-17 16:48:21
    SHA-2,名称来自于安全散列算法2(英语:Secure Hash Algorithm 2)的缩写,种密码散列函数算法标准,由美国国家安全局研发,属于SHA算法之,是SHA-1的后继者。 SHA-2下又可再分为六个不同的算法标准 包括了:...
  • 【OpenSSL】OpenSSL之SHA

    千次阅读 2019-10-23 17:50:26
    00. 目录 文章目录00. 目录01. SHA-1介绍02....SHA-1(英语:Secure Hash Algorithm 1,中文名:安全散列算法1)是种密码散列函数,美国国家安全局设计,并由美国国家标准技术研究所(NIST)发布为联邦...
  • sha1加密实现

    千次阅读 2018-11-15 15:08:22
    SHA1加密:安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生...
  • Java 加解密技术之SHA

    万次阅读 2016-12-15 22:18:07
    这篇文章继续之前提到的单向加密,主要讲的是 SHA,同 MD5 一样,SHA 同样也是个系列,它包括 SHA-1,SHA-224,SHA-256,SHA-384,和 SHA-512 等几种算法。其中,SHA-1,SHA-224 和 SHA-256 适用于长度不超过 2^64...
  • MD5 SHA1 SHA256 SHA512 这4种本质都是摘要函数,不通在于长度 MD5 是 128 位,SHA1 是 160 位 ,SHA256 是 256 位,SHA512 是512 位。 SHA1WithRSA 他的 核心算法是 先用sha1 去摘要,然后使用 RSA 加密。但是 他...
  • iOS - 获取文件的SHA1、SHA256

    千次阅读 2018-02-24 16:53:24
    这篇文章,我们来获取一下文件的SHA1。此方法主要用于文件比对,比如云空间上传文件时,需要提前判断文件之前是否存在于与空间之上。...能计算出数字消息所对应到的长度固定的字符(又称消息摘要)的算法。且...
  • SHA-1算法c语言实现

    万次阅读 2014-05-14 09:59:05
    安全哈希算法(Secure Hash Algorithm)主要适用于...对于长度小于2^64位的消息,SHA1会产生个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,220
精华内容 10,488
关键字:

一串数字的sha值