SHA1hash算法C语言实现

最新推荐文章于 2024-05-13 02:38:57 发布
置顶 最新推荐文章于 2024-05-13 02:38:57 发布
阅读量6.3k 收藏 88
点赞数 9
分类专栏： 密码学 sha1 文章标签： c语言 密码学 hash sha1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mlynb/article/details/110570191
版权

SHA的简介

美国国家标准技术研究所NIST于1993年开发的另一个散
列算法称为SHA。两年之后，这个算法被修改为了今天广泛
使用的形式。修改后的版本是SHA-1，是数字签名标准中要
求使用的算法。
SHA接受任何有限长度的输入消息，并产生长度为160比
特的Hash值（MD5仅仅生成128位的摘要），因此抗穷举性
更好。SHA-1设计时基于和MD4相同原理，它有5个参与运
算的32位寄存器字，消息分组和填充方式与MD5相同，主循
环也同样是4轮，但每轮进行20次操作，非线性运算、移位和
加法运算也与MD5类似，但非线性函数、加法常数和循环左
移操作的设计有一些区别。

SHA-1哈希值的生成过程

在这里插入图片描述

SHA-1对单个512位分组的处理过程

在这里插入图片描述

SHA-1生成字Wt的方法

在这里插入图片描述

SHA-1的基本操作

在这里插入图片描述

C语言实现

#include <stdio.h>
#include <string.h>
#include "sha1.h"

#define S(x,n)	(((x)<<n)|(x)>>(32-n))	//SHA定义S函数为循环左移

static unsigned long h[5];
static unsigned long m[16];
static unsigned long w[80];

//补位(余数=448)+补长度(64位)=512位M
static void sha1_pad( char *input, int len)
{
	int i;
	int n;

	for(i=0;i<16;i++)
	{
		m[i] = 0;
	}
	//printf("%d",len); 

	for(i=0;i<len;i++)
	{
		n = 24-((i&0x03)<<3);
		m[i/4] |= input[i]<<n;
	}
	n = 24-((i&0x03)<<3);
	m[i/4] |= 0x80<<n;
	m[15] = len*8;
}

//由512位M生成80字W
static void sha1_prepare(void)
{
	int i;
	for(i=0;i<16;i++)
	{
		w[i]=m[i];
	}
	for(i=16;i<80;i++)
	{
		w[i]=w[i-16]^w[i-14]^w[i-8]^w[i-3];
		w[i]=S(w[i],1);
	}
}

//由80字W计算sha1
static void sha1_calc(void)
{
	int i;
	unsigned long a,b,c,d,e,f,k;
	unsigned long temp;
	
	h[0]=0x67452301;
	h[1]=0xEFCDAB89;
	h[2]=0x98BADCFE;
	h[3]=0x10325476;
	h[4]=0xC3D2E1F0;
	
	a = h[0];
	b = h[1];
	c = h[2];
	d = h[3];
	e = h[4];
	for(i=0;i<80;i++)
	{
		switch(i/20)
		{
		case 0:
			k=0x5A827999;
			f=(b&c)|(~b&d);
			break;
		case 1:
			k=0x6ED9EBA1;
			f=b^c^d;
			break;
		case 2:
			k=0x8F1BBCDC;
			f=(b&c)|(b&d)|(c&d);
			break;
		case 3:
			k=0xCA62C1D6;
			f=b^c^d;
			break;
		}
		temp=S(a,5)+f+e+w[i]+k;
		e=d;
		d=c;
		c=S(b,30);
		b=a;
		a=temp;
	}
	h[0]+=a;
	h[1]+=b;
	h[2]+=c;
	h[3]+=d;
	h[4]+=e;
}

//SHA1算法接口
//input:待校验的数据
//len:数据长度(小于56字节)
unsigned long* sha1( char* input, int len)
{
	sha1_pad(input,len);
	sha1_prepare();
	sha1_calc();
	return h;
}
main()
{
	char str[1024];
	unsigned long* mac;
	while(1)
	{
		puts("input:");
		gets(str);
		mac=sha1(str,strlen(str));
		printf("SHA1=%08X%08X%08X%08X%08X\n",mac[0],mac[1],mac[2],mac[3],mac[4]);
		//system("pause");
	}
}

//sha1.h：对字符串进行sha1加密
#include <string.h>
#include <stdio.h>
#ifndef _SHA1_H_
#define _SHA1_H_
typedef struct SHA1Context{
    unsigned Message_Digest[5];      
    unsigned Length_Low;             
    unsigned Length_High;            
    unsigned char Message_Block[64]; 
    int Message_Block_Index;         
    int Computed;                    
    int Corrupted;                   
} SHA1Context;

void SHA1Reset(SHA1Context *);
int SHA1Result(SHA1Context *);
void SHA1Input( SHA1Context *,const char *,unsigned);
#endif


#define SHA1CircularShift(bits,word) ((((word) << (bits)) & 0xFFFFFFFF) | ((word) >> (32-(bits))))

void SHA1ProcessMessageBlock(SHA1Context *);
void SHA1PadMessage(SHA1Context *);

void SHA1Reset(SHA1Context *context){// 初始化动作
    context->Length_Low             = 0;
    context->Length_High            = 0;
    context->Message_Block_Index    = 0;

    context->Message_Digest[0]      = 0x67452301;
    context->Message_Digest[1]      = 0xEFCDAB89;
    context->Message_Digest[2]      = 0x98BADCFE;
    context->Message_Digest[3]      = 0x10325476;
    context->Message_Digest[4]      = 0xC3D2E1F0;

    context->Computed   = 0;
    context->Corrupted  = 0;
}


int SHA1Result(SHA1Context *context){// 成功返回1，失败返回0
    if (context->Corrupted) {
        return 0;
    }
    if (!context->Computed) {
        SHA1PadMessage(context);
        context->Computed = 1;
    }
    return 1;
}


void SHA1Input(SHA1Context *context,const char *message_array,unsigned length){
    if (!length) return;

    if (context->Computed || context->Corrupted){
        context->Corrupted = 1;
        return;
    }

    while(length-- && !context->Corrupted){
        context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);

        context->Length_Low += 8;

        context->Length_Low &= 0xFFFFFFFF;
        if (context->Length_Low == 0){
            context->Length_High++;
            context->Length_High &= 0xFFFFFFFF;
            if (context->Length_High == 0) context->Corrupted = 1;
        }

        if (context->Message_Block_Index == 64){
            SHA1ProcessMessageBlock(context);
        }
        message_array++;
    }
}

void SHA1ProcessMessageBlock(SHA1Context *context){
    const unsigned K[] = {0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
    int         t;                
    unsigned    temp;             
    unsigned    W[80];            
    unsigned    A, B, C, D, E;    

    for(t = 0; t < 16; t++) {
    W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
    W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
    W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
    W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
    }
    
    for(t = 16; t < 80; t++)  W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);

    A = context->Message_Digest[0];
    B = context->Message_Digest[1];
    C = context->Message_Digest[2];
    D = context->Message_Digest[3];
    E = context->Message_Digest[4];

    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;
    }
    context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF;
    context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF;
    context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF;
    context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF;
    context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF;
    context->Message_Block_Index = 0;
}

void SHA1PadMessage(SHA1Context *context){
    if (context->Message_Block_Index > 55) {
        context->Message_Block[context->Message_Block_Index++] = 0x80;
        while(context->Message_Block_Index < 64)  context->Message_Block[context->Message_Block_Index++] = 0;
        SHA1ProcessMessageBlock(context);
        while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0;
    } else {
        context->Message_Block[context->Message_Block_Index++] = 0x80;
        while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0;
    }
    context->Message_Block[56] = (context->Length_High >> 24 ) & 0xFF;
    context->Message_Block[57] = (context->Length_High >> 16 ) & 0xFF;
    context->Message_Block[58] = (context->Length_High >> 8 ) & 0xFF;
    context->Message_Block[59] = (context->Length_High) & 0xFF;
    context->Message_Block[60] = (context->Length_Low >> 24 ) & 0xFF;
    context->Message_Block[61] = (context->Length_Low >> 16 ) & 0xFF;
    context->Message_Block[62] = (context->Length_Low >> 8 ) & 0xFF;
    context->Message_Block[63] = (context->Length_Low) & 0xFF;

    SHA1ProcessMessageBlock(context);
}

int sha1_hash(const char *source, char *lrvar){// Main
    SHA1Context sha;
    char buf[128];

    SHA1Reset(&sha);
    SHA1Input(&sha, source, strlen(source));

    if (!SHA1Result(&sha)){
       // lr_error_message("SHA1 ERROR: Could not compute message digest");
        return -1;
    } else {
        memset(buf,0,sizeof(buf));
        sprintf(buf, "%08X%08X%08X%08X%08X", sha.Message_Digest[0],sha.Message_Digest[1],
        sha.Message_Digest[2],sha.Message_Digest[3],sha.Message_Digest[4]);
        //lr_save_string(buf, lrvar);
        return strlen(buf);
    }
}
c 语言常见的加密算法——SHA-1算法
A185822153的专栏
12-09 1461
以上这些算法在C语言中实现时，通常会使用到openssl这样的第三方库，因为这些库已经实现了这些算法的高效实现，直接使用。最后，我们输出哈希值（以16进制格式）。请注意，这只是一个简单的示例，实际应用中可能需要更复杂的错误处理和资源管理。在这个示例中，我们首先定义了要计算哈希的数据，然后声明了一个长度为。函数对数据进行哈希计算，并将结果存储在。的数组来存储哈希结果。
SHA-1算法c语言实现
无知人生，记录点滴
05-14 2213
安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准 （Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化...
SHA1校验算法C语言实现
热门推荐
coding__madman的博客
07-31 2万+
SHA1 安全哈希算法：对于长度小于2^64位的消息(1M = 1024k,1K = 1024字节，1BYTE = 8bit 可以想象一下2的63次方位可以表示一个多大的数据文件)，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。 SHA1有如下特性：不可以从消息摘要中复原信
SHA1算法 C语言实现
Blackkitty 's Blog
02-20 1万+
SHA1算法 C语言实现实现了计算字符串，文件的SHA1值 算法来自百度百科 VS2013下成功编译运行
SHA-1密码哈希算法（c语言实现）
04-05
本人为在校大学生，所写源码可能不够尽善尽美，希望各位包涵指正。写这个代码只是为了练手，可能有错误，只为大家提供思路和方法。
sha256 哈希算法 c语言实现
08-10
亲测可要使用 * Filename: sha256.c * Author: Brad Conte (brad AT bradconte.com) * Copyright: * Disclaimer: This code is presented "as is" without any guarantees.
SHA1算法及HMAC<SHA1>算法C语言实现
03-08
/*SHA1算法及HMAC<SHA1>算法C语言实现。内附详细测试例程。测试数据取自rfc2202.txt和rfc3174.txt。源文件列表: md5.h, md5.cpp, test.h, test.cpp, rfc2202.txt, rfc3174.txt。包含测试工程: VC++6.0, VC++2008, ...
sha 算法c语言实现
08-16
在标题“SHA算法C语言实现”中，我们关注的是如何使用C语言编写代码来实现SHA算法。C语言是一种底层、通用且高效的编程语言，适合编写这样的底层算法实现。 描述中提到“编译成功，并在nrf52832上验证”，nrf52832...
C语言实现hash算法
09-04
本项目是用C语言实现的哈希算法，包括SHA256、SHA384和SHA512三种不同的哈希函数，这些函数是SHA-2（Secure Hash Algorithm 2）家族的一部分。 SHA-2是由美国国家安全局（NSA）设计的，包含了多种不同长度的哈希...
用C语言实现SHA1哈希函数
01-12
用C语言实现SHA1哈希函数，它将文件的每一行进行加密，输出160位的哈希值
SHA1加密算法(c语言实现).zip
12-15
SHA1非对称加密算法(c语言实现).
安全哈希算法(sha1)c语言实现，包括测试程序
04-15
全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要
SHA1算法实现，c语言实现
05-26
SHA1加密算法
SHA1算法C语言源代码
02-02
SHA1算法C语言完全实现的源代码，里面另附测试代码！可直接运行的。
maven jar包安全性说明
weixin_45209491的博客
05-15 622
1).说明:文件在进行数据传输时,如何保证安全性可靠性 ​ 2).实现策略:采用sha1加密方式保证传输正确性. ​ 3).sha1算法: ​ SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。 4).数据传输的原理 信息摘要, 目的判断新旧
C语言实现SHA-1算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-24 542
C语言实现SHA-1算法(附完整源码)
SHA1算法的C语言实现（支持输入字符串长度超过56）_sha1 c语言
2401_84008985的博客
04-05 1127
你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！” />你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！更多资料点击此处获qu！！
Android物联网应用程序开发基础_基于android的物联网应用开发
最新发布
2401_84010457的博客
05-13 839
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值