单项散列算法：SHA

最新推荐文章于 2023-03-23 19:09:58 发布
最新推荐文章于 2023-03-23 19:09:58 发布
阅读量813 收藏 2
点赞数
文章标签： SHA 算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37431937/article/details/90322254
版权

单项散列算法_SHA

SHA-1是一种能够根据上限为2^64位的消息计算出160比特的散列值的单向散列函数，它的分组及对数据的填充方式与MD5是一样的，512位为1组，填充数据时先填1，后面填0，一直填满448位，最后64位表示原始数据长度。

SHA-1算法原理与实现

1.填充1

以abcde这条长度为六的消息进行填充。

ABCDEF=41 42 43 44 45 46 ，在消息末尾加

0100 00010100 0010 0100 00110100 0100   0100 0101 0100 01101

2.填充0

在消息末尾继续添加0，直到消息的长度达到512比特的整数倍，但是最后一个最后64位用来保存原始数据的长度。如：ABCDEF减掉最后的保存长度64位，填充0，直到消息长度为填充满448位。

0100 00010100 0010 0100 00110100 0100   0100 0101 0100 011010000000



-----448位
：：：：：：：
00000000000000000000000000000000000000000000000000000000

3.最末位添加原始数据长度

0100 00010100 0010 0100 00110100 0100   0100 0101 0100 011010000000



-----448位
：：：：：：：
00000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000110000--标记原始长度64位。

此时数据长度为512位，符合512整数倍。

完成数据的填充后，我们将以输入分组为单位进行下面的处理，这一步要对每个输入分组计算80个32位的值(W0~W79)，首先将输入分组的512位分为32位*16组，并将它们命名为W0~W15，然后剩下W16~W79的计算，方法如下：

 for (t = 0; t < 16; t++)
    {
        W[t] = ((unsigned)Message_Block[t * 4]) << 24;
        W[t] |= ((unsigned)Message_Block[t * 4 + 1]) << 16;
        W[t] |= ((unsigned)Message_Block[t * 4 + 2]) << 8;
        W[t] |= ((unsigned)Message_Block[t * 4 + 3]);
    }
    for (t = 16; t < 80; t++)
    {
        W[t] = CircularShift(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);            //W16 = (W0 ^ W2 ^ W8 ^ W13) 循环左移1位，即：Wt = (Wt - 16 ^ Wt - 14 ^ Wt - 8 ^ Wt - 3) 循环左移1位完成后，W0~W79的数据就生成完成了。
    }

4. SHA-1： 分组处理

接下来，对输入分组进行80个步骤的处理，目的是根据输入分组的信息来改变内部状态。

在对分组处理时，SHA-1中常数Kt及Ht：

其他初始化数据：SHA-1，SHA-256,SHA-384,和SHA-512初始化数据

5.算法逻辑实现

SHA-1使用了f0, f1, .... f79这样的一个逻辑函数序列，每一个ft对3个32位双字B,C,D进行操作，产生一个32位双字的输出。

SHA-1算法从f0,f1。。。。f79,逻辑函数序列，每一个ft(0<t<79)对3个32位双字B C D进行操作，产生一个32位双字的输出，ft(B,C,D)定义如下：

w0~w79的处理


#define F0(x,y,z) (z^(x&(Y^z)))
#define F1(x,y,z) (z^Y^z)
#define F2(x,y,z) ((x&y)|(z&(x^y)))
#define F3(x,y,z) (x^Y^z)
for (t = 0; t < 20; t++)
{
    temp = CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
    temp &= 0xFFFFFFFF;
    E = D;
    D = C;
    C = CircularShift(30, B);
    B = A;
    A = temp;
}
for (t = 20; t < 40; t++)
{
    temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1];
    temp &= 0xFFFFFFFF;
    E = D;
    D = C;
    C = CircularShift(30, B);
    B = A;
    A = temp;
}
   for (t = 40; t < 60; t++)
{
    temp = CircularShift(5, A) +
        ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
    temp &= 0xFFFFFFFF;
    E = D;
    D = C;
    C = CircularShift(30, B);
    B = A;
    A = temp;
}
for (t = 60; t < 80; t++)
{
    temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3];
    temp &= 0xFFFFFFFF;
    E = D;
    D = C;
    C = CircularShift(30, B);
    B = A;
    A = temp;

}
获取摘要：

在一个步骤完成之后，缓冲区a,b,c,d的内容会被分别复制到b,c,d,e中(其中b要循环左移30位之后再复制)，而缓冲区e的内容则会与其他缓冲区的内容以及Wt、Kt相加之后再复制到缓冲区a中。

最终将循环80个步骤的值与原始相加，即更新原始的5个H常量，得到最终160位的消息摘要。

    H[0] = (H[0] + A) & 0xFFFFFFFF;
    H[1] = (H[1] + B) & 0xFFFFFFFF;
    H[2] = (H[2] + C) & 0xFFFFFFFF;
    H[3] = (H[3] + D) & 0xFFFFFFFF;
    H[4] = (H[4] + E) & 0xFFFFFFFF

代码实现：

编译环境VS2017：

.h
#pragma once
class SHA1
{
public:
    SHA1();
    virtual ~SHA1();
    bool SHA_GO(const char *lpData_Input, char *lpSHACode_Output);
private:
    unsigned int H[5];              
    unsigned int Length_Low;                
    unsigned int Length_High;           
    unsigned char Message_Block[64];    
    int Message_Block_Index;                
private:
    void SHAInit();
    void AddDataLen(int nDealDataLen);
	 // 处理消息的下一个512位
	 void ProcessMessageBlock();
	// 将当前消息块填充为512位
	 void PadMessage();
	 // 执行循环左移位操作
	 inline unsigned CircularShift(int bits, unsigned word);
};
//******************************************
.cpp
#include "stdafx.h"
#include "SHA1.h"
#include <string.h>
#pragma warning(disable:4996)
SHA1::SHA1()
{
    SHAInit();
}
SHA1::~SHA1()
{
}
void SHA1::SHAInit()
{
	Length_Low = 0;
	Length_High = 0;
	Message_Block_Index = 0;
	H[0] = 0x67452301;
	H[1] = 0xEFCDAB89;
	H[2] = 0x98BADCFE;
	H[3] = 0x10325476;
	H[4] = 0xC3D2E1F0;
}
//SHA计算
bool SHA1::SHA_GO(const char *lpData_Input, char *lpSHACode_Output)
{
    if (lpData_Input == NULL || lpSHACode_Output == NULL)
        return false;
    SHAInit();
    // One times analyse 64Bytes, 512 bits.
    int nInputLen = strlen(lpData_Input);
    int nDealDataLen = 0;                           //  计算输入长度
    for (int pos = 0; pos <= nInputLen; pos += 64)
    {
        if (nInputLen - pos >= 64)
        {
            nDealDataLen = 64;                      
            memset(Message_Block, 0, sizeof(Message_Block));
            memcpy(Message_Block, lpData_Input + pos, nDealDataLen);
            AddDataLen(nDealDataLen);
            ProcessMessageBlock();
            AddDataLen(0);
        }
        else
        {
            nDealDataLen = nInputLen - pos;     
            memset(Message_Block, 0, sizeof(Message_Block));
            memcpy(Message_Block, lpData_Input + pos, nDealDataLen);
            AddDataLen(nDealDataLen);
            PadMessage();
        }
    }
    // copy result to output
    for (int i = 0; i < 5; i++)
    {
        sprintf(&(lpSHACode_Output[8 * i]), "%08x", H[i]);
    }
    return true;
}
void SHA1::AddDataLen(int nDealDataLen)
{
    Message_Block_Index = nDealDataLen;
    if ((Length_Low += ((unsigned int)nDealDataLen << 3)) < ((unsigned int)nDealDataLen << 3))
    {
        Length_High++;
    }
    Length_High += ((unsigned int)nDealDataLen >> 29);
}
//  此函数将处理消息的下一个512位 存储在 Message_Block 阵列中。
void SHA1::ProcessMessageBlock()
{
    const unsigned K[] = {              // Constants defined for SHA-1
        0x5A827999,
        0x6ED9EBA1,
        0x8F1BBCDC,
        0xCA62C1D6
    };
    int         t;                          // Loop counter
    unsigned    temp;                       // Temporary word value
    unsigned    W[80];                      // Word sequence
    unsigned    A, B, C, D, E;              // Word buffers
    for (t = 0; t < 16; t++)
    {
        W[t] = ((unsigned)Message_Block[t * 4]) << 24;
        W[t] |= ((unsigned)Message_Block[t * 4 + 1]) << 16;
        W[t] |= ((unsigned)Message_Block[t * 4 + 2]) << 8;
        W[t] |= ((unsigned)Message_Block[t * 4 + 3]);
    }
    for (t = 16; t < 80; t++)
    {
        W[t] = CircularShift(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
    }
    A = H[0];
    B = H[1];
    C = H[2];
    D = H[3];
    E = H[4];
    for (t = 0; t < 20; t++)
    {
        temp = CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30, B);
        B = A;
        A = temp;
    }
    for (t = 20; t < 40; t++)
    {
        temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30, B);
        B = A;
        A = temp;
    }
    for (t = 40; t < 60; t++)
    {
        temp = CircularShift(5, A) +
            ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30, B);
        B = A;
        A = temp;
    }
    for (t = 60; t < 80; t++)
    {
        temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30, B);
        B = A;
        A = temp;
    }
    H[0] = (H[0] + A) & 0xFFFFFFFF;
    H[1] = (H[1] + B) & 0xFFFFFFFF;
    H[2] = (H[2] + C) & 0xFFFFFFFF;
    H[3] = (H[3] + D) & 0xFFFFFFFF;
    H[4] = (H[4] + E) & 0xFFFFFFFF;
}
void SHA1::PadMessage()
{
    /*
    检查当前消息块太小，是否大于512
    如果大于初始填充位和长度。如果大于将增加填充快大小512位倍数，处理它，然后继续填充到第二块。 
    */
    if (Message_Block_Index > 55)
    {
        Message_Block[Message_Block_Index++] = 0x80;
        while (Message_Block_Index < 64)
        {
            Message_Block[Message_Block_Index++] = 0;
        }
        ProcessMessageBlock();
        while (Message_Block_Index < 56)
        {
            Message_Block[Message_Block_Index++] = 0;
        }
    }
    else
    {
        Message_Block[Message_Block_Index++] = 0x80;
        while (Message_Block_Index < 56)
        {
            Message_Block[Message_Block_Index++] = 0;
        }
    }
    Message_Block[56] = (Length_High >> 24) & 0xFF;
    Message_Block[57] = (Length_High >> 16) & 0xFF;
    Message_Block[58] = (Length_High >> 8) & 0xFF;
    Message_Block[59] = (Length_High) & 0xFF;
    Message_Block[60] = (Length_Low >> 24) & 0xFF;
    Message_Block[61] = (Length_Low >> 16) & 0xFF;
    Message_Block[62] = (Length_Low >> 8) & 0xFF;
    Message_Block[63] = (Length_Low) & 0xFF;
    ProcessMessageBlock();
}
unsigned SHA1::CircularShift(int bits, unsigned word)
{
    return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32 - bits));
}

调用实例：

// SHA算法实现.cpp: 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "SHA1.h"
#include <string.h>
int main()
{
    char Strng[]="12343444dasfdfaeda3rfsda43fsdfaew4thhgsdt4";
    char Array[512];
    SHA1 sha1_algorithm;
    sha1_algorithm.SHA_GO(Strng,Array );
    printf_s("%s",Array);
    getchar();
    return 0;
}

ANALYZER通过对ProcessMessageBlock函数检测SHA算法特殊操作，以及初始K数组中常数判断算法。

 

 

 

 

     

 

 


 

 

 

 

PwnGuo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
散列（hash）算法与应用
Hacah的博客
11-23 1453
散列（hash）算法与应用目录散列（hash）算法与应用一、散列（hash）算法1. 概念2.特点3.散列算法应用二、文章摘要算法（Message Digest）1.概念2.MD5算法分组操作三、安全散列（Secure Hash Algorithm）1.概念2.分类四、SHA-1与MD5之间的异同相同点：不同点： 散列（hash）算法与应用 最近在准备期末的考试，复习然后顺便写下来记录笔记。 本笔记记录的是SHA和MD算法。 一、散列（hash）算法 1. 概念 把任意长度的输入通过单向散列函数H（）计
SHA（安全散列算法）
02-26
安全散列算法 SHA (即Secu re Hash AIgorlthm 安全散列算法)是一种 常用的数据加密算法．它由美国国家标准与技术局(NatlonaI InstItute of Standards and TechnoIogy)于1 993年作为联邦信息 处理标准公布(即第一代SHA算法——SHA一0)。在1 995年和 2002年．其改进版本SHA～ SHA一2也分别正式公布(SHA- 1和SHA一2具有比SHA一0更高的安全性)。SHA算法与MD5算 法的设计原理类似．同样也按2blt数据块为单位来处理输入 但它能产生1 60bIt的消息摘要．具有比MD 5更强的安全性 (MD5为1 28bit)。
SHA算法
weixin_30578677的博客
07-01 931
安全Hash函数（SHA）是使用最广泛的Hash函数。由于其他曾被广泛使用的Hash函数都被发现存在安全隐患，从2005年至今，SHA或许是仅存的Hash算法标准。 SHA发展史 　　SHA由美国标准与技术研究所（NIST）设计并于1993年发表，该版本称为SHA-0，由于很快被发现存在安全隐患，1995年发布了SHA-1。 　　2002年，NIST分别发布了SHA-256、SHA-384、...
PB外部函数扩展 RSA SHA
08-31
1 以非图片方式在Datawindow中显示QR二维码 2 GBK和UTF 8编码相互转换 3 加密解密 RSA加密解密 4 取汉字拼音首字母 5 文件哈希算法：MD5 SHA1 RIPEMD160 SHA256 Tiger SHA512 Whirlpool CRC32 6 字符串哈希算法：MD5 SHA1 RIPEMD160 SHA256 Tiger SHA512 Whirlpool CRC32 7 URI编码解码 8 Base64编码解码 里面包含pb的调用demo">1 以非图片方式在Datawindow中显示QR二维码 2 GBK和UTF 8编码相互转换 3 加密解密 RSA加密解密 4 取汉字拼音首字母 5 文件哈希算法：MD5 SHA1 RIPEMD160 SHA256 Tiger SHA512 Whirlpool CRC32 6 字符串哈希算法：MD5 SHA1 RIPEMD160 SHA256
【数字摘要算法】SHA算法（sha-0/sha-1/sha-2）
10-24 4870
SHA-1 　　SHA 家族 　　SHA (Secure Hash Algorithm，译作安全散列算法) 是美国国家安全局 (NSA) 设计，美国国家标准与技术研究院 (NIST) 发布的一系列密码散列函数。正式名称为 SHA 的家族第一个成员发布于 1993年。然而现在的人们给它取了一个非正式的名称 SHA-0 以避免与它的后继者混淆。两年之后， SHA-1，第一个 SHA 的
单向散列函数SHA-1算法分析与实现
Apollon_krj的博客
07-19 4794
1、简介：SHA，全程安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard，DSS）里面定义的数字签名算法（Digital Signature Algorithm，DSA）。也就是说通常是用来对于信息的完整性进行验证的。而由于SHA的不可逆性，或者说是SHA中函数的不可逆性，该算法只能用于加密，不能用于解密。而加密的过
哈希函数之SHA家族
Tech in Pieces
01-02 1173
我们之前就听说过这个家族，但是并不是很熟悉。今天就来仔细看一下。 SHA，全称：Secure Hash Algorithm. 是一个密码散列函数家族，他能把任意长度的信息，投影成长度固定的字符串。虽然并不是完美的哈希函数（也并不存在完美的哈希函数一说）。 本算法是由美国国家安全局（NSA）所设计，并由美国国家标准与技术研究院（NIST）发布，是美国的政府标准。 其发展历程如下： SHA-0：1993年发布，当时称做安全散列标准（Secure Hash Standard），发布之后很快就被NSA撤回，是SHA
SHA1算法实现及详解
热门推荐
Y_peak的博客
05-18 2万+
SHA1算法实现及详解 SHA1算法详解 SHA1算法是Hash算法的一种。SHA1算法的最大输入长度小于2^64比特的消息，输入消息（**明文**）以512比特的分组为单位处理，输出160比特的消息摘要（**密文**） 源代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #pragma warning(disable:4996) /*定义用到的常量*/ unsigned int A = 0x6
shal 哈希算法软件实现！
谢文浩博客
03-23 300
若数据本身已经满足上述长度要求，让需要进行填充（例如，若数据长度为448位，则仍需要填充512位使其长度变为960，原因最后一组填充需要在数据后附加一个1（8位）以及填充前数据的长度（64位），因此最后一组长度最长为440（输入为字符串格式下）），因此填充位数在1~512之间。SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。
sha1散列算法详解示例
catwan的专栏
08-08 2875
//python3 res = '123456' print(hashlib.sha1(res.encode('utf-8')).hexdigest()) //输出： 7c4a8d09ca3762af61e59520943dc26494f8941b SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。 对于任意长度的明文，SHA1首先对其进行分组，使得每一组的长度为512位，然后对这些明文分组反复重复处理。对于每个明文分组的摘要生成过程.
一文搞懂单向散列函数
A_991128a的博客
02-15 482
单向散列函数（one-way hash function）是指对不同的输入值，通过单向散列函数进行计算，得到固定长度的输出值。这个输入值称为消息（message），输出值称为散列值单向散列函数也被称为消息摘要函数哈希函数或者杂凑函数。输入的消息也称为原像输出的散列值也称为消息摘要（message digest）或者指纹（fingerprint），相当于该消息的身份证。MD5SHA-1SHA-2和SHA-3。
散列算法（C++）
11-01
散列算法 #include #include #include #include enum{ NPREF=2, NHASH=4093, MAXGEN=10000 }; typedef struct State State; typedef struct Suffix Suffix; struct State{ char *pref[NPREF]; Suffix *...
单项服务：渲染产品图片
02-15
单项服务 此组件使用缩放功能为产品渲染图像 入门 npm install -g webpack npm install 运行测试 npm run test 在本地运行服务器和客户端 npm start npm run build 在端口3001上访问您的本地主机！ 将/？id =附加1...
单项模板：vue2简单模板
02-10
简单项目设置yarn install编译和热重装以进行开发yarn run serve编译并最小化生产yarn run build运行测试yarn run test整理和修复文件yarn run lint自定义配置请参阅。
knn算法详解（附练习代码）
12-22
KNN算法 KNN算法是一个用于对数据样本进行分类预测的算法 KNN算法就是根据样本之间的距离，来对新的样本来进行分类 计算过程：将新的样本点，与历史样本点中的每一个样本点进行距离的计算 取前k个距离最近的样本点的...
评估3：单项评估
02-12
评估3：单项评估
自动驾驶-决策规划算法七：B样条曲线(C++).pdf
最新发布
04-17
自动驾驶-决策规划算法七：B样条曲线(C++)
2024-2030全球与中国1,2-环氧丁烷市场现状及未来发展趋势.docx
04-17
2024-2030全球与中国1,2-环氧丁烷市场现状及未来发展趋势
2024-2030全球与中国胚胎孵化延时系统市场现状及未来发展趋势.docx
04-17
2024-2030全球与中国胚胎孵化延时系统市场现状及未来发展趋势
怎天根据各单项排序来综合得分 算法
07-22
假设你有三个单项：A、B、C，并且分别有对应的得分和权重。 - 单项 A 的得分为 80，权重为 0.3 - 单项 B 的得分为 90，权重为 0.5 - 单项 C 的得分为 70，权重为 0.2 2. 将每个单项的得分乘以对应的权重，得到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值