hmac演算法

『壹』 hmac-sha256-hex演算法怎麼調用

題主可以考慮使用CryptoJS這個庫，包含很多種加密方式，而且採用了RequireJS，既支持NodeJS服務端也支持普通瀏覽器客戶端。文檔寫的也很詳實。GitHub傳送門：/brix/crypto-js

『貳』 openssl中有沒有HMAC-SHA1，CBC-MAC演算法

openssl支持HMAC-SHA1
命令openssl dgst -sha1 -hmac 'key'
openssl不支持CBC-MAC，可能因為簡單XOR串聯的安全性太差
openssl支持CMAC(Cipher MAC)方法。

『叄』 用C#實現hmac-sha256演算法的代碼如下，為什麼和網上的在線解碼的結果不同

首先你在網頁上輸入的，網頁應該是以字元串來解析，而不是十六進制序列吧。

『肆』 如何C#使用HMAC-SHA1演算法生成oauth

1、HMACSHA1的概念
HMACSHA1 是
從 SHA1 哈希函數構造的一種鍵控哈希演算法，被用作 HMAC（基於哈希的消息驗證代碼）。此 HMAC
進程將密鑰與消息數據混合，使用哈希函數對混合結果進行哈希計算，將所得哈希值與該密鑰混合，然後再次應用哈希函數。輸出的哈希值長度為 160
位，可以轉換為指定位數。
上面是微軟的標準定義，我看了也沒太明白，他的作用一句話來理解：就是確認請求的URL或者參數是否存在被篡改，以QQ
簽名為例：發送方（自己）將參數等進行HMAC演算法計算，將得到的哈希值（即簽名值）與請求的參數一同提交至接收方（QQ端），然後接收方再次將參數等值
進行HMAC演算法計算，將得到的哈希值與你傳遞過來的哈希值進行核對驗證，若一樣，說明請求正確、驗證通過，進行一下步工作，若不一樣，將返回錯誤。
（下面說的夠詳細了吧，還不理解，留言給我）

2、QQ OAuth 1.0中用到的哈希演算法

/// <summary>

/// HMACSHA1演算法加密並返回ToBase64String

/// </summary>

/// <param name="strText">簽名參數字元串</param>

/// <param name="strKey">密鑰參數</param>

/// <returns>返回一個簽名值(即哈希值)</returns>

public static string ToBase64hmac(string strText, string strKey)

{

HMACSHA1 myHMACSHA1 = new HMACSHA1(Encoding.UTF8.GetBytes(strKey));

byte[] byteText = myHMACSHA1.ComputeHash(Encoding.UTF8.GetBytes(strText));

return System.Convert.ToBase64String(byteText);

}
或者寫成，原理一樣：

public static string HMACSHA1Text(string EncryptText, string EncryptKey)
{
//HMACSHA1加密
string message;
string key;
message = EncryptText;
key = EncryptKey;

System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
byte[] keyByte = encoding.GetBytes(key);
HMACSHA1 hmacsha1 = new HMACSHA1(keyByte);
byte[] messageBytes = encoding.GetBytes(message);
byte[] hashmessage = hmacsha1.ComputeHash(messageBytes);

return ByteToString(hashmessage);
}

前面都注釋了參數含義，就不再說明了。COPY就可使用

註明：頁面請引用
using System.Security.Cryptography;

3、介紹另外一種HMACSHA1演算法的寫法

public static string HMACSHA1Text(string EncryptText, string EncryptKey)

{
//HMACSHA1加密
HMACSHA1 hmacsha1 = new HMACSHA1();
hmacsha1.Key = System.Text.Encoding.UTF8.GetBytes(EncryptKey);

byte[] dataBuffer = System.Text.Encoding.UTF8.GetBytes(EncryptText);
byte[] hashBytes = hmacsha1.ComputeHash(dataBuffer);
return Convert.ToBase64String(hashBytes);
}

『伍』 hmac sha256和sha256的區別

兩者是一樣的。hmac是Hash-based Message Authentication Code的簡寫，就是指哈希消息認證碼，包含有很多種哈希加密演算法，sha256是其中一種。

『陸』 函數HMAC-SHA1

HMAC
根據RFC 2316(Report of the IAB，April 1998)，HMAC(散列消息身份驗證碼: Hashed Message Authentication Code)以及IPSec被認為是Interact安全的關鍵性核心協議。它不是散列函數，而是採用了將MD5或SHA1散列函數與共享機密密鑰(與公鑰／私鑰對不同)一起使用的消息身份驗證機制。基本來說，消息與密鑰組合並運行散列函數。然後運行結果與密鑰組合並再次運行散列函數。這個128位的結果被截斷成96位，成為MAC.
hmac主要應用在身份驗證中，它的使用方法是這樣的：
1. 客戶端發出登錄請求（假設是瀏覽器的GET請求）
2. 伺服器返回一個隨機值，並在會話中記錄這個隨機值
3. 客戶端將該隨機值作為密鑰，用戶密碼進行hmac運算，然後提交給伺服器
4. 伺服器讀取用戶資料庫中的用戶密碼和步驟2中發送的隨機值做與客戶端一樣的hmac運算，然後與用戶發送的結果比較，如果結果一致則驗證用戶合法
在這個過程中，可能遭到安全攻擊的是伺服器發送的隨機值和用戶發送的hmac結果，而對於截獲了這兩個值的黑客而言這兩個值是沒有意義的，絕無獲取用戶密碼的可能性，隨機值的引入使hmac只在當前會話中有效，大大增強了安全性和實用性。大多數的語言都實現了hmac演算法，比如php的mhash、python的hmac.py、java的MessageDigest類，在web驗證中使用hmac也是可行的，用js進行md5運算的速度也是比較快的。
SHA
安全散列演算法SHA(Secure Hash Algorithm)是美國國家標准和技術局發布的國家標准FIPS PUB 180-1，一般稱為SHA-1。其對長度不超過264二進制位的消息產生160位的消息摘要輸出，按512比特塊處理其輸入。
SHA是一種數據加密演算法，該演算法經過加密專家多年來的發展和改進已日益完善，現在已成為公認的最安全的散列演算法之一，並被廣泛使用。該演算法的思想是接收一段明文，然後以一種不可逆的方式將它轉換成一段（通常更小）密文，也可以簡單的理解為取一串輸入碼（稱為預映射或信息），並把它們轉化為長度較短、位數固定的輸出序列即散列值（也稱為信息摘要或信息認證代碼）的過程。散列函數值可以說時對明文的一種「指紋」或是「摘要」所以對散列值的數字簽名就可以視為對此明文的數字簽名。
HMAC_SHA1
HMAC_SHA1(Hashed Message Authentication Code, Secure Hash Algorithm)是一種安全的基於加密hash函數和共享密鑰的消息認證協議。它可以有效地防止數據在傳輸過程中被截獲和篡改，維護了數據的完整性、可靠性和安全性。HMAC_SHA1消息認證機制的成功在於一個加密的hash函數、一個加密的隨機密鑰和一個安全的密鑰交換機制。
HMAC_SHA1 其實還是一種散列演算法,只不過是用密鑰來求取摘要值的散列演算法。
HMAC_SHA1演算法在身份驗證和數據完整性方面可以得到很好的應用，在目前網路安全也得到較好的實現。

『柒』 求網頁端的JavaScript的HMAC-SHA1加密演算法。最近遇到了需要一些加密演算法的地方，然而

題主可以考慮使用 CryptoJS 這個庫，包含很多種加密方式，而且採用了 RequireJS，既支持 NodeJS 服務端也支持普通瀏覽器客戶端。文檔寫的也很詳實。

GitHub 傳送門：https://github.com/brix/crypto-js

『捌』 hmacsha256可逆嗎

hmacsha256可逆。

對數據解密破解就是找到任意一個源數據，能夠生成相同的目標數據。SHA256基本上是不可破解的，即找不到（或概率極小）「碰撞」結果。

網站的解密規則：網站從瀏覽器發送過來的信息當中選出一組加密演算法與HASH演算法，並將自己的身份信息以證書的形式發回給瀏覽器。證書裡麵包含了網站地址，加密公鑰，以及證書的頒發機構等信息。

在HMAC規劃之初，就有以下設計目標：

1、不必修改而直接套用已知的散列函數，並且很容易得到軟體上執行速度較快的散列函數及其代碼。

2、若找到或需要更快或更安全的散列函數，能夠容易地代替原來嵌入的散列函數。

3、應保持散列函數的原來性能，不能因為嵌入在HMAC中而過分降低其性能。

4、對密鑰的使用和處理比較簡單。

5、如果已知嵌入的散列函數強度，則完全可以推斷出認證機制抵抗密碼分析的強度。

『玖』 sha1 的hmac演算法c++的 今晚急求！！！！！

HMACSHA1.h文件

#ifndef _IPSEC_SHA1_H_
#define _IPSEC_SHA1_H_
typedef unsigned long__u32;
typedef char__u8;
typedef struct
{
__u32 state[5];
__u32 count[2];
__u8 buffer[64];
} SHA1_CTX;
#if defined(rol)
#undef rol
#endif
#define SHA1HANDSOFF
#define __LITTLE_ENDIAN
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding ring the round function from SSLeay */
#ifdef __LITTLE_ENDIAN
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|(rol(block->l[i],8)&0x00FF00FF))
#else
#define blk0(i) block->l[i]
#endif
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
^block->l[(i+2)&15]^block->l[i&15],1))
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
/* Hash a single 512-bit block. This is the core of the algorithm. */
void SHA1Transform(__u32 state[5], __u8 buffer[64]);
void SHA1Init(SHA1_CTX *context);
void SHA1Update(SHA1_CTX *context, char *data, __u32 len);
void SHA1Final( char digest[20], SHA1_CTX *context);
//void hmac_sha1(unsigned char *to_mac,unsigned int to_mac_length, unsigned char *key,unsigned int key_length, unsigned char *out_mac);
void SHA1_Encode
(
char* k, /* secret key */
int lk, /* length of the key in bytes */
char* d, /* data */
int ld, /* length of data in bytes */
char* out, /* output buffer, at least "t" bytes */
int t
);

#endif /* _IPSEC_SHA1_H_ */

HMACSHA1.cpp 文件

#include"stdafx.h"
#include "HMACSHA1.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#ifndef SHA_DIGESTSIZE
#define SHA_DIGESTSIZE 20
#endif
#ifndef SHA_BLOCKSIZE
#define SHA_BLOCKSIZE 64
#endif
/* Hash a single 512-bit block. This is the core of the algorithm. */
void SHA1Transform(__u32 state[5], __u8 buffer[64])
{
__u32 a, b, c, d, e;
typedef union {
unsigned char c[64];
__u32 l[16];
} CHAR64LONG16;
CHAR64LONG16* block;
#ifdef SHA1HANDSOFF
static unsigned char workspace[64];
block = (CHAR64LONG16*)workspace;
// NdisMoveMemory(block, buffer, 64);
memcpy(block, buffer, 64);
#else
block = (CHAR64LONG16*)buffer;
#endif
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
/* Wipe variables */
a = b = c = d = e = 0;
}
/* SHA1Init - Initialize new context */
void SHA1Init(SHA1_CTX* context)
{
/* SHA1 initialization constants */
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void SHA1Update(SHA1_CTX* context, char* data, __u32 len)
{
__u32 i, j;
j = context->count[0];
if ((context->count[0] += len << 3) < j)
context->count[1]++;
context->count[1] += (len>>29);
j = (j >> 3) & 63;
if ((j + len) > 63) {
// NdisMoveMemory(&context->buffer[j], data, (i = 64-j));
memcpy(&context->buffer[j], data, (i = 64-j));
SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64) {
SHA1Transform(context->state, &data[i]);
}
j = 0;
}
else i = 0;
// NdisMoveMemory(&context->buffer[j], &data[i], len - i);
memcpy(&context->buffer[j], &data[i], len - i);
}
/* Add padding and return the message digest. */
void SHA1Final( char digest[20], SHA1_CTX* context)
{
__u32 i, j; char finalcount[8];
for (i = 0; i < 8; i++) {
finalcount[i] = ( char)((context->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
}
SHA1Update(context, ( char *)"\200", 1);
while ((context->count[0] & 504) != 448) {
SHA1Update(context, ( char *)"\0", 1);
}
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
for (i = 0; i < 20; i++) {
digest[i] = ( char)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
/* Wipe variables */
i = j = 0;
// NdisZeroMemory(context->buffer, 64);
// NdisZeroMemory(context->state, 20);
// NdisZeroMemory(context->count, 8);
// NdisZeroMemory(&finalcount, 8);
memset(context->buffer, 0x00, 64);
memset(context->state, 0x00, 20);
memset(context->count, 0x00, 8);
memset(&finalcount, 0x00, 8);

#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite its own static vars */
SHA1Transform(context->state, context->buffer);
#endif
}
void truncate
(
char* d1, /* data to be truncated */
char* d2, /* truncated data */
int len /* length in bytes to keep */
)
{
int i ;
for (i = 0 ; i < len ; i++) d2[i] = d1[i];
}
/* Function to compute the digest */
void SHA1_Encode
(
char* k, /* secret key */
int lk, /* length of the key in bytes */
char* d, /* data */
int ld, /* length of data in bytes */
char* out, /* output buffer, at least "t" bytes */
int t
)
{
SHA1_CTX ictx, octx ;
char isha[SHA_DIGESTSIZE], osha[SHA_DIGESTSIZE] ;
char key[SHA_DIGESTSIZE] ;
char buf[SHA_BLOCKSIZE] ;
int i ;
if (lk > SHA_BLOCKSIZE) {
SHA1_CTX tctx ;
SHA1Init(&tctx) ;
SHA1Update(&tctx, k, lk) ;
SHA1Final(key, &tctx) ;
k = key ;
lk = SHA_DIGESTSIZE ;
}
/**** Inner Digest ****/
SHA1Init(&ictx) ;
/* Pad the key for inner digest */
for (i = 0 ; i < lk ; ++i) buf[i] = k[i] ^ 0x36 ;
for (i = lk ; i < SHA_BLOCKSIZE ; ++i) buf[i] = 0x36 ;
SHA1Update(&ictx, buf, SHA_BLOCKSIZE) ;
SHA1Update(&ictx, d, ld) ;
SHA1Final(isha, &ictx) ;
/**** Outter Digest ****/
SHA1Init(&octx) ;
/* Pad the key for outter digest */
for (i = 0 ; i < lk ; ++i) buf[i] = k[i] ^ 0x5C ;
for (i = lk ; i < SHA_BLOCKSIZE ; ++i) buf[i] = 0x5C ;
SHA1Update(&octx, buf, SHA_BLOCKSIZE) ;
SHA1Update(&octx, isha, SHA_DIGESTSIZE) ;
SHA1Final(osha, &octx) ;
/* truncate and print the results */
t = t > SHA_DIGESTSIZE ? SHA_DIGESTSIZE : t ;
truncate(osha, out, t) ;
}
//int main()
//{
//char k[1024],d[1024],out[1024];
//int lk,ld,t;
//strcpy(d,"what do ya want for nothing?");
//strcpy(k,"Jefe");
//lk=strlen(k);
//ld=strlen(d);
//printf("lk=%d\n",lk);
//printf("ld=%d\n",ld);
//t=20;
//hmac_sha(k,lk,d,ld,out,t);
//
//return 0;
//}

調用方法：
SHA_RESULTSIZE =20;

char paramSrc[1024]="aaa";
char keySrc[100]="bbbb";
char sha1Str[SHA_RESULTSIZE] = "";

SHA1_Encode(keySrc,strlen(keySrc),paramSrc,strlen(paramSrc),sha1Str,sizeof(sha1Str));

sha1Str就是最終的值。