c语言生成文件哈希值,C语言获取文件的SHA1哈希值

最新推荐文章于 2024-03-16 09:35:04 发布
最新推荐文章于 2024-03-16 09:35:04 发布
阅读量639 收藏
点赞数
文章标签： c语言生成文件哈希值

版权声明：本文为 testcs_dn(微wx笑) 原创文章，非商用自由转载-保持署名-注明出处，谢谢。    https://blog..net/testcs_dn/article/details/25569975

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

SHA1 C语言实现

#include

#include

#include

#include

#include

#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     \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..net/detail/testcs_dn/7332933

---------------------

作者：微wx笑

来源：

原文：https://blog..net/testcs_dn/article/details/25569975

版权声明：本文为博主原创文章，转载请附上博文链接！

陈华葵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
sha1:sha1哈希算法
05-04
名称 SHA1Init，SHA1Update，SHA1Final，SHA1Transform 概要 #include <sys> #include <sha1> 无效的SHA1Transform（ uint32_t state [5]，const unsigned char buffer [64]）； 无效的SHA1Init（ SHA1_CTX *上下文）; 无效的SHA1Update（ SHA1_CTX *上下文，const unsigned char data，uint32_t len）; 无效的SHA1Final（ unsigned char摘要[20]，SHA1_CTX *上下文）； 描述 SHA1函数实现了NIST安全哈希算法（SHA-1），FIPS PUB 180-1。 SHA-1用于生成称为消息摘要的消息的压缩表示。 该算法将小
SHA1 - SHA1_Init()/SHA1_Update()/SHA1_Final()生成 sha1 散列值函数组合
热门推荐
Mrknowledge
06-20 1万+
在《 sha1 -- 生成 sha1 散列值 》中给出了可以生成 SHA1() 函数，它应用很简单。实际上，OpenSSL 还提供了另外一套 API 用以产生 sha1 散列值，该套 API 可以生成更大文件的散列值。比如在 32 位系统下，应用程序不能访问超过 4G (2[sup]32[/sup] )的内存空间，从 SHA1() 函数的
Hasher: 快速生成哈希值的命令行工具
最新发布
gitblog_00097的博客
03-16 340
Hasher: 快速生成哈希值的命令行工具 如果你需要频繁地为文件生成哈希值，那么你可以试试 Hasher。这是一个简单的命令行工具，可以快速地为指定文件生成 MD5、SHA-1 或 SHA-256 哈希值。 功能特性 支持 MD5、SHA-1 和 SHA-256 哈希算法 可以通过管道或重定向输入文件 支持批量处理多个文件 输出结果可定制化 如何使用 安装 首先，你需要安装 Go 编译器并将...
SHA1hash算法C语言实现
mlynb的博客
12-03 5400
SHA的简介 美国国家标准技术研究所NIST于1993年开发的另一个散 列算法称为SHA。两年之后，这个算法被修改为了今天广泛 使用的形式。修改后的版本是SHA-1，是数字签名标准中要 求使用的算法。 SHA接受任何有限长度的输入消息，并产生长度为160比 特的Hash值（MD5仅仅生成128位的摘要），因此抗穷举性 更好。SHA-1设计时基于和MD4相同原理，它有5个参与运 算的32位寄存器字，消息分组和填充方式与MD5相同，主循 环也同样是4轮，但每轮进行20次操作，非线性运算、移位和 加法运算也与MD
SHA1 摘要算法
cwg2552298的博客
08-13 1958
SHA1 算法：         消息摘要算法，把消息按照 512 bits 进行分组，不断的对 5 个int型变量进行计算，直到所有消息都运算完毕。 最终得到 160 bit 即 20 字节的哈希值。流程图：   -------------------------------------------------------- C语言实现： 用到的数据结构： //SHA1算法的...
通过SHA_init/SHA_update/SHA_final生成sha散列值
csdn66_2016的博客
08-16 1606
在《sha1 -- 生成 sha1 散列值》中给出了可以生成 SHA1() 函数，它应用很简单。实际上，OpenSSL 还提供了另外一套 API 用以产生 sha1 散列值，该套 API 可以生成更大文件的散列值。比如在 32 位系统下，应用程序不能访问超过 4G (2[sup]32[/sup] )的内存空间，从 SHA1() 函数的第 1 个参数指针也知道，它所指向的空间也不能超过 4G
C语言获取文件的SHA1哈希值
05-12
C语言获取文件的SHA1哈希值,详情请参考：http://blog.csdn.net/testcs_dn/article/details/25569975
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.
C#获取文件哈希值的代码
04-10
可以获取MD5的值和sha1的值简单易用，有用的朋友可以下载。
用C语言实现SHA1哈希函数
01-12
用C语言实现SHA1哈希函数，它将文件的每一行进行加密，输出160位的哈希值
SHA-1密码哈希算法（c语言实现）
04-05
本人为在校大学生，所写源码可能不够尽善尽美，希望各位包涵指正。写这个代码只是为了练手，可能有错误，只为大家提供思路和方法。
【 逆向基础 】密码学实现（SHA1）
u014685598的博客
12-15 772
基本思路都是将信息分成N个分组，每组64个字节（512 位），每个分组都进行摘要运算。 当一个分组的摘要运算完毕后，将上一个分组的结果也用于下一个分组的运算。 当最后一个分组长度小于448 b那么会加上0x80 然后补足448 ，在最后64位为长度标识，大端序
文件的hash值
yangyu19910407的专栏
09-10 1万+
Hash，一般翻译做“散列”，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射，pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。 简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 HASH主要
OpenSSL源码中SHA1_Init()的实现在哪里？
oneinmore的专栏
01-25 5231
事情起源于想基于openssl的源码编译自己写的一个调用API的简单程序，结果在m_sha1.c:init()函数中报“undefined reference to `SHA1_Init'”的错误（并不是所有openssl源码的文件都添加到我的项目中了，我的想法是尽量只使用我的自己写的程序所必需的文件），我立即在源码中搜索SHA1_Init()函数的实现，结果根本找不到。附带说一下，我使用的源码分
字符串SHA1值计算C语言,SHA-1算法的C语言实现
weixin_32540109的博客
05-18 276
来自网络上的SHA－1算法，自己加了少量注释，方便以后需要的时候可以利用。代码：/* sha1sum.c - print SHA-1 Message-Digest Algorithm* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.* Copyright (C) 2004 g10 Code GmbH** Thi...
生成、查看文件的MD5、SHA1、SHA2、SHA3值 | 文件的哈希（hash）值生成
COCO56的博客
05-16 6907
文章目录1. 按2. 介绍2.1. MD52.2. SHA-12.3. SHA-22.4. SHA-33. Linux4. Windows4.1. 生成4.2. 单个文件4.3. 当前目录下的所有文件4.4. 查看5. Python5.1. 代码5.2. 结果 1. 按 操作系统自带的一般都有相关的命令，在Linux系统下可以使用bash，Windows下用CMD均可以轻松地生成文件的MD5、SHA、SHA256值，另外Windows下还可以直接查看。 此外我们还可以使用Python进行编写相关的程序，Wi
c语言 sha1 小写输出,C语言获取文件SHA1哈希
weixin_42528296的博客
05-22 156
安全散列算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)它定义了数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息。SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要能够用来验证数据的完整性。在传输的过程中。数据非常可能会发生变化，...
c语言字符串计算哈希值,【C语言】哈希函数写法、字符串深度复制
weixin_39612058的博客
05-17 1432
Little trick.html1 哈希函数理想的哈希函数保证每一个字符串对应惟一的哈希值。下面这个哈希函数是同窗在项目中遇到的。算法unsigned int hash(char* s){unsigned int h=0;for(;*s;s++)h = *s + h*31;return h%HASHSIZE; //predefined hash size}能够看出，这个hash函数遍历字符串中每...
sha-1计算文件哈希值C++代码
02-20
SHA-1算法用来计算文件的哈希值，C语言中的代码可以如下：#include #include #include<openssl/sha.h>int main() { unsigned char text[]="This is an example"; unsigned char buf[20]; SHA1(text,strlen(text...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值