精华内容
参与话题
问答
  • SHA1算法原理(转载)

    千次阅读 2018-04-17 14:56:27
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。 对于长度小于2^64位的消息,SHA1...


    1 SHA1算法简介

            安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。

            对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。当接收到消息的时候,这个消息摘要可以用来验证数据的完整性。在传输的过程中,数据很可能会发生变化,那么这时候就会产生不同的消息摘要。

    SHA1有如下特性:不可以从消息摘要中复原信息;两个不同的消息不会产生同样的消息摘要。

    2 术语和概念

    2.1(Bit),字节(Byte)和字(Word

        SHA1始终把消息当成一个位(bit)字符串来处理。本文中,一个Word)是32位,而一个字节Byte)是8位。比如,字符串“abc”可以被转换成一个位字符串:01100001 01100010 01100011。它也可以被表示成16进制字符串: 0x616263.

    2.2 运算符和符号

    下面的逻辑运算符都被运用于Word

    X^Y = XY逻辑与

    X \/ Y = XY逻辑或

    X XOR Y= XY逻辑异或

    ~X = X逻辑取反

    X+Y定义如下:

      字 X Y 代表两个整数 x y, 其中 0 <= x < 2^32 0 <= y < 2^32. 令整数z = (x + y) mod 2^32. 这时候 0 <= z < 2^32. z转换成字Z, 那么就是 Z = X + Y.

      循环左移位操作符Sn(X)X是一个字,n是一个整数,0<=n<=32Sn(X) = (X<>32-n)

    X<>n是抛弃右边的n位,将各个位依次向右移动n位,然后在左边的n位填0。因此可以叫Sn(X)位循环移位运算

    3 SHA1算法描述

      在SHA1算法中,我们必须把原始消息(字符串,文件等)转换成位字符串。SHA1算法只接受位作为输入。假设我们对字符串“abc”产生消息摘要。首先,我们将它转换成位字符串如下:

    01100001 01100010 01100011

    ―――――――――――――

    ‘a’=97 ‘b’=98 ‘c’=99

      这个位字符串的长度为24。下面我们需要5个步骤来计算MD5

    3.1 补位

      消息必须进行补位,以使其长度在对512取模以后的余数是448。也就是说,(补位后的消息长度)%512 = 448。即使长度已经满足对512取模后余数是448,补位也必须要进行。

      补位是这样进行的:先补一个1,然后再补0,直到长度满足对512取模后余数是448。总而言之,补位是至少补一位,最多补512位。还是以前面的“abc”为例显示补位的过程。

      原始信息: 01100001 01100010 01100011

      补位第一步:01100001 01100010 01100011 1

      首先补一个“1”

      补位第二步:01100001 01100010 01100011 10…..0

      然后补423“0”

      我们可以把最后补位完成后的数据用16进制写成下面的样子

    61626380 00000000 00000000 00000000

    00000000 00000000 00000000 00000000

    00000000 00000000 00000000 00000000

    00000000 00000000

      现在,数据的长度是448了,我们可以进行下一步操作。

    3.2 补长度

      所谓的补长度是将原始数据的长度补到已经进行了补位操作的消息后面。通常用一个64位的数据来表示原始消息的长度。如果消息长度不大于2^64,那么第一个字就是0。在进行了补长度的操作以后,整个消息就变成下面这样了(16进制格式)

    61626380 00000000 00000000 00000000

    00000000 00000000 00000000 00000000

    00000000 00000000 00000000 00000000

    00000000 00000000 00000000 00000018

      如果原始的消息长度超过了512,我们需要将它补成512的倍数。然后我们把整个消息分成一个一个512位的数据块,分别处理每一个数据块,从而得到消息摘要。

    3.3 使用的常量

      一系列的常量字K(0), K(1), ... , K(79),如果以16进制给出。它们如下:

    Kt = 0x5A827999 (0 <= t <= 19)

    Kt = 0x6ED9EBA1 (20 <= t <= 39)

    Kt = 0x8F1BBCDC (40 <= t <= 59)

    Kt = 0xCA62C1D6 (60 <= t <= 79).

    3.4 需要使用的函数

      在SHA1中我们需要一系列的函数。每个函数ft (0 <= t <= 79)都操作32位字BCD并且产生32位字作为输出。ft(B,C,D)可以如下定义

    ft(B,C,D) = (B AND C) or ((NOT B) AND D) ( 0 <= t <= 19)

    ft(B,C,D) = B XOR C XOR D (20 <= t <= 39)

    ft(B,C,D) = (B AND C) or (B AND D) or (C AND D) (40 <= t <= 59)

    ft(B,C,D) = B XOR C XOR D (60 <= t <= 79).

    3.5 计算消息摘要

      必须使用进行了补位和补长度后的消息来计算消息摘要。计算需要两个缓冲区,每个都由532位的字组成,还需要一个8032位字的缓冲区。第一个5个字的缓冲区被标识为ABCDE。第一个5个字的缓冲区被标识为H0, H1, H2, H3, H480个字的缓冲区被标识为W0, W1,..., W79

      另外还需要一个一个字的TEMP缓冲区。

      为了产生消息摘要,在第4部分中定义的16个字的数据块M1, M2,..., Mn

      会依次进行处理,处理每个数据块Mi 包含80个步骤。

      在处理每个数据块之前,缓冲区 被初始化为下面的值(16进制)

    H0 = 0x67452301

    H1 = 0xEFCDAB89

    H2 = 0x98BADCFE

    H3 = 0x10325476

    H4 = 0xC3D2E1F0.

      现在开始处理M1, M2, ... , Mn。为了处理 Mi,需要进行下面的步骤

    (1). Mi 分成 16 个字 W0, W1, ... , W15, W0 是最左边的字

    (2). 对于 t = 16 79 Wt = S1(Wt-3 XOR Wt-8 XOR Wt- 14 XOR Wt-16).

    (3). A = H0, B = H1, C = H2, D = H3, E = H4.

    (4) 对于 t = 0 79,执行下面的循环

    TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;

    E = D; D = C; C = S30(B); B = A; A = TEMP;

    (5). H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.

      在处理完所有的 Mn, 后,消息摘要是一个160位的字符串,以下面的顺序标识

    H0 H1 H2 H3 H4.

      对于SHA256,SHA384,SHA512。你也可以用相似的办法来计算消息摘要。对消息进行补位的算法完全是一样的。

    4 参考文献

    1: FIPS 180-1 Secure Hash Standard: http://www.itl.nist.gov/fipspubs/fip180-1.htm

    2: Secure Hash Standard: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf

    5 实现代码如下:

    using System; 
    using System.Collections; 
    using System.IO; 
    using System.Text;

    namespace VerifySHA1
    {
        public class MySHA1
        { 
            // state variables 
            private static UInt32 Message_Digest1      = 0x67452301;
            private static UInt32 Message_Digest2      = 0xEFCDAB89;
            private static UInt32 Message_Digest3      = 0x98BADCFE;
            private static UInt32 Message_Digest4      = 0x10325476;
            private static UInt32 Message_Digest5      = 0xC3D2E1F0;

            private static UInt32 SHA1CircularShift(int bits,UInt32 word) 
            {
                return ((word << bits) & 0xFFFFFFFF) | (word) >> (32-(bits));
            }

            private static void SHA1_Init()
            { 
                Message_Digest1      = 0x67452301;
                Message_Digest2      = 0xEFCDAB89;
                Message_Digest3      = 0x98BADCFE;
                Message_Digest4      = 0x10325476;
                Message_Digest5      = 0xC3D2E1F0;
            }

            private static UInt32[] SHA1_Append(byte[] input)
            { 
                int zeros=0; 
                int ones =1; 
                int size=0; 
                int n = input.Length; 
                int m = n%64; 
                if( m < 56 )
                { 
                    zeros = 55-m; 
                    size=n-m+64; 
                } 
                else if (m==56)
                { 
                    zeros = 63; 
                    ones = 1; 
                    size=n+8+64; 
                } 
                else
                { 
                    zeros = 63-m+56; 
                    size=n+64-m+64; 
                }

                ArrayList bs = new ArrayList(input); 
                if(ones==1)
                { 
                    bs.Add( (byte)0x80 ); // 0x80 = 10000000 
                } 
                for(int i=0;i<zeros;i++)
                { 
                    bs.Add( (byte)0 ); 
                }

                UInt64 N = (UInt64) n * 8; 
                byte h8=(byte)(N&0xFF); 
                byte h7=(byte)((N>>8)&0xFF); 
                byte h6=(byte)((N>>16)&0xFF); 
                byte h5=(byte)((N>>24)&0xFF); 
                byte h4=(byte)((N>>32)&0xFF); 
                byte h3=(byte)((N>>40)&0xFF); 
                byte h2=(byte)((N>>48)&0xFF); 
                byte h1=(byte)(N>>56); 
                bs.Add(h1); 
                bs.Add(h2); 
                bs.Add(h3); 
                bs.Add(h4); 
                bs.Add(h5); 
                bs.Add(h6); 
                bs.Add(h7); 
                bs.Add(h8); 
                byte[] ts=(byte[])bs.ToArray(typeof(byte));

                /* Decodes input (byte[]) into output (UInt32[]). Assumes len is 
                 * a multiple of 4. 
                 */ 
                UInt32[] output = new UInt32[size/4]; 
                for(Int64 i=0,j=0;i<size;j++,i+=4)
                {
                    UInt32 temp = 0;
                    temp=temp|(((UInt32)ts[i])<<24);
                    temp=temp|(((UInt32)ts[i+1])<<16);
                    temp=temp|(((UInt32)ts[i+2])<<8);
                    temp=temp|(((UInt32)ts[i+3]));
                    output[j] = temp;
                } 
                return output; 
            } 
            private static UInt32[] SHA1_Transform(UInt32[] x)
            { 
                SHA1_Init();

                UInt32[] K = {
                                 0x5A827999,
                                 0x6ED9EBA1,
                                 0x8F1BBCDC,
                                 0xCA62C1D6
                             };
                int         t;                  
                UInt32    temp;              
                UInt32[]    W = new UInt32[80];             
                UInt32    A, B, C, D, E;  

                for(int k=0; k            {
                    for(t = 0; t < 16; t++)
                    {
                        W[t] = x[t+k];
                    }

                    for(t = 16; t < 80; t++)
                    {
                        W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
                    }

                    A = Message_Digest1;
                    B = Message_Digest2;
                    C = Message_Digest3;
                    D = Message_Digest4;
                    E = Message_Digest5;

                    for(t = 0; t < 20; t++)
                    {
                        temp = SHA1CircularShift(5,A) +
                            ((B & C) | ((~B) & D)) + E + W[t] + K[0];
                        temp &= 0xFFFFFFFF;
                        E = D;
                        D = C;
                        C = SHA1CircularShift(30,B);
                        B = A;
                        A = temp;
                    }

                    for(t = 20; t < 40; t++)
                    {
                        temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
                        temp &= 0xFFFFFFFF;
                        E = D;
                        D = C;
                        C = SHA1CircularShift(30,B);
                        B = A;
                        A = temp;
                    }

                    for(t = 40; t < 60; t++)
                    {
                        temp = SHA1CircularShift(5,A) +
                            ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
                        temp &= 0xFFFFFFFF;
                        E = D;
                        D = C;
                        C = SHA1CircularShift(30,B);
                        B = A;
                        A = temp;
                    }

                    for(t = 60; t < 80; t++)
                    {
                        temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
                        temp &= 0xFFFFFFFF;
                        E = D;
                        D = C;
                        C = SHA1CircularShift(30,B);
                        B = A;
                        A = temp;
                    }

                    Message_Digest1 = (Message_Digest1 + A) & 0xFFFFFFFF;
                    Message_Digest2 = (Message_Digest2 + B) & 0xFFFFFFFF;
                    Message_Digest3 = (Message_Digest3 + C) & 0xFFFFFFFF;
                    Message_Digest4 = (Message_Digest4 + D) & 0xFFFFFFFF;
                    Message_Digest5 = (Message_Digest5 + E) & 0xFFFFFFFF;
                }
            
                return new UInt32[]{Message_Digest1,Message_Digest2,Message_Digest3,Message_Digest4,Message_Digest5}; 
            } 
            public static string SHA1Array(UInt32[] input)
            { 
                StringBuilder sb = new StringBuilder();

                for(int i=0; i<input.length; i++)
                {
                    sb.Append( String.Format("{0:X8}", input[i]).ToUpper() );
                }

                return sb.ToString(); 
            }

            public static string MySHA1String(string message)
            { 
                char[] c = message.ToCharArray(); 
                byte[] b = new byte[c.Length]; 
                for(int i=0;i<c.length;i++)
                { 
                    b[i]=(byte)c[i]; 
                } 
                UInt32[] output = SHA1_Append( b );
                UInt32[] str = SHA1_Transform( output );
                return SHA1Array(str);
                
            } 
            public static string MySHA1File(string fileName)
            { 
                FileStream fs=File.Open(fileName,FileMode.Open,FileAccess.Read); 
                byte[] array=new byte[fs.Length]; 
                fs.Read(array,0,(int)fs.Length); 
                fs.Close(); 
                UInt32[] output = SHA1_Append( array );
                UInt32[] str = SHA1_Transform( output );
                return SHA1Array(str);
            } 
            #region Unit Test
            public static string Test(string message)
            { 
                return "\r\nSHA1 (\""+message+"\") = " + MySHA1String(message); 
            } 
            public static string TestSuite()
            {     
                string s = ""; 
                s+=Test(""); 
                s+=Test("a"); 
                s+=Test("abc"); 
                s+=Test("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"); 
                s+=Test("abcdefghijklmnopqrstuvwxyz"); 
                s+=Test("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"); 
                s+=Test("12345678901234567890123456789012345678901234567890123456789012345678901234567890"); 
                //        StringBuilder sb = new StringBuilder();
                //        for(int i=0; i<1000000; i++)
                //            sb.Append("a");
                //        s+=Test(sb.ToString());

                return s;     
            }

            public static void Main()
            {
                Console.WriteLine(MySHA1.TestSuite());
                Console.ReadLine();
            }
            #endregion
        } 
    }


    /******************************************************************************************
    *Author】:flyingbread
    *Date】:200712
    *Notice】:
    *1、本文为原创技术文章,首发博客园个人站点(http://flyingbread.cnblogs.com/),转载和引用请注明作者及出处。
    *2、本文必须全文转载和引用,任何组织和个人未授权不能修改任何内容,并且未授权不可用于商业。
    *3、本声明为文章一部分,转载和引用必须包括在原文中。
    ******************************************************************************************/

     


    展开全文
  • SHA1 简单介绍以及使用

    千次阅读 2019-03-19 11:38:56
    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出...

    原文出处:blog.sina.com.cn/s/blog_a42c4c6c0102woq9.html

    安全哈希算法(Secure Hash Algorithm)

         SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。 

          该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。

           数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改

    简单文字描述:

    客户端:

    在APP 与 后端服务器接口调用的时候,将需要传输的参数进行关键参数(如:String A,String B)进行SHA1加密,获取加密之后的摘要(C);然后在接口调用的时候将参数原文(A,B) 和 加密的摘要(C) 一起传输给后台服务器;

    服务器:

    后台接口接受相关参数,然后将(A,B) 在后台进行SHA1加密,获取加密摘要D,最后将D与C进行比较,如果C == D ,则 A和B 在传输过程中参数没有被窃取改变;如果 C != D,则说明A和B已经在传输过程中发生了改变,最好不要使用!

    注:需要在前后端共同定义一个加密额外秘钥,在进行SHA1加密的过程中添加进去,这样即使在客户端拦截到我们需要传输的参数,进行SHA1 加密,但是由于其不知道 秘钥,所以进行SHA1加密出来的摘要肯定和后端用相关参数、秘钥计算出来的结果不同

    关键SHA1加密代码简单举例:

     public static String createSignature(String... arr) {

            try {

                Arrays.sort(arr);

                StringBuilder content = new StringBuilder();

                for (int i = 0; i < arr.length; i++) {

                    content.append(arr[i]);

                }

                MessageDigest md = MessageDigest.getInstance("SHA-1");

                byte[] digest = md.digest(content.toString().getBytes());

                return byteToStr(digest);

            } catch (Exception e) {

            }

            return null;

        }

     。。。。。 

    展开全文
  • SHA1算法详解

    万次阅读 2018-08-25 13:30:00
    SHA1算法也是哈希算法的一种,只要理解了MD5算法,SHA1也很快就能理解。 MD5算法可以参考:MD5算法详解 MD5算法得出的MD5值长度为16个字节(8*16=128位) SHA1算法得出的SHA1值长度为20个字节(8*20=160位) 0x...

    0x00 前言

    SHA1算法也是哈希算法的一种,只要理解了MD5算法,SHA1也很快就能理解。
    MD5算法可以参考:MD5算法详解
    MD5算法得出的MD5值长度为16个字节(8*16=128位)
    SHA1算法得出的SHA1值长度为20个字节(8*20=160位)

    0x01 填充信息

    和MD5算法类似,对信息的第一步也是填充信息直至满足条件。

    填充的过程如下:
    1.先判断文件(消息)的大小(长度) mod 512 == 448 mod 512 ,就是大小(长度)对512求余等于448。(这里的512、448是“位”为单位,转成“字节”就是64、56,即mod 64 == 56 mod 64)

    2.如果大小(长度)满足 mod 512 == 448 mod 512,就在文件(消息)的末尾处添加64位(8字节)的值,值的内容是原消息的长度(以位为单位)

    3.如果大小(长度)不满足要求,就执行以下操作:
    (1)填充1个1
    (2)填充0,直到满足满足过程的第一步。

    注意:这里是以位为单位,假如是以字节为单位,第一个填充的是0x80(1000 0000),然后就填0x0
    举例:消息内容为“gnubd”,就能得到以下内容

    67 6E 62 75 64 80 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 28 

    还需要注意到的是最后原消息的长度是以大端存储的方式存到内存中的,这里与MD5的存储是有区别的。

    0x02 数据说明

    这里列举出所用到的数据

    DWORD sha1::A = 0x67452301;
    DWORD sha1::B = 0xEFCDAB89;
    DWORD sha1::C = 0x98BADCFE;
    DWORD sha1::D = 0x10325476;
    DWORD sha1::E = 0xC3D2E1F0;

    这里相对MD5算法多了4个字节。(因为SHA1值就是比MD5值多4个字节嘛)

    常量:

    DWORD sha1::k[4] = {0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6};

    MD5就有64个,这个就简单一点,4个

    0x03 处理信息

    和MD5算法类似,也是需要将消息分组,每64个字节(512位)一组,分成多个组(n个)。
    对与每一组Mi(0 < i <= n)都要做如下处理。
    将64个字节分成16组w0-w15,每组刚好4个字节
    然后生成w16-w79,生成的方法如下:

    for(DWORD i = 16;i<80;i++){
            DWORD temp = w[i-3]^w[i-8]^w[i-14]^w[i-16];
            w[i] = temp<<1 | temp>>31;
        }

    接下来就是做核心运算了。
    将a、b、c、d、e分别赋值为上面的A、B、C、D、E,作为Mi的初始值
    然后循环80次,从0-79:

            for(DWORD j = 0;j<80;j++){
                    DWORD temp;
                    DWORD temp2 = a<<5|a>>27; //循环左移5位,等下需要用到
                    switch(j/20){   
                    case 0:   //0-19步执行这里
                        temp = (b&c)|((~(b))&d);
                        temp += sha1::k[0];  //这个是常数
                        break;
                    case 1:  //20-39步执行这里
                        temp = (b^c^d);
                        temp += sha1::k[1];
                        break;
                    case 2: //40-59步执行这里
                        temp = (b&c)|(b&d)|(c&d);
                        temp += sha1::k[2];
                        break;
                    case 3: //60-79步执行这里
                        temp = (b^c^d);
                        temp += sha1::k[3];
                        break;
                    }
                    temp += temp2 + e + w[j]; //这里就是上面生成的80个分组了
                    e = d;
                    d = c;
                    c = b<<30 | b>>2; //循环左移30位
                    b = a;
                    a = temp;
                }
            A+=a;
            B+=b;
            C+=c;
            D+=d;
            E+=e;

    注意最后这里和MD5类似,也是再将abcde分别加上初始值ABCDE,作为下一个消息分组Mi+1的初始值,直到最后一个分组Mn计算完后,得出的结果就是SHA1值。
    即:
    MnAMnBMnCMnDMnE
    这里只需按直接输出就好了,不必像md5那样调整字节位置后再输出,

    展开全文
  • 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产...

    转载:https://blog.csdn.net/jiangyu1013/article/details/73290371

    安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。
    单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码,那么任何人在不知道密码的情况下都不能产生正确的散列值,从而保证了其安全性。SHA将输入流按照每块512位(64个字节)进行分块,并产生20个字节的被称为信息认证代码或信息摘要的输出。
    该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。
    通过散列算法可实现数字签名实现,数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改。
    MAC (信息认证代码)就是一个散列结果,其中部分输入信息是密码,只有知道这个密码的参与者才能再次计算和验证MAC码的合法性。

    SHA-1与MD5的比较
    因为二者均由MD4导出,SHA-1和MD5彼此很相似。相应的,他们的强度和其他特性也是相似,但还有以下几点不同:
    l 对强行攻击的安全性:最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术,产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作,而对SHA-1则是2160数量级的操作。这样,SHA-1对强行攻击有更大的强度。
    l 对密码分析的安全性:由于MD5的设计,易受密码分析的攻击,SHA-1显得不易受这样的攻击。
    l 速度:在相同的硬件上,SHA-1的运行速度比MD5慢。

    展开全文
  • SHA1算法实现及详解

    万次阅读 2017-04-26 13:55:31
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1...
  • 开发版的sha1值:就是值我们平时开发调试的时候用的sha1值。 1.1运行控制台,输入cmd 1.2 cd .android,定位到.android文件夹下 输入keytool -list -v -keystore debug.keystore, 输入密钥口令:密钥口令是android...
  • sha1加密实现

    千次阅读 2018-11-15 15:08:22
    SHA1加密:安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生...
  • 版权声明:本文为博主原创文章,未经博主允许不得转载,否则后果自负。 https://blog.csdn.net/qq_29269233/article/details/53725865 &amp;amp;amp;amp;lt;/div&amp;amp;...stylesh
  • sha1完整源代码

    2013-11-18 21:32:21
    C语言实现 计算并得出指定文件的SHA1值 的功能。
  • SHA1校验算法C语言实现

    万次阅读 2016-07-31 21:25:58
    SHA1 安全哈希算法:对于长度小于2^64位的消息(1M = 1024k,1K = 1024字节,1BYTE = 8bit 可以想象一下2的63次方位可以表示一个多大的数据文件),SHA1会产生一个160位的消息摘要。当接收到消息的时候,这个消息摘要...
  • sha1 -- 生成 sha1 散列值 》中给出了可以生成 SHA1() 函数,它应用很简单。实际上,OpenSSL 还提供了另外一套 API 用以产生 sha1 散列值,该套 API 可以生成更大文件的散列值。比如在 32 位系统下,...
  • SHA1算法C语言源代码

    热门讨论 2012-02-02 21:29:16
    SHA1算法C语言完全实现的源代码,里面另附测试代码!可直接运行的。
  • sha1算法源码c版

    千次阅读 2016-07-03 21:58:28
    sha1算法源码c版#include #include #define SHA1_ROTL(a,b) (SHA1_tmp=(a),((SHA1_tmp>>(32-b))&(0x7fffffff>>(31-b)))|(SHA1_tmp)) #define SHA1_F(B,C,D,t) ((t)?((t)?((B&C)|((~B)&D)):
  • SHA1算法原理

    万次阅读 2012-01-16 10:04:51
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1...
  • sha1算法破解

    千次阅读 2020-10-09 21:08:58
    完成关卡Cracking SHA1-Hashed Passwords https://www.mysterytwisterc3.org/en/challenges/level-ii/cracking-sha1-hashed-passwords pdf中键盘上的指纹,它提示我们密码中可能出现的字符有“QWINqwin%(*=2468”,...
  • SHA算法,即安全散列算法(Secure Hash Algorithm)是一种与MD5同源的数据加密算法,该算法经过加密专家多年来的发展和改进已日益完善,现在已成为公认的最安全的散列算法之一,并被广泛使用。 1、概述 SHA算法能...
  • SHA1算法 C语言实现

    千次阅读 2015-02-20 19:35:00
    SHA1算法 C语言实现实现了计算字符串,文件的SHA1算法来自百度百科 VS2013下成功编译运行
  • sha1:安全哈希算法(secure hash algorithm) 加密:将密码嵌入到一串序列值中,通过sha1加密后,生成一段固定长度的散列值(160位)。 解密:解密方同样将密码嵌入到同样的序列值中,同过sha1算法后会生成同样的一...
  • 需要计算sha1值,用Java写,但要Python的sha1结果。
  • MD5和SHA1算法的C++实现和使用

    千次阅读 2016-02-18 11:16:12
    MD5算法: MD5.H #ifndef MD5_H #define MD5_H typedef struct { unsigned int count[2]; unsigned int state[4]; unsigned char buffer[64]; } MD5_CTX; #define F(x,y,z) ((x & y) | (~x & z)) #defin
  • sha1 算法

    2019-09-08 13:16:28
    import hashlib sha1 = hashlib.sha1() t = '1567915904' data = "Xr0Z-javascript-obfuscation-1" + t sha1.update(data.encode('utf-8')) sha1_data = sha1.hexdigest() print(sha1_data)
  • 目前很多应用的SDK都开始需要Authorization(鉴权),然网络浩瀚,杂乱无章。终于找到了可用的方案,已为腾讯官方做了一个C#的SDK,大家放心copy。
  • sha1算法原理

    千次阅读 2015-06-10 15:32:56
    一般主流的彩虹表都在100G以上。...这是以空间换时间的典型实践, 在每一次尝试都计算的暴力破解中使用更少的计算能力和更多的储存空间,但却比简单的每个输入一条散列的翻查表使用更少的储存空间和更多的计算性能。...
  • SHA1算法告破

    千次阅读 2005-09-14 09:20:00
    SHA1算法告破 作者 Samuel Chen 2005-02-22 11:35 王小云、尹依群(音,英文名Lisa)和余鸿波(音)的小组继去年8月宣告破解MD5后,在今年农历新年还没过的2月13日,再次宣布惊人的消息——SHA1哈希算法告破!...
  • hmac-sha1算法

    2016-04-29 10:25:20
    + (NSString *)hmac_sha1:(NSString *)plaintext withKey:(NSString *)key { NSData *cKey = [self hexStringToNSData:key]; //key转换为二进制数据 const char *cData = [plaintext cStringUsingEncoding:NSUTF8S
  • Python SHA1算法

    2019-12-05 21:42:30
    SHA(Secure Hash Algorithm)基于MD5,生成的数据更长,比MD5安全,但运算速度慢 ...hashlib.sha1(str.encode("utf8")).hexdigest() # c7b16c7c468cd413352500bdc9d032dd7e972aa7 参考: https://blog.csdn.net/ruanxi...
  • SHA1算法升级SHA256更新计划

    千次阅读 2016-05-11 17:43:51
    2013年11月份的微软根证书成员计划策略更新显示,第三方认证机构自2016年1月1日起,将全面停止签发SHA1算法的SSL数字证书。 自2017年1月1日起,微软将全面停止对SHA1算法的SSL证书的支持。届时在最新版本的...
  • apk签名机制与SHA1算法

    千次阅读 2017-03-26 09:32:47
    1.SHA1算法 sha1用于数字签名,将一段消息生成一个160位的消息摘要,我们可以通过消息摘要来验证消息的完整性。 2.apk的签名机制 将apk解压,可以看到一个META-INF目录,里面就存放着Android对该apk的签名信息。 ...
  • C#SHA1算法及注意事项

    千次阅读 2018-06-07 18:48:49
    要求:使用hash算法SHA-1计算字符串的hash值,得到16进制...SHA1在线加密算法工具:http://tool.oschina.net/encrypt?type=2 多种工具 几种算法略微差别 C#算法: 方法一: /// &lt;summary&gt; ...
  • SHA1散列算法及其C++实现

    千次阅读 2018-09-19 16:21:33
    这里重点说一下SHA1算法的实现步骤与代码,由于本人水平有限,不过多讨论SHA1的数学原理以及应用场景。 SHA1简介 In cryptography, SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function which takes...

空空如也

1 2 3 4 5 ... 20
收藏数 255,465
精华内容 102,186
关键字:

sha1