【SHA1】求加密代码

Question

求Win32 的SHA1的加密算法，得到的结果和下面这段java代码的结果一致。：import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;import org.apache.commons.codec.binary.Base64;
public class HMAC_SHA1 {
public static void main(String[] args) {
System.out.println(base64sha1("message", "234123"));
}

public static String base64sha1(String str, String key) {
try {
String Algorithm = "HmacSHA1";
SecretKey sk = new SecretKeySpec(key.getBytes(), Algorithm);
Mac mac = Mac.getInstance(Algorithm);
mac.init(sk);
byte[] result = mac.doFinal(str.getBytes());

for (byte b : result) {
System.out.print(b);
System.out.print(" ");
}
return new String(Base64.encodeBase64(result));
} catch (NoSuchAlgorithmException e) {

e.printStackTrace();
} catch (InvalidKeyException e) {

e.printStackTrace();
}
return key;
}}我参考了很多代码，都不行
比如这个。

Answer 1

甘草哥在搞邮件系统还是什么？贴一下上述代码的输出：
34 36 -18 117 1 -101 30 105 -83 113 -85 116 41 -30 -110 -13 53 0 58 69 IiTudQGbHmmtcat0KeKS8zUAOkU=

Answer 2

对字符串进行sha1加密不知道是否合适

Answer 3

//sha1.h：对字符串进行sha1加密
#ifndef _SHA1_H_
#define _SHA1_H_
typedef struct SHA1Context{
unsigned Message_Digest[5];      
unsigned Length_Low;             
unsigned Length_High;            
unsigned char Message_Block[64]; 
int Message_Block_Index;         
int Computed;                    
int Corrupted;                   
} SHA1Context;void SHA1Reset(SHA1Context *);
int SHA1Result(SHA1Context *);
void SHA1Input( SHA1Context *,const char *,unsigned);
#endif
#define SHA1CircularShift(bits,word) ((((word) << (bits)) & 0xFFFFFFFF) | ((word) >> (32-(bits))))void SHA1ProcessMessageBlock(SHA1Context *);
void SHA1PadMessage(SHA1Context *);void SHA1Reset(SHA1Context *context){// 初始化动作
context->Length_Low             = 0;
context->Length_High            = 0;
context->Message_Block_Index    = 0; context->Message_Digest[0]      = 0x67452301;
context->Message_Digest[1]      = 0xEFCDAB89;
context->Message_Digest[2]      = 0x98BADCFE;
context->Message_Digest[3]      = 0x10325476;
context->Message_Digest[4]      = 0xC3D2E1F0; context->Computed   = 0;
context->Corrupted  = 0;
}
int SHA1Result(SHA1Context *context){// 成功返回1，失败返回0
if (context->Corrupted) {
return 0;
}
if (!context->Computed) {
SHA1PadMessage(context);
context->Computed = 1;
}
return 1;
}
void SHA1Input(SHA1Context *context,const char *message_array,unsigned length){
if (!length) return; if (context->Computed || context->Corrupted){
context->Corrupted = 1;
return;
} while(length-- && !context->Corrupted){
context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF); context->Length_Low += 8; context->Length_Low &= 0xFFFFFFFF;
if (context->Length_Low == 0){
context->Length_High++;
context->Length_High &= 0xFFFFFFFF;
if (context->Length_High == 0) context->Corrupted = 1;
} if (context->Message_Block_Index == 64){
SHA1ProcessMessageBlock(context);
}
message_array++;
}
}void SHA1ProcessMessageBlock(SHA1Context *context){
const unsigned K[] = {0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
int         t;                
unsigned    temp;             
unsigned    W[80];            
unsigned    A, B, C, D, E;     for(t = 0; t < 16; t++) {
W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
}

for(t = 16; t < 80; t++)  W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); A = context->Message_Digest[0];
B = context->Message_Digest[1];
C = context->Message_Digest[2];
D = context->Message_Digest[3];
E = context->Message_Digest[4]; for(t = 0; t < 20; t++) {
temp =  SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 20; t < 40; t++) {
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 40; t < 60; t++) {
temp = SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 60; t < 80; t++) {
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF;
context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF;
context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF;
context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF;
context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF;
context->Message_Block_Index = 0;
}void SHA1PadMessage(SHA1Context *context){
if (context->Message_Block_Index > 55) {
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 64)  context->Message_Block[context->Message_Block_Index++] = 0;
SHA1ProcessMessageBlock(context);
while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0;
} else {
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0;
}
context->Message_Block[56] = (context->Length_High >> 24 ) & 0xFF;
context->Message_Block[57] = (context->Length_High >> 16 ) & 0xFF;
context->Message_Block[58] = (context->Length_High >> 8 ) & 0xFF;
context->Message_Block[59] = (context->Length_High) & 0xFF;
context->Message_Block[60] = (context->Length_Low >> 24 ) & 0xFF;
context->Message_Block[61] = (context->Length_Low >> 16 ) & 0xFF;
context->Message_Block[62] = (context->Length_Low >> 8 ) & 0xFF;
context->Message_Block[63] = (context->Length_Low) & 0xFF; SHA1ProcessMessageBlock(context);
}int sha1_hash(const char *source, char *lrvar){// Main
SHA1Context sha;
char buf[128]; SHA1Reset(&sha);
SHA1Input(&sha, source, strlen(source)); if (!SHA1Result(&sha)){
lr_error_message("SHA1 ERROR: Could not compute message digest");
return -1;
} else {
memset(buf,0,sizeof(buf));
sprintf(buf, "%08X%08X%08X%08X%08X", sha.Message_Digest[0],sha.Message_Digest[1],
sha.Message_Digest[2],sha.Message_Digest[3],sha.Message_Digest[4]);
lr_save_string(buf, lrvar);
return strlen(buf);
}
}

Answer 4

搞openssl成本太高，include这个就需要include那个的受不了。
本来几个Win32 API就能搞定的，我就是不知道哪几个参数设置的不对

Answer 5

SHA1加密算法的c++实现

Answer 6

应该有的是源代码吧，俺在csdn下载频道下载的。

Answer 7

咕~~(╯﹏╰)b，还是不对，注意到没? 那个java代码里面是可以传递一个Key的，就是私钥，他参与了加密过程。
但是下载到的那个代码，只是Degist运算。所以还是不行啊，各位老大再帮忙啊~~~~

Answer 8

那叫hmac，你说“求Win32 的SHA1的加密算法，得到的结果和下面这段java代码的结果一致。：”，你要知道，不是每个人都有java环境的，你必须给出你的输入和输出，别人才有可能达到“结果一致”

Answer 9

System.out.println(base64sha1("message", "234123"));
这不是信息和密钥吗？

Answer 10

SHA1算法可以找到源代码,目前我也正在收集.
我需要用到SHA1,Blowfish和DSA三个算法,现在还有DSA算法没有找到源代码.哪位有啊?

Answer 11

刚找到hmac的流程，先将明文处理成64字节，然后经过两次xor与hash( sha1, sha256........ )

Answer 12

SHA用java实现?面向对象...算法...好蛋疼...

Answer 13

看来我应该把这个过程好好了解一下，以及那些API的准确含义

Answer 14

DSA可以联系我~大数库，可以联系我~

Answer 15

结贴了，俺正在手工实现sha1_hmac呢。

Answer 16

下面是俺手工计算的结果，算是有个交待
//sha1_hash ( xor_whole ( dup ( int ( 64 ) , 5c ) , pack00_len ( ansi_string ( "234123" ) , int ( 64 ) ) ) sha1_hash ( xor_whole ( dup ( int ( 64 ) , 36 ) , pack00_len ( ansi_string ( "234123" ) , int ( 64 ) ) ) ansi_string ( "message" ) ) ) 
//--------int
//--------  input = 64  hex = 00 00 00 40 
//
//----------ansi_string convert utf16-little-endian format input data to ansi format
//----------  input = 32 00 33 00 34 00 31 00 32 00 33 00 
//----------  output = 32 33 34 31 32 33 
//
//----------int
//----------  input = 64  hex = 00 00 00 40 
//
//----------------int
//----------------  input = 64  hex = 00 00 00 40 
//
//------------------ansi_string convert utf16-little-endian format input data to ansi format
//------------------  input = 32 00 33 00 34 00 31 00 32 00 33 00 
//------------------  output = 32 33 34 31 32 33 
//
//------------------int
//------------------  input = 64  hex = 00 00 00 40 
//
//------------------ansi_string convert utf16-little-endian format input data to ansi format
//------------------  input = 6D 00 65 00 73 00 73 00 61 00 67 00 65 00 
//------------------  output = 6D 65 73 73 61 67 65 
//
//------dup repeat the specified number of times the input data
//------  result = 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 
//
//------pack00_len implementation of alignment when input data length is not multiple times of the length
//------  input = 32 33 34 31 32 33 
//------  output = 32 33 34 31 32 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
//
//----------dup repeat the specified number of times the input data
//----------  result = 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 [color=#F0F0F0]

Answer 17

//[/color]
//----------pack00_len implementation of alignment when input data length is not multiple times of the length
//----------  input = 32 33 34 31 32 33 
//----------  output = 32 33 34 31 32 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
//
//----xor_whole XOR data 1 to data 2, the returned data length is the length of the data 2
//----  data 1 = 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 
//----  data 2 = 32 33 34 31 32 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
//----  result = 6E 6F 68 6D 6E 6F 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 
//
//------xor_whole XOR data 1 to data 2, the returned data length is the length of the data 2
//------  data 1 = 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 
//------  data 2 = 32 33 34 31 32 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
//------  result = 04 05 02 07 04 05 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 
//
//----sha1_hash
//----  input = 
//--------04 05 02 07 04 05 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 
//--------36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 
//--------6D 65 73 73 61 67 65 
//----  output = CB 03 87 7F ED 03 DE 7B B7 1A B9 F3 B8 CF 22 1B 53 79 7D FD 
//
//--sha1_hash
//--  input = 
//------6E 6F 68 6D 6E 6F 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 
//------5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 5C 
//------CB 03 87 7F ED 03 DE 7B B7 1A B9 F3 B8 CF 22 1B 53 79 7D FD 
//--  output = 22 24 EE 75 01 9B 1E 69 AD 71 AB 74 29 E2 92 F3 35 00 3A 45 
//