❶ 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就是最終的值。
❷ nodejs裡面怎麼實現HMAC-SHA1
1）crypto模塊
crypto.createHmac('sha1',app_secret).update('待加密字串').digest().toString('base64');//base64
crypto.createHmac('sha1',app_secret).update('待加密字串').digest('hex');//16進制
2）crypto-js
varCryptoJS=require('crypto-js');
varstr='orderId=21140600050549799429&orderStatus=TRADE_SUCCESS&payTime=2014-07-2211:43:31';
varkey='REzySUKRCPfyfV/jfgwTA==';
varsign=CryptoJS.HmacSHA1(str,key).toString();
console.log(sign);
❸ openssh網路安全分析
SSH協議出現之前，在網路設備管理上廣泛應用的一種方式是Telnet。Telnet協議的優勢在於通過它可以遠程地虧滲脊登錄到網路設備上，對網路設備進行配置，為網路管理員異地管理網路設備提供了極大的方便。但是，Telnet協議存在三個致命的弱點：
A、明文傳輸：數據傳輸採用明文方式，傳輸的數據沒有任何機密性可言。
B、認證機制脆弱。用戶的認證信息在網路上以明文方式傳輸，很容易被竊聽； Telnet 只支持傳統的密碼認證方式，很容易被攻擊。
C、「偽伺服器欺騙」：客戶端無法真正識別伺服器的身份，攻擊者很容易進行「偽伺服器欺騙」。SSH協議正是為了克服Telnet協議存在的問題而誕生的。
D、數據傳輸過程被篡改，無法保證傳輸過程數據完整性
ssh如果解決上述幾個安全問題？我們一個個來分析
通過 在 通信雙方建立「加密通道」，保證傳輸的數據不被竊聽。並且需要有合適的手段保證通信雙方秘鑰的安全
所謂加密喊虛通道，是指發送方在發送數據前，使用加密密鑰對數據進行加密，然後將
數據發送給對方；接收方接收到數據後，利用解密密鑰從密文中獲取明文。
加解密演算法分為兩類： 對稱密鑰演算法：數據加密和解密時使用相同的密鑰和相同的演算法。 非對稱密鑰演算法：數據加密和解密時使用不同的密鑰，一個是公開的公鑰，
一個是由用戶秘密保存的私鑰。
由於非對稱密鑰演算法比較耗時，一般多用於數字簽名以及身份認證。SSH加密通道
上的數據加解密使用對稱密鑰演算法，目前主要支持的演算法有DES、3DES、AES
等，這些演算法都可以有效地防止交互數據被竊聽，而且由於採用了初始化向量保
護，可以防止類似於密碼流復用等密碼分析工具的攻擊。
對稱密鑰演算法要求解密密鑰和銷滲加密密鑰完全一致，才能順利從密文中解密得到明
文。因此，要建立加密通道，必須先在通信雙方部署一致的加解密密鑰。部署加解
密密鑰的方式有多種：手工配置和第三方機構分配等。手工配置的方式擴展性差，
只適合一些小型的本地網路；使用第三方機構分配密鑰的方式，需要額外的第三方
伺服器，而且密鑰在網路中傳輸容易被竊聽。
SSH協議使用一種安全的方式在通信雙方部署密鑰：密鑰交換演算法。利用密鑰交換
演算法可以在通信雙方動態地產生密鑰，這個密鑰只能被通信的雙方獲得，任何第三
者都無法竊聽，這就在源頭上保證了加解密使用密鑰的安全性，很好地解決了密鑰
分發問題。
支持的數據加密演算法有：
3des-cbc
aes128-cbc
aes192-cbc
aes256-cbc
aes128-ctr
aes192-ctr
aes256-ctr
[email protected]
[email protected]
[email protected]
默認使用的演算法：
[email protected],
aes128-ctr,aes192-ctr,aes256-ctr,
[email protected],[email protected]
可以通過關鍵字 「 Ciphers」指定使用的演算法，多個演算法間，需要使用逗號相隔
有三種方式指定演算法
方式一：Ciphers 關鍵字後接演算法名稱，比如：Ciphers aes256-ctr，aes192-ctr表示只使用
aes256-ctr，aes192-ctr兩種演算法
方式二：Ciphers 關鍵字後接演算法名稱，並且演算法名稱前帶上「+」，表示在默認演算法基礎上，新增「+」後的演算法
方式三：Ciphers 關鍵字後接演算法名稱，並且演算法名稱前帶上「-」，表示在默認演算法基礎上，裁剪「-」後的演算法
支持的密鑰交換演算法有：
curve25519-sha256
[email protected]
diffie-hellman-group1-sha1
diffie-hellman-group14-sha1
diffie-hellman-group-exchange-sha1
diffie-hellman-group-exchange-sha256
ecdh-sha2-nistp256
ecdh-sha2-nistp384
ecdh-sha2-nistp521
默認使用的密鑰交換演算法有：
curve25519-sha256,[email protected],
ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,
diffie-hellman-group-exchange-sha256,
diffie-hellman-group14-sha1
可以通過關鍵字 「
KexAlgorithms 」指定使用的演算法，多個演算法間，需要使用 逗號相隔
有三種方式指定演算法
方式一：KexAlgorithms關鍵字後接演算法名稱，比如：KexAlgorithms
diffie-hellman-group-exchange-sha256，diffie-hellman-group14-sha1
表示只使用diffie-hellman-group-exchange-sha256，diffie-hellman-group14-sha1
兩種演算法
方式二：KexAlgorithms關鍵字後接演算法名稱，並且演算法名稱前帶上「+」，表示在默認演算法基礎上，新增「+」後的演算法
方式三：KexAlgorithms關鍵字後接演算法名稱，並且演算法名稱前帶上「-」，表示在默認演算法基礎上，裁剪「-」後的演算法
傳統的方式，採用的是密碼認證模式：用戶在ssh客戶端輸入賬號、密碼，openssh完成對登錄用戶進行密碼認證。用戶的身份信息等關鍵數據都保存在認證伺服器上
由於密碼認證方式的認證強度較弱，SSH協議引入了公鑰認證方式。目前，openssh
可以利用RSA和DSA兩種非對稱密鑰演算法實現公鑰認證。
公鑰認證的過程分為兩個部分：：
(1) 公鑰驗證：客戶端首先將自己本地密鑰對的公鑰部分，按照字元串格式發送
到伺服器。伺服器使用本地保存的客戶端公鑰，與報文中攜帶的客戶端公鑰
進行比較，驗證客戶端持有公鑰的正確性。
(2) 數字簽名驗證：如果公鑰驗證成功，客戶端繼續使用自己本地密鑰對的私鑰
部分，對特定報文進行摘要運算，將所得的結果（即數字簽名）發送給服務
器，向伺服器證明自己的身份；伺服器使用預先配置的該用戶的公鑰，對客
戶端發送過來的數字簽名進行驗證。
公鑰驗證和數字簽名驗證中任何一個驗證失敗，都會導致本次公鑰認證失敗。
AuthenticationMethods
PubkeyAuthentication：是否使用公鑰認證，默認為yes
UsePAM:該關鍵字只有在移植版中支持，PAM為「可插拔認證模塊」，用於
PubkeyAcceptedKeyTypes：公鑰認證演算法
[email protected], [email protected], [email protected], [email protected], [email protected], ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521, ssh-ed25519,ssh-rsa
公鑰認證配置方法：
1. 首先，在客戶端生成一個對鑰：
# ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
fa:49:6c:0a:90:0e:0f:57:2e:21:79:f6:65:7f:8d:42
這里我們用的是rsa演算法,我們也可以使用dsa演算法：
ssh-keygen -t dsa
從上面可以看到，提示輸入私鑰的保護密碼，我們也可以不選，直接ENTER就行了！
現在密鑰已經生成：
id_rsa(私鑰) id_rsa.pub(公鑰)
如果是dsa演算法生成的話：
id_dsa id_dsa.pub
2. 我們將公鑰傳到伺服器的.ssh目錄下.
scp id_rsa.pub user@hostname:/home/user/.ssh/authorized_keys
3. 將/etc/ssh/sshd_config
中的rsa認證功能打開.(去掉注釋)
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys
然後重新啟動sshd就行了.
如果是dsa演算法的話同理.
疑問：公鑰認證，是否使用了PAM？還是openssh自己搞的？
可插拔認證模塊的介紹：
http://www.infoq.com/cn/articles/wjl-linux-pluggable-authentication-mole
http://www.infoq.com/cn/articles/linux-pam-one
ChrootDirectory：
Specifies
2.3.1 原理
用戶認證機制只實現了伺服器端對客戶端的認證，而客戶端無法認證伺服器端，因
此存在著「偽伺服器欺騙」的安全隱患。
圖4 偽伺服器欺騙
如圖4所示，當客戶端主機需要與伺服器建立連接時，第三方攻擊者冒充真正的服
務器，與客戶端進行數據交互，竊取客戶端主機的安全信息，並利用這些信息去登
錄真正的伺服器，獲取伺服器資源，或對伺服器進行攻擊。
為了防止類似這樣的偽伺服器欺騙，SSH協議支持客戶端對伺服器端進行認證。服
務器端在密鑰交換階段，使用自己的私鑰對一段固定格式的數據進行數字簽名，並
將該簽名發往客戶端，客戶端使用本地保存的伺服器公鑰，對簽名進行鑒別，從而
達到認證伺服器的目的。
HostKey
HostKeyAlgorithms
[email protected], [email protected], [email protected], [email protected], [email protected], ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521, ssh-ed25519,ssh-rsa
Macs
支持的消息認證碼（Mac）演算法有：
hmac-md5
hmac-md5-96
hmac-sha1hmac-sha1-96
hmac-sha2-256
hmac-sha2-512
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
默認使用的密鑰交換演算法有：
[email protected],[email protected],
[email protected],[email protected],
[email protected],
[email protected],[email protected],
hmac-sha2-256,hmac-sha2-512,hmac-sha1
可以通過關鍵字 「Macs 」指定使用的演算法，多個演算法間，需要使用 逗號相隔
有三種方式指定演算法
方式一：Macs關鍵字後接演算法名稱，比如：KexAlgorithms
hmac-sha2-256，hmac-sha2-512
表示只使用hmac-sha2-256，hmac-sha2-512
兩種演算法
方式二：Macs關鍵字後接演算法名稱，並且演算法名稱前帶上「+」，表示在默認演算法基礎上，新增「+」後的演算法
方式三：Macs關鍵字後接演算法名稱，並且演算法名稱前帶上「-」，表示在默認演算法基礎上，裁剪「-」後的演算法
openssh通過 以下4類演算法，保證傳輸過程網路安全：
A、傳輸數據加密：傳輸加密演算法，密鑰協商演算法，
B、公鑰認證演算法
C、Mac演算法
❹ 如何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);
}
❺ openssl中有沒有HMAC-SHA1，CBC-MAC演算法
openssl支持HMAC-SHA1
命令openssl dgst -sha1 -hmac 'key'
openssl不支持CBC-MAC，可判虧能因為簡單XOR串聯的安全掘豎神性太差
openssl支持CMAC(Cipher MAC)方法纖咐。
❻ AK/SK【HMAC】 認證
1. 客戶端需要在認證伺服器中預先申請 AK 和 SK
2. 在調用 API 的時候，除傳遞請求必要的參數之外，還需要傳輸一個通過 HMAC 演算法生成的一個簽名串【簽名串的生成方法後面講】
3. 伺服器通過預先留存的 AK 和 SK 進行同樣的摘要演算法計算，得到衫埋的結果與客戶端傳輸的額外的參數進行比對，如果一致，則認為該請求是有效的；否則將拒絕處理這次請求，並返回 HTTP 403
假設請求的 URL 格式為 https://.com/gate/move/?c=2&b=1
目前的實現方式無法抵禦重放攻擊；因此我們需要在簽名時放入一下干擾信息
在業界標准中解決這個問題有兩種典型的做法
1)質疑/應答演算法【OCRA: OATH Challenge-Response Algorithm】
質疑/應答演算法需要預先客戶端先請求一次伺服器，獲得 HTTP 狀態碼為 401 未認證的返回，並得到一個隨機字元串（nonce）。將 nonce 附加到按照上面說到的方法襪卜進行 HMAC_SHA1 簽名，伺服器使用預先分配的 nonce 同樣進行簽名校驗，這個 nonce 在伺服器只會被使用一次【當然你可以給這個nonce設置一個有效期，只要在有效期之內均可以使用】，因此可以提供唯一的摘要
2）timestamp+nonce方案
nonce 指唯一的隨機字元串，用來標識每個被簽名的請求，通常為每個請求提供一個唯一的標識符，伺服器能夠防止請求被多次使用【記錄所有用過的 nonce 以阻止它們被二次使用】；但是對於伺服器永久存儲所有接收到的 nonce 的代價非常大，因此可以通過 timestamp 配合 nonce 進行優化
假設客戶端和服務端最多能存在或好螞 1 分鍾的時間差；服務端需要記錄客戶端所有的 nonce 請求集合，當有新的請求進來後，檢測當前攜帶的 nonce 是否在集合中存在；
如果不存在，則記錄該 nonce 的值，有效期為 1分鍾；
如果存在，則說明客戶端在一分鍾內進行了重復的請求，則拒絕服務；
❼ 函數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演算法在身份驗證和數據完整性方面可以得到很好的應用，在目前網路安全也得到較好的實現。
❽ HmacSHA1 演算法
「HMAC是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code）,HMAC運算櫻伏利用哈希演算法，以一個核態密鑰和一個消息為輸入，生成一個消息摘要作為輸出。」
可以看出，HMAC是需要一個密鑰的改頌源。所以，HMAC_SHA1也是需要一個密鑰的，而SHA1不需要。
❾ 解決SSH連接server responded 「Algorithm negotiation failes」錯誤
環境：
ssh secure shell clien t 3.2.9 + PC win 10 + 遠程主機 Linux Ubuntu4.4.0
如題游辯：新建連接之後彈出server responded 「Algorithm negotiation failes」錯誤
解決：
在Linux主機上編輯sshd_config，執行命令
sudo vi /etc/ssh/sshd_config
在配置文件末尾添加
Ciphers aes128-cbc,aes192-cbc,aes256-cbc,aes128-ctr,aes192-ctr,aes256-ctr,3des-cbc,arcfour128,arcfour256,arcfour,blowfish-cbc,cast128-cbc
MACs hmac-md5,hmac-sha1,[email protected],hmac-ripemd160,hmac-sha1-96,hmac-md5-96
KexAlgorithms diffie-hellman-group1-sha1,diffie-hellman-group14-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group-exchange-sha256,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group1-sha1,[email protected]
重啟sshd服務
sudo etc/init.d/ssh restart
連接正常
報錯原因：ssh升級後，為了安全數和，默認不再採用原來一些加密演算法，需要手工神畢缺添加進去
❿ win10系統下，ssh連接虛擬機linux出現以下錯誤如何解決
ssh
client
報
algorithm
negotiation
failed的解決方法之一
修改sshd的配置文件
/etc/ssh/sshd_config
在配置文件中添加：
Ciphers
aes128-cbc,aes192-cbc,aes256-cbc,aes128-ctr,aes192-ctr,aes256-ctr,3des-cbc,arcfour128,arcfour256,arcfour,blowfish-cbc,cast128-cbc
MACs
hmac-md5,hmac-sha1,[email protected],hmac-ripemd160,hmac-sha1-96,hmac-md5-96
KexAlgorithms
diffie-hellman-group1-sha1,diffie-hellman-group14-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group-exchange-sha256,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group1-sha1,[email protected]
重啟sshd服務後，即可正常連接。
導致此問題的原因是ssh升級後，為了安全，默認不再採用原來一些加密演算法，我們手工添加進去即可。