❶ 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升级后，为了安全，默认不再采用原来一些加密算法，我们手工添加进去即可。