SHA1

最新推荐文章于 2023-02-16 15:35:11 发布
最新推荐文章于 2023-02-16 15:35:11 发布
阅读量828 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/90231782
版权

https://blog.csdn.net/u010144805/article/details/80803380

#ifndef G_SHA1_H
#define G_SHA1_H
 

#include "publish.h"

/**
 * \brief          SHA-1 context structure
 */
typedef struct
{
    uint32_t total[2];          /*!< number of bytes processed  */
    uint32_t state[5];          /*!< intermediate digest state  */
    unsigned char buffer[64];   /*!< data block being processed */
}
sha1_context;
 
void SHA1TEST(void);
#endif

#include "gsha1.h"




/* Implementation that should never be optimized out by the compiler */
static void zeroize( void *v, size_t n ) {
    volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
}

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i)                            \
{                                                       \
    (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
        | ( (uint32_t) (b)[(i) + 1] << 16 )             \
        | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
        | ( (uint32_t) (b)[(i) + 3]       );            \
}
#endif

#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i)                            \
{                                                       \
    (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    (b)[(i) + 3] = (unsigned char) ( (n)       );       \
}
#endif

void sha1_init( sha1_context *ctx )
{
    memset( ctx, 0, sizeof( sha1_context ) );
}

void sha1_free( sha1_context *ctx )
{
    if( ctx == NULL )
        return;

    zeroize( ctx, sizeof( sha1_context ) );
}

void sha1_clone( sha1_context *dst,
                         const sha1_context *src )
{
    *dst = *src;
}

/*
 * SHA-1 context setup
 */
void sha1_starts( sha1_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
    ctx->state[4] = 0xC3D2E1F0;
}


void sha1_process( sha1_context *ctx, const unsigned char data[64] )
{
    uint32_t temp, W[16], A, B, C, D, E;

    GET_UINT32_BE( W[ 0], data,  0 );
    GET_UINT32_BE( W[ 1], data,  4 );
    GET_UINT32_BE( W[ 2], data,  8 );
    GET_UINT32_BE( W[ 3], data, 12 );
    GET_UINT32_BE( W[ 4], data, 16 );
    GET_UINT32_BE( W[ 5], data, 20 );
    GET_UINT32_BE( W[ 6], data, 24 );
    GET_UINT32_BE( W[ 7], data, 28 );
    GET_UINT32_BE( W[ 8], data, 32 );
    GET_UINT32_BE( W[ 9], data, 36 );
    GET_UINT32_BE( W[10], data, 40 );
    GET_UINT32_BE( W[11], data, 44 );
    GET_UINT32_BE( W[12], data, 48 );
    GET_UINT32_BE( W[13], data, 52 );
    GET_UINT32_BE( W[14], data, 56 );
    GET_UINT32_BE( W[15], data, 60 );

#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

#define R(t)                                            \
(                                                       \
    temp = W[( t -  3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
           W[( t - 14 ) & 0x0F] ^ W[  t       & 0x0F],  \
    ( W[t & 0x0F] = S(temp,1) )                         \
)

#define P(a,b,c,d,e,x)                                  \
{                                                       \
    e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
}

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

#define F(x,y,z) (z ^ (x & (y ^ z)))
#define K 0x5A827999

    P( A, B, C, D, E, W[0]  );
    P( E, A, B, C, D, W[1]  );
    P( D, E, A, B, C, W[2]  );
    P( C, D, E, A, B, W[3]  );
    P( B, C, D, E, A, W[4]  );
    P( A, B, C, D, E, W[5]  );
    P( E, A, B, C, D, W[6]  );
    P( D, E, A, B, C, W[7]  );
    P( C, D, E, A, B, W[8]  );
    P( B, C, D, E, A, W[9]  );
    P( A, B, C, D, E, W[10] );
    P( E, A, B, C, D, W[11] );
    P( D, E, A, B, C, W[12] );
    P( C, D, E, A, B, W[13] );
    P( B, C, D, E, A, W[14] );
    P( A, B, C, D, E, W[15] );
    P( E, A, B, C, D, R(16) );
    P( D, E, A, B, C, R(17) );
    P( C, D, E, A, B, R(18) );
    P( B, C, D, E, A, R(19) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0x6ED9EBA1

    P( A, B, C, D, E, R(20) );
    P( E, A, B, C, D, R(21) );
    P( D, E, A, B, C, R(22) );
    P( C, D, E, A, B, R(23) );
    P( B, C, D, E, A, R(24) );
    P( A, B, C, D, E, R(25) );
    P( E, A, B, C, D, R(26) );
    P( D, E, A, B, C, R(27) );
    P( C, D, E, A, B, R(28) );
    P( B, C, D, E, A, R(29) );
    P( A, B, C, D, E, R(30) );
    P( E, A, B, C, D, R(31) );
    P( D, E, A, B, C, R(32) );
    P( C, D, E, A, B, R(33) );
    P( B, C, D, E, A, R(34) );
    P( A, B, C, D, E, R(35) );
    P( E, A, B, C, D, R(36) );
    P( D, E, A, B, C, R(37) );
    P( C, D, E, A, B, R(38) );
    P( B, C, D, E, A, R(39) );

#undef K
#undef F

#define F(x,y,z) ((x & y) | (z & (x | y)))
#define K 0x8F1BBCDC

    P( A, B, C, D, E, R(40) );
    P( E, A, B, C, D, R(41) );
    P( D, E, A, B, C, R(42) );
    P( C, D, E, A, B, R(43) );
    P( B, C, D, E, A, R(44) );
    P( A, B, C, D, E, R(45) );
    P( E, A, B, C, D, R(46) );
    P( D, E, A, B, C, R(47) );
    P( C, D, E, A, B, R(48) );
    P( B, C, D, E, A, R(49) );
    P( A, B, C, D, E, R(50) );
    P( E, A, B, C, D, R(51) );
    P( D, E, A, B, C, R(52) );
    P( C, D, E, A, B, R(53) );
    P( B, C, D, E, A, R(54) );
    P( A, B, C, D, E, R(55) );
    P( E, A, B, C, D, R(56) );
    P( D, E, A, B, C, R(57) );
    P( C, D, E, A, B, R(58) );
    P( B, C, D, E, A, R(59) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0xCA62C1D6

    P( A, B, C, D, E, R(60) );
    P( E, A, B, C, D, R(61) );
    P( D, E, A, B, C, R(62) );
    P( C, D, E, A, B, R(63) );
    P( B, C, D, E, A, R(64) );
    P( A, B, C, D, E, R(65) );
    P( E, A, B, C, D, R(66) );
    P( D, E, A, B, C, R(67) );
    P( C, D, E, A, B, R(68) );
    P( B, C, D, E, A, R(69) );
    P( A, B, C, D, E, R(70) );
    P( E, A, B, C, D, R(71) );
    P( D, E, A, B, C, R(72) );
    P( C, D, E, A, B, R(73) );
    P( B, C, D, E, A, R(74) );
    P( A, B, C, D, E, R(75) );
    P( E, A, B, C, D, R(76) );
    P( D, E, A, B, C, R(77) );
    P( C, D, E, A, B, R(78) );
    P( B, C, D, E, A, R(79) );

#undef K
#undef F

    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
    ctx->state[4] += E;
}


/*
 * SHA-1 process buffer
 */
void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (uint32_t) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (uint32_t) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left), input, fill );
        sha1_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        sha1_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
        memcpy( (void *) (ctx->buffer + left), input, ilen );
}

static const unsigned char sha1_padding[64] =
{
 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
};

/*
 * SHA-1 final digest
 */
void sha1_finish( sha1_context *ctx, unsigned char output[20] )
{
    uint32_t last, padn;
    uint32_t high, low;
    unsigned char msglen[8];

    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_BE( high, msglen, 0 );
    PUT_UINT32_BE( low,  msglen, 4 );

    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

    sha1_update( ctx, sha1_padding, padn );
    sha1_update( ctx, msglen, 8 );

    PUT_UINT32_BE( ctx->state[0], output,  0 );
    PUT_UINT32_BE( ctx->state[1], output,  4 );
    PUT_UINT32_BE( ctx->state[2], output,  8 );
    PUT_UINT32_BE( ctx->state[3], output, 12 );
    PUT_UINT32_BE( ctx->state[4], output, 16 );
}


/*
 * output = SHA-1( input buffer )
 */
int sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
{
    sha1_context ctx;

    sha1_init( &ctx );
    sha1_starts( &ctx );
    sha1_update( &ctx, input, ilen );
    sha1_finish( &ctx, output );
    sha1_free( &ctx );
    return 0;
}


//HELP
//0XAB-->"AB" 长度会扩大一倍！注意：0没有结束符
static void G_1byteTo2str(unsigned char* strings,unsigned char* bytes,unsigned char len)
{
    unsigned char const StrRefer[]="0123456789abcdef";//"0123456789ABCDEF";
    #define GET_MSB_STR(x) (StrRefer[((x>>4)&0x0f)])
    #define GET_LSB_STR(x) (StrRefer[(x&0x0f)])
    for(char i=0,j=0;i<len;i++,j+=2)
    {
        strings[j]  =GET_MSB_STR(bytes[i]);
        strings[j+1]=GET_LSB_STR(bytes[i]);
    }

}
//测试接口
void mbedtls_hmac_sha1( char *ref_hash,  
    const void *key, size_t key_len,  
    const void *msg, size_t msg_len )  
{  
    sha1_context ctx;
      
    enum { HASH_LEN = 20 };  
    enum { BLOCK_LEN = 64 };  
    unsigned char hash[HASH_LEN] = { 0 };  
    unsigned char key_pad[BLOCK_LEN] = { 0 };  
      
    if (key_len > BLOCK_LEN)  
    {  
        sha1((const unsigned char *)key, key_len, key_pad);  
    }  
    else  
    {  
        memcpy (key_pad, key, key_len);  
    }  
      
    unsigned char hash_temp[HASH_LEN] = { 0 };  
    unsigned char key_pad_temp[BLOCK_LEN] = { 0 };  
    size_t i = 0;  
    for (i = 0; i < BLOCK_LEN; i++)  
    {  
        key_pad_temp[i] = key_pad[i] ^ 0x36;  
        key_pad[i] ^= 0x5C;  
    }  
     
		sha1_init( &ctx );
		sha1_starts( &ctx );
		sha1_update( &ctx, key_pad_temp, BLOCK_LEN);
		sha1_update( &ctx, msg, msg_len);
		sha1_finish( &ctx, hash_temp );
		sha1_free( &ctx );

		sha1_init( &ctx );
		sha1_starts( &ctx );
		sha1_update( &ctx, key_pad, BLOCK_LEN);
		sha1_update( &ctx, hash_temp, HASH_LEN);
		sha1_finish( &ctx, hash );
		sha1_free( &ctx );

//    for (uint8_t i = 0; i < 20; i++)  
//    {  
//        const char *hex = "0123456789abcdef";  
//        unsigned char ch = hash[i];  
//        ref_hash[i * 2 + 0] = hex[(ch >> 4U) & 0x0F];  
//        ref_hash[i * 2 + 1] = hex[(ch >> 0U) & 0x0F];  
//    }  

//    ref_hash[40] = 0;
      
			G_1byteTo2str(ref_hash,hash,20);
			ref_hash[40] = 0;
    return;  
} 

//5个参数 第一个PWD是OUTPUT的结果
//第二个 三个参数的RSA 容器是256长
//第四个 第五个参数是MSG 用到蓝牙MAC地址长度12
//最后PWD和TOUCH一样 和MD5一样也是扩大了！
void SHA1TEST(void)
{
	uint8_t pwd[50]={0};uint8_t  rsa[256]={0};
  char  rsaKey[]="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYIZwEfCwjzzsz0bcPzpbyDVrbOXsh/GLRqO7Da9IderDVBpCvOMRFyYNMoB9v2Yv3knwUvOvOh/vyQij6GJi42R2BQ5f8MHw/6u1QSxhNWJOpQAj11PNssOjnacmVL0L7se5qOBED5q7COfRljkeLvMxII57inPLEXQSW0xjoUwIDAQAB";

	char  MAC[12] = {"112233445566"};
	
	memcpy(rsa,rsaKey,strlen(rsaKey));
	
	printf("rsaKey LEN=%d rsa LEN=%d\r\n",strlen(rsaKey),strlen(rsa));
  mbedtls_hmac_sha1(pwd,rsa,strlen(rsa),MAC,12);
	for(int i=0;i<50;i++)
	{
		printf("%02X-",pwd[i]);
	}
		printf("\r\n");
}

 

GKoSon
关注
安全基础学习-SHA-1(Secure Hash Algorithm 1)算法
小夭的博客
08-14 476
消息填充：将消息长度填充到一个满足某种条件（例如512位块）的长度。填充方式通常是先在消息末尾添加一个 1，然后再添加若干个 0，直到消息长度为接近但不超过512的整数倍。最后，消息长度信息也会被附加到填充后的消息中。初始化散列值：SHA-1 使用五个初始散列值 H0、H1、H2、H3 和 H4，这些值都是常量。处理每个数据块：消息分块后，每个块都经过一系列的操作（如扩展、位运算、混合等），并更新中间哈希值。输出最终哈希值：经过所有块的处理后，五个散列值被连接在一起，形成最终的160位哈希值。
SHA1(加密工具类)
07-29
SHA1(加密工具类)，已通过测试.
sha1
jiangchao92的博客
12-20 1210
安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一
什么是SHA-1
cocojiji5的专栏
12-08 1444
 1 SHA1算法简介 安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的 过程中
SHA1详解
xcxhzjl的博客
02-16 4252
哈希（SHA1）算法详解
SHA1 简单介绍以及使用
热门推荐
chelen_jak的专栏
03-19 1万+
原文出处：blog.sina.com.cn/s/blog_a42c4c6c0102woq9.html 安全哈希算法（Secure Hash Algorithm） SHA-1是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信...
Sha1算法c语言实现
最新发布
03-20
SHA1（Secure Hash Algorithm 1）是一种广泛使用的散列函数，设计用于数字签名和消息认证码（MAC）。它由美国国家安全局（NSA）开发，于1993年发布，是SHA-0的增强版。SHA1算法将任意长度的输入（也称为预映射）转换...
sha1:sha1哈希算法
05-04
SHA1Init，SHA1Update，SHA1Final，SHA1Transform 概要 #include #include <sha1> 无效的SHA1Transform（ uint32_t state [5]，const unsigned char buffer [64]）； 无效的SHA1Init（ SHA1_CTX *上下文）; ...
亲测可用115sha1链接怎么使用？115网盘sha1链接转存方法
12-23
115sha1链接怎么使用？现在有很多资源是百度网盘的，但是有时也会遇到115网盘资源，大家想知道获取了多条115sha1链接的情况下如何快速转存资源进行下载，一条一条操作太麻烦了，今天系统之家小编带来了115网盘sha1...
sha1.lua ：（不建议使用的存储库）SHA-1安全哈希计算和Lua中的HMAC-SHA1签名计算（5.1）
02-03
**SHA-1与HMAC-SHA1：基本概念** SHA-1（Secure Hash Algorithm 1）是一种广泛应用于数据完整性验证的加密散列函数。它由美国国家安全局（NSA）设计，可将任意长度的数据转化为固定长度的160位（20字节）哈希值，...
微信小程序 sha1 实现密码加密实例详解
08-30
这个函数使用了 encodeUTF8 函数将字符串转换为 UTF-8 编码，然后使用 sha1 加密算法将 UTF-8 编码转换为十六进制字符串。 知识点4：十六进制字符串的应用 十六进制字符串是加密后的字符串，它可以用于身份验证、...
js sha1.js
07-30
适用于微信公众号的openjssdk的sign前面生成，使用方法 var sha1=SHA1(sign).toLowerCase() 注意微信是小写的
java SHA1加密
07-23
简单的SHA1加密
sha1.js（js版sha1加密）
09-01
sha1.js（js版sha1加密）
安全算法—SHA-1算法
enjoycsdn_YW的博客
07-11 4561
1、什么是SHA-1?SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。SHA-1的特性有以下两点特性，同时也是SHA算法所拥有的共同特性：...
密码学------SHA_1加密的python实现
qq_51048845的博客
04-26 2736
1.算法介绍 SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数 2.源码 import math # 异或算法 def xor_func(a, b): a = bin(a)[2:] b = bin(b)[2:] while l
关于SHA1
牛仔面包
03-23 349
SHA1其实分几种 1.apk的SHA1，可以用下面的工具来查看 版本升级用的是这个2.签名key的SHA1 打开cmd，定位到.android文件夹下，输入cd .android 在cmd中输入下面命令：keytool -list -v -keystore “jsk路径” 输入密码 地图开发用的就是这个
单向散列函数——SHA-1
weixin_44791273的博客
08-21 888
一. 加密算法描述 1. 填充 （a）添加1：在消息末尾添加一个1bit的“1” （b）添加0：添加0直到消息长度为512的整数倍，最后一个512bit的分组的最后64bit需要空出来以保存原始的消息长度。 （c）添加原始的消息长度：消息长度 < 2^64 bit 2. 计算W0~W79 将输入分组的512bit分成32bit*16组，并将它们命名为W0~W15。其他的： 3. 分组处理 通过上述80个步骤的反复执行，SHA-1就能够将已经填充的信息全部混入这160比特的内部状态中，而SHA-1
SHA1算法详解及C语言实现
"这篇资源提供了SHA1算法的源代码，包括了算法的思想原理，对于理解和应用SHA1哈希函数非常有帮助。" SHA1（Secure Hash Algorithm 1）是一种广泛使用的安全散列函数，它能够将任意长度的信息映射为固定长度的输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值