c语言实现hmac-md5(提供完整的、测试通过的例子)

最新推荐文章于 2024-04-20 17:18:42 发布
最新推荐文章于 2024-04-20 17:18:42 发布
阅读量4k 收藏 42
点赞数 15
分类专栏： 其他问题 文章标签： md5 hmac c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a823837282/article/details/107931442
版权

最近工作需要使用hmac-md5算法，网上找的例子都或多或少有问题。但md5可使用的代码好找，而hmac-md5只需要在md5的基础上做些小操作即可。

 

完整代码如下。

总共三个文件：

                md5.c：  md5算法的具体实现

                md5.h：  md5算法的头文件

                hmac_md5.c ：hmac_md5的实现。（包含main，提供测试例子）

 

检验方法：

          可以通过输入同样的密钥以及加密串，看看这份hmac-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))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) \
          { \
          a += F(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define GG(a,b,c,d,x,s,ac) \
          { \
          a += G(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define HH(a,b,c,d,x,s,ac) \
          { \
          a += H(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define II(a,b,c,d,x,s,ac) \
          { \
          a += I(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }                                            
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen);
void MD5Final(MD5_CTX *context,unsigned char digest[16]);
void MD5Transform(unsigned int state[4],unsigned char block[64]);
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len);
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len);
 
#endif

 

 

md5.c：

#include <memory.h>
#include "md5.h"
 
unsigned char PADDING[]={0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                         
void MD5Init(MD5_CTX *context)
{
     context->count[0] = 0;
     context->count[1] = 0;
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
    unsigned int i = 0,index = 0,partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;
    context->count[0] += inputlen << 3;
    if(context->count[0] < (inputlen << 3))
       context->count[1]++;
    context->count[1] += inputlen >> 29;
    
    if(inputlen >= partlen)
    {
       memcpy(&context->buffer[index],input,partlen);
       MD5Transform(context->state,context->buffer);
       for(i = partlen;i+64 <= inputlen;i+=64)
           MD5Transform(context->state,&input[i]);
       index = 0;        
    }  
    else
    {
        i = 0;
    }
    memcpy(&context->buffer[index],&input[i],inputlen-i);
}
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
    unsigned int index = 0,padlen = 0;
    unsigned char bits[8];
    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56)?(56-index):(120-index);
    MD5Encode(bits,context->count,8);
    MD5Update(context,PADDING,padlen);
    MD5Update(context,bits,8);
    MD5Encode(digest,context->state,16);
}
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len)
    {
         output[j] = input[i] & 0xFF;  
         output[j+1] = (input[i] >> 8) & 0xFF;
         output[j+2] = (input[i] >> 16) & 0xFF;
         output[j+3] = (input[i] >> 24) & 0xFF;
         i++;
         j+=4;
    }
}
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
     unsigned int i = 0,j = 0;
     while(j < len)
     {
           output[i] = (input[j]) |
                       (input[j+1] << 8) |
                       (input[j+2] << 16) |
                       (input[j+3] << 24);
           i++;
           j+=4; 
     }
}
void MD5Transform(unsigned int state[4],unsigned char block[64])
{
     unsigned int a = state[0];
     unsigned int b = state[1];
     unsigned int c = state[2];
     unsigned int d = state[3];
     unsigned int x[64];
     MD5Decode(x,block,64);
     FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */
 FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */
 FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */
 FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */
 FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */
 FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */
 FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */
 FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */
 FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */
 FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */
 FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */
 FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */
 FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */
 FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */
 FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */
 FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */
 
 /* Round 2 */
 GG(a, b, c, d, x[ 1], 5, 0xf61e2562); /* 17 */
 GG(d, a, b, c, x[ 6], 9, 0xc040b340); /* 18 */
 GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */
 GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /* 20 */
 GG(a, b, c, d, x[ 5], 5, 0xd62f105d); /* 21 */
 GG(d, a, b, c, x[10], 9,  0x2441453); /* 22 */
 GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */
 GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /* 24 */
 GG(a, b, c, d, x[ 9], 5, 0x21e1cde6); /* 25 */
 GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */
 GG(c, d, a, b, x[ 3], 14, 0xf4d50d87); /* 27 */
 GG(b, c, d, a, x[ 8], 20, 0x455a14ed); /* 28 */
 GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */
 GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8); /* 30 */
 GG(c, d, a, b, x[ 7], 14, 0x676f02d9); /* 31 */
 GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 */
 
 /* Round 3 */
 HH(a, b, c, d, x[ 5], 4, 0xfffa3942); /* 33 */
 HH(d, a, b, c, x[ 8], 11, 0x8771f681); /* 34 */
 HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */
 HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */
 HH(a, b, c, d, x[ 1], 4, 0xa4beea44); /* 37 */
 HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9); /* 38 */
 HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60); /* 39 */
 HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */
 HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */
 HH(d, a, b, c, x[ 0], 11, 0xeaa127fa); /* 42 */
 HH(c, d, a, b, x[ 3], 16, 0xd4ef3085); /* 43 */
 HH(b, c, d, a, x[ 6], 23,  0x4881d05); /* 44 */
 HH(a, b, c, d, x[ 9], 4, 0xd9d4d039); /* 45 */
 HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */
 HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */
 HH(b, c, d, a, x[ 2], 23, 0xc4ac5665); /* 48 */
 
 /* Round 4 */
 II(a, b, c, d, x[ 0], 6, 0xf4292244); /* 49 */
 II(d, a, b, c, x[ 7], 10, 0x432aff97); /* 50 */
 II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */
 II(b, c, d, a, x[ 5], 21, 0xfc93a039); /* 52 */
 II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */
 II(d, a, b, c, x[ 3], 10, 0x8f0ccc92); /* 54 */
 II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */
 II(b, c, d, a, x[ 1], 21, 0x85845dd1); /* 56 */
 II(a, b, c, d, x[ 8], 6, 0x6fa87e4f); /* 57 */
 II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */
 II(c, d, a, b, x[ 6], 15, 0xa3014314); /* 59 */
 II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */
 II(a, b, c, d, x[ 4], 6, 0xf7537e82); /* 61 */
 II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */
 II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /* 63 */
 II(b, c, d, a, x[ 9], 21, 0xeb86d391); /* 64 */
     state[0] += a;
     state[1] += b;
     state[2] += c;
     state[3] += d;
}

 

hmac_md5.c:

#include <stdio.h>
#include <stdlib.h>
#include "md5.h"
#include <string.h>



#define LENGTH_MD5_RESULT 16
#define LENGTH_BLOCK 64


/**
*作者：			小姚
*时间：			2020-08-11
*功能：			基于md5实现hmac。
*注意事项：			
*				1. 代码中多次出现64、16，应该定义为宏，便于修改。
*				2. 
*参数：
*		data(in): 需要加密的数据
*		dlen(in): 加密数据的长度
*		key(in) : 密钥
*		klen(in): 密钥长度
*		out(out): 加密之后的串
*/
void hmac_md5(unsigned char* out, unsigned char* data, int dlen, unsigned char* key, int klen)
{
	int i;

	unsigned char tempString16[LENGTH_MD5_RESULT];
	unsigned char OneEnding[LENGTH_BLOCK];
	unsigned char TwoEnding[LENGTH_BLOCK];
	unsigned char ThreeEnding[LENGTH_BLOCK + dlen];
	unsigned char FourEnding[LENGTH_MD5_RESULT];	/*如下步骤四生成的结果*/
	unsigned char FiveEnding[LENGTH_BLOCK];    /*步骤五生成的结果*/
	unsigned char SixEnding[LENGTH_BLOCK+ LENGTH_MD5_RESULT];
	
	char ipad;
	char opad;
	MD5_CTX md5;
	
	ipad = 0x36;
	opad = 0x5c;
	
	
/*(1) 在密钥key后面添加0来创建一个长为B(64字节)的字符串(OneEnding)。如果key的长度klen大于64字节，则先进行md5运算，使其长度klen=16字节。 */

	for ( i = 0; i < LENGTH_BLOCK; i++)
	{
			OneEnding[i] = 0;
	}

	if ( klen > LENGTH_BLOCK)
	{
		MD5Init(&md5);         		
		MD5Update(&md5,key,klen);
		MD5Final(&md5,tempString16);   
		for (i = 0; i < LENGTH_MD5_RESULT; i++)
			OneEnding[i] = tempString16[i];
	}	
	else
	{
	   for (i = 0; i < klen; i++)
			OneEnding[i] = key[i] ;
	}
	
	
/*(2) 将上一步生成的字符串(OneEnding)与ipad(0x36)做异或运算，形成结果字符串(TwoEnding)。*/
	for ( i = 0; i < LENGTH_BLOCK; i++)
	{
		TwoEnding[i] = OneEnding[i] ^ ipad; 
	}
/*(3) 将数据流data附加到第二步的结果字符串(TwoEnding)的末尾。*/
	for ( i = 0; i < LENGTH_BLOCK; i++ )
	{
		ThreeEnding[i] = TwoEnding[i];
	}
	for ( ; i < dlen + LENGTH_BLOCK; i++)
	{
		ThreeEnding[i] = data[i - LENGTH_BLOCK];
	}
/*(4) 做md5运算于第三步生成的数据流(ThreeEnding)。*/
	MD5Init(&md5);         		
	MD5Update( &md5, ThreeEnding, LENGTH_BLOCK + dlen);
	MD5Final(&md5,FourEnding);
	
/*(5) 将第一步生成的字符串(OneEnding)与opad(0x5c)做异或运算，形成结果字符串(FiveEnding)。*/
	for ( i = 0 ; i < LENGTH_BLOCK; i++ )
	{
			FiveEnding[i] = OneEnding[i] ^ opad;
	}
/*(6) 再将第四步的结果(FourEnding)附加到第五步的结果字符串(FiveEnding)的末尾。*/
	for (i = 0; i < LENGTH_BLOCK; i++)
	{
		SixEnding[i] = FiveEnding[i];
	}
	for ( ; i < (LENGTH_BLOCK + LENGTH_MD5_RESULT); i++)
	{
		SixEnding[i] = FourEnding[i - LENGTH_BLOCK];
	}
/*(7) 做md5运算于第六步生成的数据流(SixEnding)，输出最终结果(out)。*/
	MD5Init(&md5);         		
	MD5Update( &md5, SixEnding, LENGTH_BLOCK + LENGTH_MD5_RESULT);
	MD5Final(&md5,out);	
}


 
int main(int argc, char *argv[])
{
    char  * data = "1111";
	char   * key = "woshiren";
	
	unsigned char * out = (unsigned char *)malloc(16);
	hmac_md5(out, (unsigned char *)data , strlen(data), (unsigned char *)key , strlen(key));
	int i;
	for ( i = 0; i < 16; i++)
	{
		printf("%02x ", out[i]);
	}
	return 0;
}

 

Gk_zheng
关注
  • 15
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
C/C++学习 -- HMAC算法
weixin_41489908的博客
10-05 1224
HMAC，全称为HMAC-MD5、HMAC-SHA1、HMAC-SHA256等，是一种在数据传输中验证完整性和认证来源的方法。它结合了哈希函数和密钥，通过在数据上应用哈希函数，生成一个带密钥的散列值，用于验证数据的完整性。总之，HMAC算法是一种强大的加密技术，用于验证数据的完整性和源自身。HMAC算法的核心思想是将密钥与数据结合，然后应用哈希函数。下面是一个简单的C语言示例，演示如何使用HMAC-SHA256算法来计算HMAC值。安全性高: HMAC算法提供了高级别的安全性，因为它依赖于强大的哈希函数。
MD5算法C语言实现
保持每天的清醒
11-14 4157
转自http://witmax.cn/c-md5-code.html，作者也是网上转载的，但没标明出处。 网上找到的md5函数的代码，试了一下，可以用，记录一下。包括三个文件，依次如下： 头文件md5.h 01 02 03 04 05 06 07 08 09 10 11 12 13 ...
HMAC算法以及工作原理
最新发布
扬帆起航
04-20 2660
HMAC算法以及工作原理
【MD5算法_C语言实现】
Sugar_wolf的博客
01-18 3904
Message Digest Algorithm 消息摘要算法： 5表示第5版 算法的文件号为RFC 1321 本质： 算法不可逆 不同的数据可能会生成相同的一串 有破解之道，比如穷举法，暴力破解。 根据生成的数据串，在数据库中找生成他的数据数据库是在时时刻刻的收集枚举各种数据组合。 应用：比如登录密码 本地注册时填入密码，本地将密码转成md5串，传输给服务器，服务器存的密码就是md5串。中途被坏人劫走的密码，劫走的只是md5串，而不是密码本身，这也是一种保护。 很多验证都应用的md5 ...
C++中实现HMAC单向散列类
FlushHip
12-05 2114
HMAC的维基百科解释是：hash-based message authentication code，其实就是加了盐的单向散列算法。而HMAC的重点就是如何给要散列的数据加盐。 加盐公式如下： 解释一下上面的符号： ⊕\oplus⊕表示异或运算； mmm表示要散列的数据； a∣∣ba || ba∣∣b表示把aaa加入bbb，其实就是用散列算法把aaa算一下，紧接着把bbb算一下； ipadi...
C语言实现MD5算法!
天行健
03-07 7182
1)global.h 头文件  #ifndef PROTOTYPES  #define PROTOTYPES 0  #endif  /* POINTER defines a generic pointer type */  typedef unsigned char *POINTER;  /* UINT4 defines a four byte word */  typedef unsigned 
MD5算法的C语言实现
White3zz的博客
11-18 2182
算法原理概述 MD5信息摘要算法，( Message-Digest Algorithm 5)，是一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值，用于确保信息传输完整一致。 MD5算法使用little-endian（小端模式，即低位字节存在内存低地址），输入任意不定长度信息，算法都首先将其以512-bit进行分组（不足补位），每个512-bit的分组都和四个32-bit的数...
HMAC-MD5的c语言实现算法 安全摘要算法
05-13
总的来说，HMAC-MD5是加强了安全性的摘要算法，通过C语言实现，可以帮助开发者在系统中实现数据的完整性检查和身份验证。尽管MD5的安全性已经受到质疑，但在某些场景下，如旧系统的兼容性需求，HMAC-MD5仍有一定的...
hmac-md5.zip
07-06
HMACMD5 是从 MD5 哈希函数构造的一种键控哈希算法，被用作基于哈希的消息验证代码 (HMAC)。此 HMAC 进程将密钥与消息数据混合，使用哈希函数对混合结果进行哈希计算，将所得哈希值与该密钥混合，然后再次应用哈希...
hmac.rar_HMAC-MD5_hmac_hmac-sha1
09-20
压缩包中的"hmac.c"文件很可能包含了C语言实现的HMAC算法，可能包括HMAC-MD5和HMAC-SHA1的函数。开发者可以使用这些函数来在他们的软件中集成HMAC功能，以确保通信的安全。 在实际应用中，HMAC常用于网络协议（如...
delphi 实现hmac-md5加密算法
08-12
HMAC-MD5是一种基于密钥的哈希消息认证码（Hash-based Message Authentication Code）算法，它结合了MD5（Message-Digest Algorithm 5）哈希函数和密钥，用于验证数据的完整性和来源。在Delphi编程环境中，实现HMAC-...
HMAC-MD5 C语言算法
06-03
HMAC-MD5的c语言实现算法。安全摘要算法。
Hash-MD5算法(C语言实现，附带Hash验证工具)
12-28
压缩包里包括了MD5算法的源代码，完全用C语言实现，同时还附带了7个验证Hash的小工具，供大家使用希望对大家有所帮助！谢谢使用
SHA256 和 HMAC-SHA256 的C语言实现
11-25
SHA256 和 HMAC-SHA256 的C语言实现，只有一个文件，无库依赖。使用方法见源码底部注释说明
HMAC-SHA256和HMAC-SHA1加密C语言代码
07-10
data: test Data key: 123 ---SHA1--- DATA: 3a81f749059c9ace07e63d613857b21e2f42145b BASE64: OoH3SQWcms4H5j1hOFeyHi9CFFs= ---HMACSHA1--- DATA: 0a7ec5f83fbeb938f155a265c431a09457c43a76 BASE64: Cn7F+D++uTjxVaJlxDGglFfEOnY= ---SHA256--- DATA: 1d6bf7fc06eb47cca7c310ef87656920e24c65a23780e8ba53b8317b5c79fd1f BASE64: HWv3/AbrR8ynwxDvh2VpIOJMZaI3gOi6U7gxe1x5/R8= ---HMACSHA256--- DATA: dafb37cff18237a2bbd7da6a12e8f6743b459ddca186c831b9b23c99c0e38eed BASE64: 2vs3z/GCN6K719pqEuj2dDtFndyhhsgxubI8mcDjju0= Any key to exit
C++实践（五）C++实现认证算法：基于SHA-512的HMAC
goodluckcwl的专栏
03-14 6325
基于SHA-512的HMAC算法 SHA是使用最广泛的Hash函数。其家族有SHA-1，SHA-2（包括SHA-256/SHA-384/SHA-512）。SHA1与SHA2都使用了同样的迭代结构和模算术与二元逻辑操作。在本实验中，我们采用SHA-512。 SHA-512算法 SHA-512的逻辑 算法的输入为长度小于128位的信息（实际实现中我们假定输入的信息长度小于64位）， ...
md5算法c语言实现,c++实现MD5算法实现代码
weixin_42107561的博客
05-19 276
测试结果和百度百科测试例子一致。实现过程中需要注意事项：最后把四个变量A B C D 链接成结果时 ，注意变量高低位的先后顺序，具体参考 LinkResult()方法。md5.h#ifndef _MD5_H_#define _MD5_H_#include #include using namespace std;class MD5{public:typedef unsigned char ucha...
【安全算法之MD5】MD5摘要运算的C语言源码实现
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
10-18 6528
大家都知道，MD5是一种摘要运算算法，关于更多的摘要算法，可以参考我之前的一篇文章：摘要算法汇总 今天要给大家带来的是MD5摘要运算的源码实现，废话不多说，直接上源码： 先看头文件，什么了一些结构体定义和操作宏定义，以及导出的3个API接口： #ifndef __MD5_H__ #define __MD5_H__ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #include <stdint.h> typedef
用C语言实现HMAC-SHA256源码
06-09
以下是使用C语言实现HMAC-SHA256的源代码： ```c #include <stdio.h> #include <string.h> #include <openssl/hmac.h> #include <openssl/sha.h> int main() { const char* key = "mysecretkey"; const char* data = "Hello World"; unsigned char digest[SHA256_DIGEST_LENGTH]; unsigned int digest_len; HMAC(EVP_sha256(), key, strlen(key), (unsigned char*) data, strlen(data), digest, &digest_len); for(int i=0; i<SHA256_DIGEST_LENGTH; i++) { printf("%02x", digest[i]); } return 0; } ``` 和上面的C++代码类似，这个例子中我们同样使用了OpenSSL库来计算HMAC-SHA256摘要。在这个例子中，我们使用了一个秘钥和一个数据字符串来计算摘要。计算出的摘要被存储在digest数组中，并通过循环输出为十六进制字符串。请注意，这个例子中的秘钥和数据都是硬编码的，实际使用时应该从安全的来源中获取。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值