SHA-512 (这些有时候也被称做 SHA-2)。

简介　SHA 家族

SHA (Secure Hash Algorithm，译作安全散列算法) 是美国国家安全局 (NSA) 设计，美国国家标准与技术研究院 (NIST) 发布的一系列密码散列函数。正式名称为 SHA 的家族第一个成员发布于 1993年。然而现在的人们给它取了一个非正式的名称 SHA-0 以避免与它的后继者混淆。两年之后， SHA-1，第一个 SHA 的后继者发布了。另外还有四种变体，曾经发布以提升输出的范围和变更一些细微设计: SHA-224, SHA-256, SHA-384 和 SHA-512 (这些有时候也被称做 SHA-2)。

c++实现代码

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

//SHA512.h

#ifndef SHA512_H

#define SHA512_H

#include <string>

class SHA512

{

protected:

typedef unsigned char uint8;

typedef unsigned int uint32;

typedef unsigned long long uint64;

const static uint64 sha512_k[];

static const unsigned int SHA384_512_BLOCK_SIZE = (1024/8);

public:

void init();

void update(const unsigned char *message, unsigned int len);

void final(unsigned char *digest);

static const unsigned int DIGEST_SIZE = ( 512 / 8);

protected:

void transform(const unsigned char *message, unsigned int block_nb);

unsigned int m_tot_len;

unsigned int m_len;

unsigned char m_block[2 * SHA384_512_BLOCK_SIZE];

uint64 m_h[8];

};

std::string sha512(std::string input);

#define SHA2_SHFR(x, n) (x >> n)

#define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))

#define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))

#define SHA2_CH(x, y, z) ((x & y) ^ (~x & z))

#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

#define SHA512_F1(x) (SHA2_ROTR(x, 28) ^ SHA2_ROTR(x, 34) ^ SHA2_ROTR(x, 39))

#define SHA512_F2(x) (SHA2_ROTR(x, 14) ^ SHA2_ROTR(x, 18) ^ SHA2_ROTR(x, 41))

#define SHA512_F3(x) (SHA2_ROTR(x, 1) ^ SHA2_ROTR(x, 8) ^ SHA2_SHFR(x, 7))

#define SHA512_F4(x) (SHA2_ROTR(x, 19) ^ SHA2_ROTR(x, 61) ^ SHA2_SHFR(x, 6))

#define SHA2_UNPACK32(x, str) \

{ \

*((str) + 3) = (uint8) ((x) ); \

*((str) + 2) = (uint8) ((x) >> 8); \

*((str) + 1) = (uint8) ((x) >> 16); \

*((str) + 0) = (uint8) ((x) >> 24); \

}

#define SHA2_UNPACK64(x, str) \

{ \

*((str) + 7) = (uint8) ((x) ); \

*((str) + 6) = (uint8) ((x) >> 8); \

*((str) + 5) = (uint8) ((x) >> 16); \

*((str) + 4) = (uint8) ((x) >> 24); \

*((str) + 3) = (uint8) ((x) >> 32); \

*((str) + 2) = (uint8) ((x) >> 40); \

*((str) + 1) = (uint8) ((x) >> 48); \

*((str) + 0) = (uint8) ((x) >> 56); \

}

#define SHA2_PACK64(str, x) \

{ \

*(x) = ((uint64) *((str) + 7) ) \

| ((uint64) *((str) + 6) << 8) \

| ((uint64) *((str) + 5) << 16) \

| ((uint64) *((str) + 4) << 24) \

| ((uint64) *((str) + 3) << 32) \

| ((uint64) *((str) + 2) << 40) \

| ((uint64) *((str) + 1) << 48) \

| ((uint64) *((str) + 0) << 56); \

}

#endif

//SHA512.cpp

#include <cstring>

#include <fstream>

#include "sha512.h"

const unsigned long long SHA512::sha512_k[80] = //ULL = uint64

{0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,

0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,

0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,

0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,

0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,

0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,

0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,

0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,

0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,

0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,

0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,

0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,

0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,

0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,

0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,

0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,

0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,

0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,

0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,

0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,

0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,

0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,

0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,

0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,

0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,

0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,

0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,

0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,

0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,

0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,

0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,

0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,

0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,

0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,

0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,

0x113f9804bef90daeULL, 0x1b710b35131c471bULL,

0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,

0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,

0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,

0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};

void SHA512::transform(const unsigned char *message, unsigned int block_nb)

{

uint64 w[80];

uint64 wv[8];

uint64 t1, t2;

const unsigned char *sub_block;

int i, j;

for (i = 0; i < (int) block_nb; i++) {

sub_block = message + (i << 7);

for (j = 0; j < 16; j++) {

SHA2_PACK64(&sub_block[j << 3], &w[j]);

}

for (j = 16; j < 80; j++) {

w[j] = SHA512_F4(w[j - 2]) + w[j - 7] + SHA512_F3(w[j - 15]) + w[j - 16];

}

for (j = 0; j < 8; j++) {

wv[j] = m_h[j];

}

for (j = 0; j < 80; j++) {

t1 = wv[7] + SHA512_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])

+ sha512_k[j] + w[j];

t2 = SHA512_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);

wv[7] = wv[6];

wv[6] = wv[5];

wv[5] = wv[4];

wv[4] = wv[3] + t1;

wv[3] = wv[2];

wv[2] = wv[1];

wv[1] = wv[0];

wv[0] = t1 + t2;

}

for (j = 0; j < 8; j++) {

m_h[j] += wv[j];

}

void SHA512::init()

{

m_h[0] = 0x6a09e667f3bcc908ULL;

m_h[1] = 0xbb67ae8584caa73bULL;

m_h[2] = 0x3c6ef372fe94f82bULL;

m_h[3] = 0xa54ff53a5f1d36f1ULL;

m_h[4] = 0x510e527fade682d1ULL;

m_h[5] = 0x9b05688c2b3e6c1fULL;

m_h[6] = 0x1f83d9abfb41bd6bULL;

m_h[7] = 0x5be0cd19137e2179ULL;

m_len = 0;

m_tot_len = 0;

}

void SHA512::update(const unsigned char *message, unsigned int len)

{

unsigned int block_nb;

unsigned int new_len, rem_len, tmp_len;

const unsigned char *shifted_message;

tmp_len = SHA384_512_BLOCK_SIZE - m_len;

rem_len = len < tmp_len ? len : tmp_len;

memcpy(&m_block[m_len], message, rem_len);

if (m_len + len < SHA384_512_BLOCK_SIZE) {

m_len += len;

return;

}

new_len = len - rem_len;

block_nb = new_len / SHA384_512_BLOCK_SIZE;

shifted_message = message + rem_len;

transform(m_block, 1);

transform(shifted_message, block_nb);

rem_len = new_len % SHA384_512_BLOCK_SIZE;

memcpy(m_block, &shifted_message[block_nb << 7], rem_len);

m_len = rem_len;

m_tot_len += (block_nb + 1) << 7;

}

void SHA512::final(unsigned char *digest)

{

unsigned int block_nb;

unsigned int pm_len;

unsigned int len_b;

int i;

block_nb = 1 + ((SHA384_512_BLOCK_SIZE - 17)

< (m_len % SHA384_512_BLOCK_SIZE));

len_b = (m_tot_len + m_len) << 3;

pm_len = block_nb << 7;

memset(m_block + m_len, 0, pm_len - m_len);

m_block[m_len] = 0x80;

SHA2_UNPACK32(len_b, m_block + pm_len - 4);

transform(m_block, block_nb);

for (i = 0 ; i < 8; i++) {

SHA2_UNPACK64(m_h[i], &digest[i << 3]);

}

std::string sha512(std::string input)

{

unsigned char digest[SHA512::DIGEST_SIZE];

memset(digest,0,SHA512::DIGEST_SIZE);

SHA512 ctx = SHA512();

ctx.init();

ctx.update((unsigned char*)input.c_str(), input.length());

ctx.final(digest);

char buf[2*SHA512::DIGEST_SIZE+1];

buf[2*SHA512::DIGEST_SIZE] = 0;

for (int i = 0; i < SHA512::DIGEST_SIZE; i++)

sprintf(buf+i*2, "%02x", digest[i]);

return std::string(buf);

}

//main.cpp

#include <iostream>

#include "sha512.h"

using namespace std;

int main(int argc, char *argv[])

{

string plain_text = "This is a SHA215 example";

string sha512_code= sha512(plain_text);

cout<<plain_text<<"通过sha512获得的摘要值："<< sha512_code<< endl;

system("pause");

return 0;

}

SHA

本词条缺少名片图，补充相关内容使词条更完整，还能快速升级，赶紧来吧！

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

中文名: 安全哈希算法
外文名: SHA

提出者: 美国国家标准技术研究所
提出时间: 2008年
适用领域范围: 数字签名标准里面数字签名算法

基本信息

简介

安全散列算法SHA

（Secure Hash Algorithm，SHA)

是美国国家标准技术研究所发布的国家标准FIPS PUB 180，最新的标准已经于2008年更新到FIPS PUB 180-3。其中规定了SHA-1，SHA-224，SHA-256，SHA-384，和SHA-512这几种单向散列算法。SHA-1，SHA-224和SHA-256适用于长度不超过2^64二进制位的消息。SHA-384和SHA-512适用于长度不超过2^128二进制位的消息。

散列算法

散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特性的散列结果就可以用于验证信息是否被修改。

单向散列函数一般用于产生消息摘要，密钥加密等，常见的有：

l MD5（Message Digest Algorithm 5）：是RSA数据安全公司开发的一种单向散列算法。

l SHA（Secure Hash Algorithm）：可以对任意长度的数据运算生成一个160位的数值；

SHA-1

在1993年，安全散列算法（SHA）由美国国家标准和技术协会（NIST)提出，并作为联邦信息处理标准（FIPS PUB 180）公布；1995年又发布了一个修订版FIPS PUB 180-1，通常称之为SHA-1。SHA-1是基于MD4算法的，并且它的设计在很大程度上是模仿MD4的。现在已成为公认的最安全的散列算法之一，并被广泛使用。

原理

SHA-1是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。

单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码，那么任何人在不知道密码的情况下都不能产生正确的散列值，从而保证了其安全性。SHA将输入流按照每块512位（64个字节）进行分块，并产生20个字节的被称为信息认证代码或信息摘要的输出。

该算法输入报文的长度不限，产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突，并具有良好的雪崩效应。

通过散列算法可实现数字签名实现，数字签名的原理是将要传送的明文通过一种函数运算（Hash）转换成报文摘要（不同的明文对应不同的报文摘要），报文摘要加密后与明文一起传送给接受方，接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较，比较结果一致表示明文未被改动，如果不一致表示明文已被篡改。

MAC （信息认证代码）就是一个散列结果，其中部分输入信息是密码，只有知道这个密码的参与者才能再次计算和验证MAC码的合法性。

SHA-1与MD5的比较

因为二者均由MD4导出，SHA-1和MD5彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：

l 对强行攻击的安全性：最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2^128数量级的操作，而对SHA-1则是2^160数量级的操作。这样，SHA-1对强行攻击有更大的强度。

l 对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。

l 速度：在相同的硬件上，SHA-1的运行速度比MD5慢。

SHA-1停止计划

　　2005年，密码学家就证明SHA-1的破解速度比预期提高了2000倍，虽然破解仍然是极其困难和昂贵的，但随着计算机变得越来越快和越来越廉价，SHA-1算法的安全性也逐年降低，已被密码学家严重质疑，希望由安全强度更高的SHA-2替代它。

微软第一个宣布了SHA-1弃用计划，对于SSL证书和代码签名证书，微软设定了不同的替换时间表：
　　1、所有Windows受信任的根证书颁发机构(CA)从2016年1月1日起必须停止签发新的SHA-1签名算法SSL证书和代码签名证书；
　　2、对于SSL证书，Windows将于2017年1月1日起停止支持SHA1证书。也就是说：任何在之前签发的SHA-1证书必须替换成SHA-2证书；
　
　3、对于代码签名证书，Windows将于2016年1月1日停止接受没有时间戳的SHA-1签名的代码和SHA-1证书。也就是说，Windows仍
然接受在2016年1月1日之前使用SAH-1签名的已经加上RFC3161时间戳的代码，直到微软认为有可能出现SHA-1攻击时。

　　Google官方博客宣布，将在Chrome浏览器中逐渐降
低SHA-1证书的安全指示，逐步停止对使用SHA-1散列算法证书的支持。近日，Chrome 39新版本 PC
端发布，在部分操作系统下，该版本浏览器中已开始出现“该网站使用的安全设置已过期”
提示，在接下来的6个月内会变得越来越严格。最终，使用了有效期至2016年的SHA-1证书的站点可能会被给予黄色警告。

　　Mozilla也做了同样的决定，在其对外公布近期更新计划
中表示：“现在依然有不少网站使用基于 SHA-1签名的 SSL证书，所以我们决定加入微软和谷歌的阵营，认为应在 2016 年 1 月 1
日前停止发放 SHA-1 证书，在 2017 年 1 月1 日后不再信任此证书。”

应用

计算MD5或sha-1加密哈希值的文件

当您将哈希算法应用于任意数量的如一个二进制文件的数据时结果将是一个哈希或消息摘要。此哈希具有固定的大小。MD5 是创建一个 128 位的哈希值的哈希算法。sha-1 是创建一个 160 位哈希值的哈希算法。

文件校验和完整性验证程序 (Microsoft File Checksum Integrity Verifier，简写为FCIV）实用程序可以用于计算 MD5 或 sha-1 加密哈希值的文件。若要计算在 MD5 和文件的 sha-1 哈希值，安装完成FCIV之后请在命令行键入以下命令：

FCⅣ-md5-sha1 path\filename.ext

例如对于计算 Shdocvw.dll 文件 %Systemroot% \System32 文件夹中的 MD5 和 sha-1 哈希值，键入以下命令：

FCⅣ-md5-sha1 c:\windows\system32\shdocvw.dll

SHA-1 Java 实现源码

----------------------------------------------------------------------------------------------------

/* 安全散列算法SHA (Secure Hash Algorithm，SHA) */

public class SHA1 {

private final int[] abcde = { 0x67452301,0xefcdab89,0x98badcfe,

0x10325476,0xc3d2e1f0 };

// 摘要数据存储数组

private int[] digestInt = new int[5];

// 计算过程中的临时数据存储数组

private int[] tmpData = new int[80];

// 计算sha-1摘要

private int process_input_bytes(byte[] bytedata) {

// 初试化常量

System.arraycopy(abcde,0,digestInt,0,abcde.length);

// 格式化输入字节数组，补10及长度数据

byte[] newbyte = byteArrayFormatData(bytedata);

// 获取数据摘要计算的数据单元个数

int MCount = newbyte.length / 64;

// 循环对每个数据单元进行摘要计算

for (int pos = 0; pos < MCount; pos++) {

// 将每个单元的数据转换成16个整型数据，并保存到tmpData的前16个数组元素中

for (int j = 0; j < 16; j++) {

tmpData[j] = byteArrayToInt(newbyte,(pos * 64） + (j * 4））；

}

摘要计算函数

encrypt();

}

return 20;

}

// 格式化输入字节数组格式

private byte[] byteArrayFormatData(byte[] bytedata) {

// 补0数量

int zeros = 0;

// 补位后总位数

int size = 0;

// 原始数据长度

int n = bytedata.length;

// 模64后的剩余位数

int m = n % 64;

// 计算添加0的个数以及添加10后的总长度

if (m < 56） {

zeros = 55 - m;

size = n - m + 64;

} else if (m == 56） {

zeros = 63;

size = n + 8 + 64;

} else {

zeros = 63 - m + 56;

size = (n + 64） - m + 64;

}

// 补位后生成的新数组内容

byte[] newbyte = new byte[size];

// 复制数组的前面部分

System.arraycopy(bytedata,0,newbyte,0,n);

// 获得数组Append数据元素的位置

int l = n;

// 补1操作

newbyte[l++] = (byte) 0x80;

// 补0操作

for (int i = 0; i < zeros; i++) {

newbyte[l++] = (byte) 0x00;

}

// 计算数据长度，补数据长度位共8字节，长整型

long N = (long) n * 8;

byte h8 = (byte) (N & 0xFF);

byte h7 = (byte) ((N >> 8） & 0xFF);

byte h6 = (byte) ((N >> 16） & 0xFF);

byte h5 = (byte) ((N >> 24） & 0xFF);

byte h4 = (byte) ((N >> 32） & 0xFF);

byte h3 = (byte) ((N >> 40） & 0xFF);

byte h2 = (byte) ((N >> 48） & 0xFF);

byte h1 = (byte) (N >> 56）；

newbyte[l++] = h1;

newbyte[l++] = h2;

newbyte[l++] = h3;

newbyte[l++] = h4;

newbyte[l++] = h5;

newbyte[l++] = h6;

newbyte[l++] = h7;

newbyte[l++] = h8;

return newbyte;

}

private int f1(int x,int y,int z) {

return (x & y) | (~x & z);

}

private int f2(int x,int y,int z) {

return x ^ y ^ z;

}

private int f3(int x,int y,int z) {

return (x & y) | (x & z) | (y & z);

}

private int f4(int x,int y) {

return (x << y) | x >>> （32 - y);

}

单元摘要计算函数

private void encrypt() {

for (int i = 16; i <= 79; i++) {

tmpData[i] = f4(tmpData[i - 3] ^ tmpData[i - 8] ^ tmpData[i - 14]

^ tmpData[i - 16],1）；

}

int[] tmpabcde = new int[5];

for (int i1 = 0; i1 < tmpabcde.length; i1++) {

tmpabcde[i1] = digestInt[i1];

}

for (int j = 0; j <= 19; j++) {

int tmp = f4(tmpabcde[0],5）

+ f1(tmpabcde[1],tmpabcde[2],tmpabcde[3]) + tmpabcde[4]

+ tmpData[j] + 0x5a827999;

tmpabcde[4] = tmpabcde[3];

tmpabcde[3] = tmpabcde[2];

tmpabcde[2] = f4(tmpabcde[1],30）；

tmpabcde[1] = tmpabcde[0];

tmpabcde[0] = tmp;

}

for (int k = 20; k <= 39; k++) {

int tmp = f4(tmpabcde[0],5）

+ f2(tmpabcde[1],tmpabcde[2],tmpabcde[3]) + tmpabcde[4]

+ tmpData[k] + 0x6ed9eba1;

tmpabcde[4] = tmpabcde[3];

tmpabcde[3] = tmpabcde[2];

tmpabcde[2] = f4(tmpabcde[1],30）；

tmpabcde[1] = tmpabcde[0];

tmpabcde[0] = tmp;

}

for (int l = 40; l <= 59; l++) {

int tmp = f4(tmpabcde[0],5）

+ f3(tmpabcde[1],tmpabcde[2],tmpabcde[3]) + tmpabcde[4]

+ tmpData[l] + 0x8f1bbcdc;

tmpabcde[4] = tmpabcde[3];

tmpabcde[3] = tmpabcde[2];

tmpabcde[2] = f4(tmpabcde[1],30）；

tmpabcde[1] = tmpabcde[0];

tmpabcde[0] = tmp;

}

for (int m = 60; m <= 79; m++) {

int tmp = f4(tmpabcde[0],5）

+ f2(tmpabcde[1],tmpabcde[2],tmpabcde[3]) + tmpabcde[4]

+ tmpData[m] + 0xca62c1d6;

tmpabcde[4] = tmpabcde[3];

tmpabcde[3] = tmpabcde[2];

tmpabcde[2] = f4(tmpabcde[1],30）；

tmpabcde[1] = tmpabcde[0];

tmpabcde[0] = tmp;

}

for (int i2 = 0; i2 < tmpabcde.length; i2++) {

digestInt[i2] = digestInt[i2] + tmpabcde[i2];

}

for (int n = 0; n < tmpData.length; n++) {

tmpData[n] = 0;

}

// 4字节数组转换为整数

private int byteArrayToInt(byte[] bytedata,int i) {

return ((bytedata[i] & 0xff) << 24） | ((bytedata[i + 1] & 0xff) << 16）

| ((bytedata[i + 2] & 0xff) << 8） | (bytedata[i + 3] & 0xff);

}

// 整数转换为4字节数组

private void intToByteArray(int intValue,byte[] byteData,int i) {

byteData[i] = (byte) (intValue >>> 24）；

byteData[i + 1] = (byte) (intValue >>> 16）；

byteData[i + 2] = (byte) (intValue >>> 8）；

byteData[i + 3] = (byte) intValue;

}

// 将字节转换为十六进制字符串

private static String byteToHexString(byte ib) {

char[] Digit = { '0','1','2','3','4','5','6','7','8','9','A',

'B','C','D','E','F' };

char[] ob = new char[2];

ob[0] = Digit[(ib >>> 4） & 0X0F];

ob[1] = Digit[ib & 0X0F];

String s = new String(ob);

return s;

}

// 将字节数组转换为十六进制字符串

private static String byteArrayToHexString(byte[] bytearray) {

String strDigest = "";

for (int i = 0; i < bytearray.length; i++) {

strDigest += byteToHexString(bytearray[i]);

}

return strDigest;

}

// 计算sha-1摘要，返回相应的字节数组

public byte[] getDigestOfBytes(byte[] byteData) {

process_input_bytes(byteData);

byte[] digest = new byte[20];

for (int i = 0; i < digestInt.length; i++) {

intToByteArray(digestInt[i],digest,i * 4）；

}

return digest;

}

// 计算sha-1摘要，返回相应的十六进制字符串

public String getDigestOfString(byte[] byteData) {

return byteArrayToHexString(getDigestOfBytes(byteData));

}

测试

public static void main(String[] args) {

String param = "wxzzs";

System.out.println("加密前：" + param);

String digest = new SHA1().getDigestOfString(param.getBytes());

System.out.println("加密后：" + digest);

}

wv

sha256

SHA

目录

基本信息

简介

散列算法

原理

SHA-1与MD5的比较

SHA-1停止计划

应用

计算MD5或sha-1加密哈希值的文件

SHA-1 Java 实现源码

摘要计算函数

单元摘要计算函数

测试