『壹』 求網頁端的javaScript的HMAC-SHA1加密演算法。最近遇到了需要一些加密演算法的地方，然而
題主可以考慮使用 CryptoJS 這個庫，包含很多種加密方式，而且採用了 RequireJS，既支持 NodeJS 服務端也支持普通瀏覽器客戶端。文檔寫的也很詳實。
GitHub 傳送門：https://github.com/brix/crypto-js
『貳』 關於HAMACSHA1加密演算法的問題
HmacSHA1聲明了演算法
RAW是個沒有作用的名稱，在某些密鍵關系不大的演算法能頂用吧。
指定一條密鍵的內容和演算法。
『叄』 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就是最終的值。
『肆』 如何用asp.net寫hmac-sha1演算法
用JQ寫的
/**
*@brief使用HMAC-SHA1演算法生成oauth_signature簽名值
*
*@param$key密鑰
*@param$str源串
*
*@return簽名值
*/
functiongetSignature($str,$key){
$signature="";
if(function_exists('hash_hmac')){
$signature=base64_encode(hash_hmac("sha1",$str,$key,true));
}else{
$blocksize=64;
$hashfunc='sha1';
if(strlen($key)>$blocksize){
$key=pack('H*',$hashfunc($key));
}
$key=str_pad($key,$blocksize,chr(0x00));
$ipad=str_repeat(chr(0x36),$blocksize);
$opad=str_repeat(chr(0x5c),$blocksize);
$hmac=pack(
'H*',$hashfunc(
($key^$opad).pack(
'H*',$hashfunc(
($key^$ipad).$str
)
)
)
);
$signature=base64_encode($hmac);
}
return$signature;
}
『伍』 函數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演算法在身份驗證和數據完整性方面可以得到很好的應用，在目前網路安全也得到較好的實現。
『陸』 openssl中有沒有HMAC-SHA1，CBC-MAC演算法
1、HMACSHA1概念
HMACSHA1
SHA1 哈希函數構造種鍵控哈希算用作 HMAC（基於哈希消息驗證代碼） HMAC
進程密鑰與消息數據混合使用哈希函數混合結進行哈希計算所哈希值與該密鑰混合再應用哈希函數輸哈希值度 160
位轉換指定位數
面微軟標準定義我看沒太明白作用句理解：確認請求URL或者參數否存篡改QQ
簽名例：發送（自）參數等進行HMAC算計算哈希值（即簽名值）與請求參數同提交至接收（QQ端）接收再參數等值
進行HMAC算計算哈希值與傳遞哈希值進行核驗證若說明請求確、驗證通進行步工作若返錯誤
（面說夠詳細吧理解留言給我）
2、QQ OAuth 1.0用哈希算
///
/// HMACSHA1算加密並返ToBase64String
///
/// 簽名參數字元串
/// 密鑰參數
/// 返簽名值(即哈希值)
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在Java中相當於一個Python的例子嗎
1. HMACSHA1似乎是你所需要的演算法：SecretKeySpec keySpec = new SecretKeySpec(
"".getBytes(),
"HmacSHA1");
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(keySpec);
byte[] result = mac.doFinal("foo".getBytes());
BASE64Encoder encoder = new BASE64Encoder();
System.out.println(encoder.encode(result));
生產：+3h2gpjf4xcynjCGU5lbdMBwGOc=
請注意，我sun.misc.BASE64Encoder為迅速在這里，但你應該不依賴於太陽的JRE。以base64編碼器在下議院編解碼器將是一個更好的選擇，例如。
2. A小調的事情，但如果你正在尋找一個相當於HMAC（那麼默認的Python庫的MD5演算法，所以你需要的HMACMD5演算法在Java中。 這個我有這個確切的問題，並認為此答案這是有幫助的 CodeGo.net，但我錯過了一個地方傳遞到HMAC（）的一部分，並就下一個兔子洞。希望這個答案可以防止其他人做的未來。 例如在Python REPL>>> import hmac
>>> hmac.new("keyValueGoesHere", "secretMessageToHash").hexdigest()
''
這等效於import org.apache.commons.codec.binary.Hex;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
public class HashingUtility {
public static String HMAC_MD5_encode(String key, String message) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(
key.getBytes(),
"HmacMD5");
Mac mac = Mac.getInstance("HmacMD5");
mac.init(keySpec);
byte[] rawHmac = mac.doFinal(message.getBytes());
return Hex.encodeHexString(rawHmac);
}
}
請注意，在我的例子我在干什麼。hexdigest相當於（）
『捌』 openssl中有沒有HMAC-SHA1，CBC-MAC演算法
openssl支持HMAC-SHA1
命令openssl dgst -sha1 -hmac 'key'
openssl不支持CBC-MAC，可能因為簡單XOR串聯的安全性太差
openssl支持CMAC(Cipher MAC)方法。
『玖』 php hash_hmac如何解密
hmac演算法的主體還是散列函數，散列演算法本身是抽取數據特徵，是不可逆的。
所以「再得到aaa」——「逆運算獲得原數據」這種想法，是不符合hmac設計初衷，可以看成是對hmac安全性的直接挑戰，屬於解密，屬於誤用。
類似的需求，應該使用AES加密演算法實現
『拾』 c#hmacsha1 和 crypto-js 的區別
c#中hmacsha1 和 crypto-js 的區別如下：
1.從定義看：
HMAC是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code）,HMAC運算利用哈希演算法，以一個密鑰和一個消息為輸入，生成一個消息摘要作為輸出。可以看出，HMAC是需要一個密鑰的。所以，HMAC_SHA1也是需要一個密鑰的，而SHA1不需要。
2、從應用場合：
crypto-js庫使用範例：
MD5加密：
<script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/rollups/md5.js"></script>
<script>
var hash = CryptoJS.MD5("Message");
</script>
SHA1加密演示
<script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/rollups/sha1.js"></script>
<script>
var hash = CryptoJS.SHA1("Message");
</script>
SHA2加密演示
<script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/rollups/sha256.js"></script>
<script>
var hash = CryptoJS.SHA256("Message");
</script>
Progressive Hashing
view sourceprint?
<script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/rollups/sha256.js"></script>
<script>
var sha256 = CryptoJS.algo.SHA256.create();
sha256.update("Message Part 1");
sha256.update("Message Part 2");
sha256.update("Message Part 3");
var hash = sha256.finalize();
</script>