SHA1 算法加密技术核心思想

最新推荐文章于 2024-09-04 00:42:56 发布
最新推荐文章于 2024-09-04 00:42:56 发布
阅读量2k 收藏 14
点赞数
分类专栏： android-技术英文文献
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guizhou_tiger_chen/article/details/107894197
版权

SHA1 算法加密技术核心思想

一、认知

1、在我们的平时生活中，经常会接触到一些密码，通过这些密码，能对我们的一些资产和隐私的东西做到保护作用，比如：

  • 古墓密码锁
  • 暗号：天王盖地虎，。。。。。
  • 美国的摩尔斯在 1844 年发明的摩尔斯电码，也叫摩斯密码
  • 银行，手机，游戏的账号密码

2、那么，在软件中又是用什么来实现的加密与解密的呢，作为一名程序猿，我们站在巨人的肩膀上前行，不用重复造轮子，但是我们也要知道轮子是怎么造的，今天我们就来了解一下加密与解密的核心思想。

二、常见的加密算法

  • 安全哈希算法（Secure Hash Algorithm）SHA-1
  • DES 数据加密标准
  • Base64
  • RSA 公钥加密算法

今天我们就通过 SHA-1 算法来了解一下加密与解密技术的核心思想：

在 APP 开发中，我们常见到 SHA-1 值是在签名文件中，如下图：
在这里插入图片描述
那么，SHA1 是什么呢，为什么 Google 要用 SHA1 作为签名文件的证书指纹呢，下面我们一起来了解SHA 算法是什么。

SHA（Secure Hash Algorithm）是安全哈希算法的简称，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用，主要适用于数字签名标准里面定义的数字签名算法。
在这里插入图片描述

上面的签名证书 SHA1 值是怎么得到的呢，下面以加密字符串 “abc” 为例，介绍 SHA1 加密的原理及流程。

1、将消息转换成二进制字符串

根据 ASCII 码表，字符对应的 ASCII 码为 ‘a’=97, ‘b’=98, ‘c’=99，再将其转换为二进制后为：
“abc” -> “97 98 99” -> “01100001 01100010 01100011”

2、对转换后的位字符串进行补位操作

Sha-1 算法标准规定，必须对消息摘要进行补位操作，即将输入的数据进行填充，使得数据长度对 512 求余的结果为 448，填充比特位的最高位补一个 1，其余的位补 0，如果在补位之前已经满足对 512 取模余数为 448，也要进行补位，在其后补一位1即可。
总之，补位是至少补一位，最多补 512 位，我们依然以 “abc” 为例，其补位过程如下：

  • 初始的信息摘要：01100001 01100010 01100011
  • 第一步补位： 01100001 01100010 01100011 1
  • … …
  • 补位最后一位： 01100001 01100010 01100011 10…0 (后面补了 423 个0)
  • 而后我们将补位操作后的信息摘要转换为十六进制，如下所示：
    61626380 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000 00000000 00000000
    00000000 00000000
3、处理附加长度值

即补长度，就是把原始数据的长度补到已经进行补位操作的消息后面，在信息摘要后面附加 64 bit 的信息，用来表示原始信息摘要的长度，在这步操作之后，信息报文便是 512 bit 的倍数。通常来说用一个 64 位的数据表示原始消息的长度，如果消息长度不大于 2^64，那么前 32 bit 就为 0，在进行附加长度值操作后，其“abc”数据报文即变成如下形式：
61626380 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000018
因为 “abc” 占 3 个字节，即 24 位 ，换算为十六进制即为 0x18。
这样，就把整个消息分成一个个 512 位的数据块，再分别处理每个数据块，得到消息摘要。

4、初始化缓存

一个 160 位 MD 缓冲区用以保存中间和最终散列函数的结果。它可以表示为 5 个 32 位的寄存器(H0,H1,H2,H3,H4)。初始化为：
H0 = 0x67452301
H1 = 0xEFCDAB89
H2 = 0x98BADCFE
H3 = 0x10325476
H4 = 0xC3D2E1F0
大端存储模式：高位数据放在低地址，低位数据放在高地址

5、计算消息摘要
  1. S 函数：循环左移操作符 Sn(x),x 是一个字，也就是 32 bit 大小的变量，n 是一个整数且 0<=n<=32。Sn(X) = (X<<n) OR (X>>32-n)
  2. 常量字 k(0)、k(1)、…k(79)
    Kt = 0x5A827999 (0 <= t <= 19)
    Kt = 0x6ED9EBA1 (20 <= t <= 39)
    Kt = 0x8F1BBCDC (40 <= t <= 59)
    Kt = 0xCA62C1D6 (60 <= t <= 79)
  3. 非线性函数
    所要用到的一系列函数，根据结果无法反推：
    Ft(b,c,d) ((b&c)|((~b)&d)) (0 <= t <= 19)
    Ft(b,c,d) (bcd) (20 <= t <= 39)
    Ft(b,c,d) ((b&c)|(b&d)|(c&d)) (40 <= t <= 59)
    Ft(b,c,d) (bcd) (60 <= t <= 79)
  4. 开始计算摘要
  • 计算需要一个缓冲区，由 5 个 32 位的字组成，还需要一个 80 个 32 位字的缓冲区。第一个 5 个字的缓冲区被标识为 A，B，C，D，E。80 个字的缓冲区被标识为 W0, W1,…, W79
  • 另外还需要一个一个字的TEMP缓冲区。
  • 为了产生消息摘要，在补好位的数据中前 16 个字的数据块 M1, M2,…, Mn
  • 会依次进行处理，处理每个数据块 Mi 包含 80 个步骤。
  • 现在开始处理 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.
6、同类算法

SHA1 SHA224 SHA256 SHA384 SHA512
MD5 HmacMD5
HmacSHA1 HmacSHA224 HmacSHA256 HmacSHA384 HmacSHA512 PBKDF2

注意：只要是哈希函数，就存在碰撞，所谓碰撞的意思是，有两个不同的数据，他们的哈希值相同（SHA1 值相同）

三、实战

废话不多说，实践才是检验真理的唯一标准，下面我们就通过代码来实现这一过程，看看结果如何：

package com.example.sha1;

import org.junit.Test;

/**
 * Created by author 2020/08/09
 */

public class SHA1 {
    //1.准备工作
    public static final int[] abcde = {
            0x67452301,
            0xEFCDAB89,
            0x98BADCFE,
            0x10325476,
            0xC3D2E1F0
    };
    //摘要数据存储用的数组（存放密文的)  20个字节*8=160；
    public static int[] h=new int[5];
    //计算过程中需要用到的临时数据存储数组
    public static int[] m=new int[80];

    //定义辅助方法

    //将字符转换为十六进制字符串
    public static String byteToHexString(byte b){//97
        char[] digit={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        char[] ob=new char[2];
        ob[0]=digit[(b>>>4)&0x0F];//9
        ob[1]=digit[b&0x0f];//7
        String s=new String(ob);//"97"
        return s;
    }
    //将字节数组转换为十六进制字符串
    public static String byteArrayToHexString(byte[] byteArray){
        String strDigest="";
        for(int i=0;i<byteArray.length;i++){
            strDigest+=byteToHexString(byteArray[i]);
        }
        return strDigest;
    }

    //4字节数组转换为int  i个byte合成到byteData[]中
    public static int byteArrayToInt(byte[] byteData,int i){
        //0a 0b 0c 0d  24       16       8       0
        //         0a000000  or  0b0000  or   0c00  or   0d
        //            0a0b0c0d
        return ((byteData[i]&0xff)<<24)|((byteData[i+1]&0xff)<<16)|((byteData[i+2]&0xff)<<8)|(byteData[i+3]&0xff);
    }
    //整数转换为4字节数组   int分解到byte数组中
    public static void intToByteArray(int intValue,byte[] byteData,int i){
        byteData[i]=(byte)((intValue>>>24)&0xff);
        byteData[i+1]=(byte)((intValue>>>16)&0xff);
        byteData[i+2]=(byte)((intValue>>>8)&0xff);
        byteData[i+3]=(byte)((intValue&0xff));
    }
    /*
    Ft(b,c,d)  ((b&c)|((~b)&d))    (0 <= t <= 19)
    Ft(b,c,d) (b^c^d)             (20 <= t <= 39)
    Ft(b,c,d) ((b&c)|(b&d)|(c&d))  (40 <= t <= 59)
    Ft(b,c,d) (b^c^d)               (60 <= t <= 79)
     */
    public static int f1(int x,int y,int z){
        return (x&y)|(~x&z);
    }
    public static int f2(int x,int y,int z){
        return x^y^z;
    }
    public static int f3(int x,int y,int z){
        return (x&y)|(x&z)|(y&z);
    }
    public static int f4(int x,int y,int z){
        return x^y^z;
    }

    //开始逻辑
    //进行对原数据的补位
    public static byte[] byteArrayFormatData(byte[] byteData){
        //补0的个数
        int fill=0;
        //补位后的总位数,64的倍数
        int size=0;
        //原数据的长度
        int srcLength=byteData.length;
        //对64求余数   n%512      56数据    8长度   53
        int m=srcLength%64;
        if(m<56){
            fill=55-m;
            size=srcLength-m+64;//数据只有一块
        }else if(m==56){
            fill=63;
            size=srcLength+8+64;
        }else{
            fill=63-m+56;//   58    60+56  116-64=52   55-52=3
            size=(srcLength+64)-m+64;
        }
        //补位后生成的新数组的内容
        byte[] newbyte=new byte[size];
        System.arraycopy(byteData,0,newbyte,0,srcLength);

        //补1
        int startLocation=srcLength;
        newbyte[startLocation++]=(byte)0x80;
        //补0
        for(int i=0;i<fill;i++){
            newbyte[startLocation++]=(byte)0x00;
        }
        //处理长度的位置  字节*8=?位   512-468=64位，用来存放长度
        long n=(long)srcLength*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));
        newbyte[startLocation++]=h1;
        newbyte[startLocation++]=h2;
        newbyte[startLocation++]=h3;
        newbyte[startLocation++]=h4;
        newbyte[startLocation++]=h5;
        newbyte[startLocation++]=h6;
        newbyte[startLocation++]=h7;
        newbyte[startLocation++]=h8;

        return newbyte;
    }
    //开始计算密文 算摘要
    public static int process_input_bytes(byte[] byteData){
        System.arraycopy(abcde,0,h,0,abcde.length);
        //格式化数据
        byte[] newbyte=byteArrayFormatData(byteData);
        //计算有多少个大块
        int mCount=newbyte.length/64;
        //循环计算每一块的内容
        for(int pos=0;pos<mCount;pos++){
            //对每一块都进行加密计算
            //(1). 将 Mi 分成 16 个字 W0, W1, ... , W15,  W0 是最左边的字
            for(int i=0;i<16;i++){
                m[i]=byteArrayToInt(newbyte,(pos*64)+(i*4));
            }
            //计算
            encrypt();
        }

        return 20;
    }
    //n是一个整数且0<=n<=32。Sn(X) = (X<<n)OR(X>>(32-n))
    public static int s(int x,int i){
        return (x<<i)|x>>>(32-i);
    }
    public static void encrypt(){
        //(2). 对于 t = 16 到 79 令
        // Wt = S1(Wt-3 XOR Wt-8 XOR Wt- 14 XOR Wt-16).
        for(int t=16;t<=79;t++){
            m[t]=s(m[t-3]^m[t-8]^m[t-14]^m[t-16],1);
        }
        //3.令 A = H0, B = H1, C = H2, D = H3, E = H4.
        int[] tempabcde=new int[5];
        for(int i=0;i<tempabcde.length;i++){
            tempabcde[i]=h[i];
        }
        //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;
        //一共有80次操作
        //Kt = 0x5A827999  (0 <= t <= 19)
//        Kt = 0x6ED9EBA1 (20 <= t <= 39)
//        Kt = 0x8F1BBCDC (40 <= t <= 59)
//        Kt = 0xCA62C1D6 (60 <= t <= 79)
        for(int i=0;i<=19;i++){
            int temp=s(tempabcde[0],5)
                    +f1(tempabcde[1],tempabcde[2],tempabcde[3])
                    +tempabcde[4]
                    +m[i]+0x5A827999;
            tempabcde[4]=tempabcde[3];
            tempabcde[3]=tempabcde[2];
            tempabcde[2]=s(tempabcde[1],30);
            tempabcde[1]=tempabcde[0];
            tempabcde[0]=temp;
        }
        for(int i=20;i<=39;i++){
            int temp=s(tempabcde[0],5)
                    +f2(tempabcde[1],tempabcde[2],tempabcde[3])
                    +tempabcde[4]
                    +m[i]+0x6ED9EBA1;
            tempabcde[4]=tempabcde[3];
            tempabcde[3]=tempabcde[2];
            tempabcde[2]=s(tempabcde[1],30);
            tempabcde[1]=tempabcde[0];
            tempabcde[0]=temp;
        }
        for(int i=40;i<=59;i++){
            int temp=s(tempabcde[0],5)
                    +f3(tempabcde[1],tempabcde[2],tempabcde[3])
                    +tempabcde[4]
                    +m[i]+0x8F1BBCDC;
            tempabcde[4]=tempabcde[3];
            tempabcde[3]=tempabcde[2];
            tempabcde[2]=s(tempabcde[1],30);
            tempabcde[1]=tempabcde[0];
            tempabcde[0]=temp;
        }
        for(int i=60;i<=79;i++){
            int temp=s(tempabcde[0],5)
                    +f4(tempabcde[1],tempabcde[2],tempabcde[3])
                    +tempabcde[4]
                    +m[i]+0xCA62C1D6;
            tempabcde[4]=tempabcde[3];
            tempabcde[3]=tempabcde[2];
            tempabcde[2]=s(tempabcde[1],30);
            tempabcde[1]=tempabcde[0];
            tempabcde[0]=temp;
        }
        //5.令 H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
        for(int i=0;i<tempabcde.length;i++){
            h[i]=h[i]+tempabcde[i];
        }
        //完成了一次操作
        //清除之前的内容，开始下一个块的计算
        for(int i=0;i<m.length;i++){
            m[i]=0;
        }

    }
    //把已经算好的数据提供一个接口进行输入和输出
    public static byte[] getDigestOfBytes(byte[] byteData){
        process_input_bytes(byteData);
        byte[] digest=new byte[20];
        for(int i=0;i<h.length;i++){
            intToByteArray(h[i],digest,i*4);
        }
        return digest;
    }
    public static String getDigestOfString(byte[] byteData){
        return byteArrayToHexString(getDigestOfBytes(byteData));
    }

    @Test
    public void test(){
        //ad93ae3d06a9114b3cbb33b6433ad546f0aa9f42
        //378940973d2f16265b7a7f2a78a253c45d953b0b
        String param="abc";
        System.out.println("加密前:"+param);
        String digest=getDigestOfString(param.getBytes());
        System.out.println("加密后的结果："+digest);
    }

}

运行结果如下：
在这里插入图片描述
大功告成！

天黑戴墨镜
关注
专栏目录
sha1 加密解密
11-29
sha1加密解密的这个不错的，经过测试的，很好的
Sha1算法实现流程（基于OpenSSL源码）
qq_38933606的博客
04-28 2709
SHA-1（Secure Hash Algorithm 1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。
SHA-1【安全散列算法】
最新发布
IT_WEH_coder的博客
09-04 512
SHA-1算法是由美国国家安全局（NSA）设计的，于1995年发布。它是MD4、MD5的后继者，MD4、MD5是具有相似功能的算法。SHA-1算法在设计上旨在提供安全性，并抵抗弱碰撞（找到两个具有相同哈希值的不同输入）和强碰撞（找到具有相同哈希值的任意两个输入）的能力。然而，随着时间的推移和计算能力的提升，SHA-1算法被发现存在一些漏洞，例如，2017年研究人员成功实现了SHA-1的碰撞攻击。因此，现在不推荐使用SHA-1算法进行敏感数据的加密，而是使用更强大的安全散列算法，例如SHA-256、SHA-3
SHA1详解
xcxhzjl的博客
02-16 4426
哈希（SHA1）算法详解
常用算法 之三 详解 SHA1 实现（基于算法的官方原文档）及源码详细注释
技术干货
12-09 1万+
写在前面   在之前的工作中，用到了CRC16、MD5 和 SHA1 算法，主要用来校验下发的文件。网上关于这些算法的文章铺天盖地，以下内容仅仅是自己在学习时候的一个记录，一些套话来自于互联网。下面先来看看 SHA1。    以下算法分析基于 RFC 3174。 Request For Comments (RFC），所有关于Internet 的正式标准都是以RFC(Request for Co...
信息摘要算法之二：SHA1算法分析及实现
weixin_30436101的博客
01-14 1555
SHA算法，即安全散列算法（Secure Hash Algorithm）是一种与MD5同源的数据加密算法，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。 1、概述 SHA算法能计算出一个数位信息所对应到的，长度固定的字串，又称信息摘要。而且如果输入信息有任何的不同，输出的对应摘要不同的机率非常高。因此SHA算法也是FIPS所认证的五种安全杂...
加密算法之SHA(SHA1、SHA256)
热门推荐
jwang的博客
08-26 2万+
前言 本章讲解典型的加密算法SHA(SHA1、SHA256) 方法 1、概念 安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。 SHA1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安...
HMAC-SHA1算法
09-11
该协议利用了SHA1哈希算法的强大功能，结合密钥管理技术，实现了对数据完整性和真实性的保护。 **重要性：** - **数据完整性：** 防止数据在传输过程中被恶意修改。 - **数据来源验证：** 确认数据确实来自预期的...
c++ 版本的HMAC SHA1
02-13
在C++中实现HMAC SHA1，我们需要包含相关的头文件，如`#include <openssl/hmac.h>`和`#include <openssl/sha.h>`，这些是OpenSSL库提供的，它提供了对各种加密和哈希算法的支持。接着，我们需要定义函数来处理密钥...
Python实现的文本简单可逆加密算法示例
09-21
本文介绍的加密算法非常简单，核心思想是通过增加一个整数密钥来改变原文中每个字符的ASCII值，从而实现加密的目的。解密时则执行相反的操作，即减去相同的密钥值，还原原文。 **加密过程：** 1. 读取输入文件。 2...
300种加密解密算法_300种加密解密算法_300_
10-03
8. **数字签名**：如RSA签名，利用非对称加密技术，可以实现数据的不可否认性和完整性。 9. **伪随机数生成器**：在加密算法中，高质量的伪随机数是至关重要的，如线性同余法、Mersenne Twister等。 10. **密码...
常用加密算法AES、RSA、DES、MD5、TEA、SHA1、SHA256的C语言源码
08-16
在IT领域，加密技术是确保数据安全的重要工具。本文将详细介绍标题中提到的几种加密算法：AES、RSA、DES、MD5、TEA以及SHA1和SHA256，并结合C语言源码来阐述它们的工作原理及应用。 1. **AES（高级加密标准）** ...
SHA1算法详解
分享各种技术
01-15 7011
SHA1算法详解 SHA1算法作为摘要算法的一种，被使用于各种签名、摘要等场景，本章我们详细分析下SHA1算法细节； 术语定义 word：32bit的String，可以表示为8个16进制的序列，例如A103FE23； integer：表示0-2^32-1之间的数字； block：表示512bit的String，一个block可以表示为16个word的序列（数组）； 消息填充规则 对于待摘要的消息M，先填充一个bit 1，然后填充N个bit 0，最后填充64b.....
SHA1算法
纸房子
02-28 3809
SHA1算法
安全哈希算法SHA1
ljheee的博客
12-11 6657
安全哈希算法（Secure Hash Algorithm）SHA1主要适用于数字签名标准 （Digital Signature Standard DSS）里面定义的数字签名算法（Digital SignatureAlgorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生
SHA1 简单介绍以及使用
chelen_jak的专栏
03-19 1万+
原文出处：blog.sina.com.cn/s/blog_a42c4c6c0102woq9.html 安全哈希算法（Secure Hash Algorithm） SHA-1是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信...
安全算法—SHA-1算法
enjoycsdn_YW的博客
07-11 4618
1、什么是SHA-1?SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。SHA-1的特性有以下两点特性，同时也是SHA算法所拥有的共同特性：...
SHA1散列算法及其C++实现
FlushHip
09-19 9374
这里重点说一下SHA1算法的实现步骤与代码，由于本人水平有限，不过多讨论SHA1的数学原理以及应用场景。 SHA1简介 In cryptography, SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function which takes an input and produces a 160-bit (20-byte) has...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值