多种语言使用SHA256

我们曾经最常使用的哈希加密算法是MD5, 如今已被证明非常不安全。山东大学的王小云教授通过碰撞法攻破了MD5算法,可在很短的时间内找到密文的碰撞。计算Md5碰撞的在线工具

王小云团队还宣称破解了SHA1。不过所谓对SHA1破解只是在数学层面,传统认为SHA1寻找碰撞需要进行2^80次运算,而王小云发现只需2^69次运算,随后又找到了更快的2^63次,因此从数学层面上来说SHA1被破解了,但是2^63次依然是个天文数字。尽管如此,人们对SHA1的信心开始动摇, 部分大厂也启动了加密迁移计划: 微软,谷歌, 赛门铁克都制定了SHA1签名的弃用时间表。

目前还没有针对SHA256有效的破解方法。比特币广泛使用了SHA256哈希,这也能从侧面说明它的安全性。 于是我将各种编程语言中SHA256的实现记录下来。

零、 在线加密工具

通过站点在线加密解密, 可以方便地得到各种算法加密后的密文。

一、原理

感兴趣的同学可以下载英文文档SHA加密原理.pdf进行研读。

二、JavaScript实现

下载sha256.js

<script src="sha256.js"></script>
<script>
    var text = "test"; // 明文
    var output = sha256_digest("test"); // 密文, 十六进制串
</script>

三、 Java实现

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Test {
   public static void main(String[] args){
       String text = "test"; // 明文
       MessageDigest digest;
       try {
           digest = MessageDigest.getInstance("SHA-256");
           byte[] hash = digest.digest(text.getBytes("UTF-8")); // 密文, 二级制byte数组
           String output = bytes2Hex(hash); // 密文, 十六进制串
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
 
   public static String bytes2Hex(byte[] src){ 
     char[] res = new char[src.length*2]; 
     final char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; 
     for(int i=0,j=0; i<src.length; i++){ 
         res[j++] = hexDigits[src[i] >>>4 & 0x0f]; 
         res[j++] = hexDigits[src[i] & 0x0f]; 
     } 
     return new String(res); 
   }
}

四、Python实现

import hashlib

sh = hashlib.sha256() # 初始化对象
sh.update("test") # 明文
print sh.digest() # 二级制密文
print sh.hexdigest() # 十六进制密文串

五、 php实现

<?php
$text = "test"; // 明文
hash("sha256", $text); // 密文, 十六进制密文串
hash("sha256", $text, true); // 密文, 二进制
?>

六、ruby实现

require 'digest'
Digest::SHA256.hexdigest 'test'    # 密文, 十六进制密文串

七、Perl实现

 #!/usr/bin/perl
 use Digest::SHA qw(sha256_hex);
 print sha256_hex('test');  # 密文, 十六进制密文串

八、Go实现

text := "test"
h := sha256.New()
h.Write([]byte(text))
bs := h.Sum(nil)
fmt.Printf("%x\n", bs)

九、 C实现

#include <string.h>
#include <stdlib.h>
#include <stdio.h>


#ifndef uint8
#define uint8 unsigned char
#endif

#ifndef uint32
#define uint32 unsigned long int
#endif

typedef struct{
     uint32 total[2];
     uint32 state[8];
     uint8 buffer[64];
}
sha256_context;

#define GET_UINT32(n,b,i) \
{ \
 (n) = ( (uint32) (b)[(i) ] << 24 ) \
 | ( (uint32) (b)[(i) + 1] << 16 ) \
 | ( (uint32) (b)[(i) + 2] << 8 ) \
 | ( (uint32) (b)[(i) + 3] ); \
}
#define PUT_UINT32(n,b,i) \
{ \
 (b)[(i) ] = (uint8) ( (n) >> 24 ); \
 (b)[(i) + 1] = (uint8) ( (n) >> 16 ); \
 (b)[(i) + 2] = (uint8) ( (n) >> 8 ); \
 (b)[(i) + 3] = (uint8) ( (n) ); \
}
void sha256_starts( sha256_context *ctx ){
 ctx->total[0] = 0;
 ctx->total[1] = 0;

ctx->state[0] = 0x6A09E667;
 ctx->state[1] = 0xBB67AE85;
 ctx->state[2] = 0x3C6EF372;
 ctx->state[3] = 0xA54FF53A;
 ctx->state[4] = 0x510E527F;
 ctx->state[5] = 0x9B05688C;
 ctx->state[6] = 0x1F83D9AB;
 ctx->state[7] = 0x5BE0CD19;
}

 void sha256_process( sha256_context *ctx, uint8 data[64] ){
 uint32 temp1, temp2, W[64];
 uint32 A, B, C, D, E, F, G, H;

 GET_UINT32( W[0], data, 0 );
 GET_UINT32( W[1], data, 4 );
 GET_UINT32( W[2], data, 8 );
 GET_UINT32( W[3], data, 12 );
 GET_UINT32( W[4], data, 16 );
 GET_UINT32( W[5], data, 20 );
 GET_UINT32( W[6], data, 24 );
 GET_UINT32( W[7], data, 28 );
 GET_UINT32( W[8], data, 32 );
 GET_UINT32( W[9], data, 36 );
 GET_UINT32( W[10], data, 40 );
 GET_UINT32( W[11], data, 44 );
 GET_UINT32( W[12], data, 48 );
 GET_UINT32( W[13], data, 52 );
 GET_UINT32( W[14], data, 56 );
 GET_UINT32( W[15], data, 60 );

#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
#define R(t) \
( \
 W[t] = S1(W[t - 2]) + W[t - 7] + \
 S0(W[t - 15]) + W[t - 16] \
)
#define P(a,b,c,d,e,f,g,h,x,K) \
{ \
 temp1 = h + S3(e) + F1(e,f,g) + K + x; \
 temp2 = S2(a) + F0(a,b,c); \
 d += temp1; h = temp1 + temp2; \
}

 A = ctx->state[0];
 B = ctx->state[1];
 C = ctx->state[2];
 D = ctx->state[3];
 E = ctx->state[4];
 F = ctx->state[5];
 G = ctx->state[6];
 H = ctx->state[7];

 P( A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98 );
 P( H, A, B, C, D, E, F, G, W[ 1], 0x71374491 );
 P( G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF );
 P( F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5 );
 P( E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B );
 P( D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1 );
 P( C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4 );
 P( B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5 );
 P( A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98 );
 P( H, A, B, C, D, E, F, G, W[ 9], 0x12835B01 );
 P( G, H, A, B, C, D, E, F, W[10], 0x243185BE );
 P( F, G, H, A, B, C, D, E, W[11], 0x550C7DC3 );
 P( E, F, G, H, A, B, C, D, W[12], 0x72BE5D74 );
 P( D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE );
 P( C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7 );
 P( B, C, D, E, F, G, H, A, W[15], 0xC19BF174 );
 P( A, B, C, D, E, F, G, H, R(16), 0xE49B69C1 );
 P( H, A, B, C, D, E, F, G, R(17), 0xEFBE4786 );
 P( G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6 );
 P( F, G, H, A, B, C, D, E, R(19), 0x240CA1CC );
 P( E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F );
 P( D, E, F, G, H, A, B, C, R(21), 0x4A7484AA );
 P( C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC );
 P( B, C, D, E, F, G, H, A, R(23), 0x76F988DA );
 P( A, B, C, D, E, F, G, H, R(24), 0x983E5152 );
 P( H, A, B, C, D, E, F, G, R(25), 0xA831C66D );
 P( G, H, A, B, C, D, E, F, R(26), 0xB00327C8 );
 P( F, G, H, A, B, C, D, E, R(27), 0xBF597FC7 );
 P( E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3 );
 P( D, E, F, G, H, A, B, C, R(29), 0xD5A79147 );
 P( C, D, E, F, G, H, A, B, R(30), 0x06CA6351 );
 P( B, C, D, E, F, G, H, A, R(31), 0x14292967 );
 P( A, B, C, D, E, F, G, H, R(32), 0x27B70A85 );
 P( H, A, B, C, D, E, F, G, R(33), 0x2E1B2138 );
 P( G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC );
 P( F, G, H, A, B, C, D, E, R(35), 0x53380D13 );
 P( E, F, G, H, A, B, C, D, R(36), 0x650A7354 );
 P( D, E, F, G, H, A, B, C, R(37), 0x766A0ABB );
 P( C, D, E, F, G, H, A, B, R(38), 0x81C2C92E );
 P( B, C, D, E, F, G, H, A, R(39), 0x92722C85 );
 P( A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1 );
 P( H, A, B, C, D, E, F, G, R(41), 0xA81A664B );
 P( G, H, A, B, C, D, E, F, R(42), 0xC24B8B70 );
 P( F, G, H, A, B, C, D, E, R(43), 0xC76C51A3 );
 P( E, F, G, H, A, B, C, D, R(44), 0xD192E819 );
 P( D, E, F, G, H, A, B, C, R(45), 0xD6990624 );
 P( C, D, E, F, G, H, A, B, R(46), 0xF40E3585 );
 P( B, C, D, E, F, G, H, A, R(47), 0x106AA070 );
 P( A, B, C, D, E, F, G, H, R(48), 0x19A4C116 );
 P( H, A, B, C, D, E, F, G, R(49), 0x1E376C08 );
 P( G, H, A, B, C, D, E, F, R(50), 0x2748774C );
 P( F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5 );
 P( E, F, G, H, A, B, C, D, R(52), 0x391C0CB3 );
 P( D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A );
 P( C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F );
 P( B, C, D, E, F, G, H, A, R(55), 0x682E6FF3 );
 P( A, B, C, D, E, F, G, H, R(56), 0x748F82EE );
 P( H, A, B, C, D, E, F, G, R(57), 0x78A5636F );
 P( G, H, A, B, C, D, E, F, R(58), 0x84C87814 );
 P( F, G, H, A, B, C, D, E, R(59), 0x8CC70208 );
 P( E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA );
 P( D, E, F, G, H, A, B, C, R(61), 0xA4506CEB );
 P( C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7 );
 P( B, C, D, E, F, G, H, A, R(63), 0xC67178F2 );

 ctx->state[0] += A;
 ctx->state[1] += B;
 ctx->state[2] += C;
 ctx->state[3] += D;
 ctx->state[4] += E;
 ctx->state[5] += F;
 ctx->state[6] += G;
 ctx->state[7] += H;
}

void sha256_update( sha256_context *ctx, uint8 *input, uint32 length ){
     uint32 left, fill;

     if( ! length ) return;

     left = ctx->total[0] & 0x3F;
     fill = 64 - left;

     ctx->total[0] += length;
     ctx->total[0] &= 0xFFFFFFFF;

     if( ctx->total[0] < length )
         ctx->total[1]++;

     if( left && length >= fill )  {
         memcpy( (void *) (ctx->buffer + left),
         (void *) input, fill );
         sha256_process( ctx, ctx->buffer );
         length -= fill;
         input += fill;
         left = 0;
     }

     while( length >= 64 ) {
         sha256_process( ctx, input );
         length -= 64;
         input += 64;
     }

     if( length ) {
         memcpy( (void *) (ctx->buffer + left),
         (void *) input, length );
     }
}

static uint8 sha256_padding[64] =
{
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

void sha256_finish( sha256_context *ctx, uint8 digest[32] )
{
    uint32 last, padn;
    uint32 high, low;
    uint8 msglen[8];

    high = ( ctx->total[0] >> 29 )
 | ( ctx->total[1] << 3 );
 low = ( ctx->total[0] << 3 );

   PUT_UINT32( high, msglen, 0 );
 PUT_UINT32( low, msglen, 4 );

 last = ctx->total[0] & 0x3F;
 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

 sha256_update( ctx, sha256_padding, padn );
 sha256_update( ctx, msglen, 8 );

 PUT_UINT32( ctx->state[0], digest, 0 );
 PUT_UINT32( ctx->state[1], digest, 4 );
 PUT_UINT32( ctx->state[2], digest, 8 );
 PUT_UINT32( ctx->state[3], digest, 12 );
 PUT_UINT32( ctx->state[4], digest, 16 );
 PUT_UINT32( ctx->state[5], digest, 20 );
 PUT_UINT32( ctx->state[6], digest, 24 );
 PUT_UINT32( ctx->state[7], digest, 28 );
}

/*
 * those are the standard FIPS-180-2 test vectors
 */


int main( int argc, char *argv[] )
{
    int j;
    char output[65]; 
    sha256_context ctx;
    unsigned char sha256sum[32];
 
    sha256_starts( &ctx ); // 初始化
    sha256_update( &ctx, (uint8 *) "test",
    strlen("test") ); // 传入明文字符串
    sha256_finish( &ctx, sha256sum ); // sha256sum为二进制密文数组

    for( j = 0; j < 32; j++ ) {
        sprintf( output + j * 2, "%02x", sha256sum[j] );
    }
    printf("%s", output);// output十六进制密文字符串
    return( 0 );
}