/*
* A JavaScript implementation of the SHA256 hash function.
*
* FILE: sha256.js
* VERSION: 0.8
* AUTHOR: Christoph Bichlmeier <informatik@zombiearena.de>
*
* NOTE: This version is not tested thoroughly!
*
* Copyright (c) 2003, Christoph Bichlmeier
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* ======================================================================
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* SHA256 logical functions */
function rotateRight(n,x) {
return ((x >>> n) | (x << (32 - n)));
}
function choice(x,y,z) {
return ((x & y) ^ (~x & z));
}
function majority(x,y,z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
function sha256_Sigma0(x) {
return (rotateRight(2, x) ^ rotateRight(13, x) ^ rotateRight(22, x));
}
function sha256_Sigma1(x) {
return (rotateRight(6, x) ^ rotateRight(11, x) ^ rotateRight(25, x));
}
function sha256_sigma0(x) {
return (rotateRight(7, x) ^ rotateRight(18, x) ^ (x >>> 3));
}
function sha256_sigma1(x) {
return (rotateRight(17, x) ^ rotateRight(19, x) ^ (x >>> 10));
}
function sha256_expand(W, j) {
return (W[j&0x0f] += sha256_sigma1(W[(j+14)&0x0f]) + W[(j+9)&0x0f] +
sha256_sigma0(W[(j+1)&0x0f]));
}
/* Hash constant words K: */
var K256 = new Array(
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
);
/* global arrays */
var ihash, count, buffer;
var sha256_hex_digits = "0123456789abcdef";
/* Add 32-bit integers with 16-bit operations (bug in some JS-interpreters:
overflow) */
function safe_add(x, y)
{
var lsw = (x & 0xffff) + (y & 0xffff);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xffff);
}
/* Initialise the SHA256 computation */
function sha256_init() {
ihash = new Array(8);
count = new Array(2);
buffer = new Array(64);
count[0] = count[1] = 0;
ihash[0] = 0x6a09e667;
ihash[1] = 0xbb67ae85;
ihash[2] = 0x3c6ef372;
ihash[3] = 0xa54ff53a;
ihash[4] = 0x510e527f;
ihash[5] = 0x9b05688c;
ihash[6] = 0x1f83d9ab;
ihash[7] = 0x5be0cd19;
}
/* Transform a 512-bit message block */
function sha256_transform() {
var a, b, c, d, e, f, g, h, T1, T2;
var W = new Array(16);
/* Initialize registers with the previous intermediate value */
a = ihash[0];
b = ihash[1];
c = ihash[2];
d = ihash[3];
e = ihash[4];
f = ihash[5];
g = ihash[6];
h = ihash[7];
/* make 32-bit words */
for(var i=0; i<16; i++)
W[i] = ((buffer[(i<<2)+3]) | (buffer[(i<<2)+2] << 8) | (buffer[(i<<2)+1]
<< 16) | (buffer[i<<2] << 24));
for(var j=0; j<64; j++) {
T1 = h + sha256_Sigma1(e) + choice(e, f, g) + K256[j];
if(j < 16) T1 += W[j];
else T1 += sha256_expand(W, j);
T2 = sha256_Sigma0(a) + majority(a, b, c);
h = g;
g = f;
f = e;
e = safe_add(d, T1);
d = c;
c = b;
b = a;
a = safe_add(T1, T2);
}
/* Compute the current intermediate hash value */
ihash[0] += a;
ihash[1] += b;
ihash[2] += c;
ihash[3] += d;
ihash[4] += e;
ihash[5] += f;
ihash[6] += g;
ihash[7] += h;
}
/* Read the next chunk of data and update the SHA256 computation */
function sha256_update(data, inputLen) {
var i, index, curpos = 0;
/* Compute number of bytes mod 64 */
index = ((count[0] >> 3) & 0x3f);
var remainder = (inputLen & 0x3f);
/* Update number of bits */
if ((count[0] += (inputLen << 3)) < (inputLen << 3)) count[1]++;
count[1] += (inputLen >> 29);
/* Transform as many times as possible */
for(i=0; i+63<inputLen; i+=64) {
for(var j=index; j<64; j++)
buffer[j] = data.charCodeAt(curpos++);
sha256_transform();
index = 0;
}
/* Buffer remaining input */
for(var j=0; j<remainder; j++)
buffer[j] = data.charCodeAt(curpos++);
}
/* Finish the computation by operations such as padding */
function sha256_final() {
var index = ((count[0] >> 3) & 0x3f);
buffer[index++] = 0x80;
if(index <= 56) {
for(var i=index; i<56; i++)
buffer[i] = 0;
} else {
for(var i=index; i<64; i++)
buffer[i] = 0;
sha256_transform();
for(var i=0; i<56; i++)
buffer[i] = 0;
}
buffer[56] = (count[1] >>> 24) & 0xff;
buffer[57] = (count[1] >>> 16) & 0xff;
buffer[58] = (count[1] >>> 8) & 0xff;
buffer[59] = count[1] & 0xff;
buffer[60] = (count[0] >>> 24) & 0xff;
buffer[61] = (count[0] >>> 16) & 0xff;
buffer[62] = (count[0] >>> 8) & 0xff;
buffer[63] = count[0] & 0xff;
sha256_transform();
}
/* Split the internal hash values into an array of bytes */
function sha256_encode_bytes() {
var j=0;
var output = new Array(32);
for(var i=0; i<8; i++) {
output[j++] = ((ihash[i] >>> 24) & 0xff);
output[j++] = ((ihash[i] >>> 16) & 0xff);
output[j++] = ((ihash[i] >>> 8) & 0xff);
output[j++] = (ihash[i] & 0xff);
}
return output;
}
/* Get the internal hash as a hex string */
function sha256_encode_hex() {
var output = new String();
for(var i=0; i<8; i++) {
for(var j=28; j>=0; j-=4)
output += sha256_hex_digits.charAt((ihash[i] >>> j) & 0x0f);
}
return output;
}
/* Main function: returns a hex string representing the SHA256 value of the
given data */
function sha256_digest(data) {
sha256_init();
sha256_update(data, data.length);
sha256_final();
return sha256_encode_hex();
}
/* test if the JS-interpreter is working properly */
function sha256_self_test()
{
return sha256_digest("message digest") ==
"f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650";
}
相关推荐
"sha256_c++sha256头文件"可能指的是一个C++项目,该项目提供了SHA256的实现,但描述提到头文件没有被添加进去,这可能是开发过程中遇到的问题。头文件在C++中非常重要,因为它们包含了函数声明、类定义和其他编译时...
标题 "Delphi SHA256加密签名" 涉及的是使用Delphi XE开发的SHA256加密算法在签名过程中的应用。SHA256是安全散列算法(Secure Hash Algorithm)的一种,属于SHA-2家族,能生成一个256位(32字节)的哈希值,广泛...
它能够将任意长度的信息转化为固定长度的摘要,通常为256位,因此得名SHA256。在VC++环境下,我们可以使用C++语言来实现SHA256加密算法,并结合MFC(Microsoft Foundation Classes)库来创建用户界面,提供更加便捷...
在Arduino和STM32这样的微控制器平台上,实现SHA256算法可以确保嵌入式系统的数据安全。 **SHA256算法基础** SHA256是SHA-2家族的一部分,由美国国家安全局(NSA)设计,其工作原理基于消息摘要。它接收任意长度的...
在给定的压缩包文件中,我们有`sha256.rar`,它可能包含了不同语言版本的SHA256实现,包括`sha256.java`和`sha256.js`。 `sha256.java`是Java编程语言实现的SHA256哈希函数。在Java中,你可以通过使用`java....
在“sha256.c”这个文件名中,我们可以推测这可能是一个C语言编写的SHA256算法实现。C语言是一种底层编程语言,适合编写这样的算法,因为它可以直接操作内存和执行高效的数学运算。使用C语言实现SHA256可以确保代码...
无需将消息一次读入内存,通过循环调用sha256_update1即可计算摘要值,摘要值最后存储在hash[32]中;可以利用SHA256在线工具验证; sha256_init(&ctx;); sha256_update1(&ctx;, message1, 64); sha256_update1(&ctx;...
项目中的`sha256.c`和`sha1.c`文件包含了SHA256和SHA1的实现,而`HMACSHA.c`可能包含了HMAC的实现,利用了上述的两个哈希函数。`sha256.h`和`sha1.h`是对应的头文件,定义了相关函数的接口。`base64.c`和`base64.h`...
SHA256withRSA-Delphi7.rar是一个与Delphi 7编程环境相关的压缩包,主要涉及SHA256加密算法以及RSA公钥密码系统。SHA256是一种广泛使用的安全散列函数,用于生成固定长度(256位)的摘要,常用于数据完整性校验和...
using (SHA256 sha256Hash = SHA256.Create()) { hashBytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(input)); } StringBuilder builder = new StringBuilder(); for (int i = 0; i ; i++) { builder...
void sha256_get(uint8_t hash[32], const uint8_t *message, int length);/*此函数用于对消息计算摘要值,输入任意大小消息,输出32字节摘要值*/ void hmac_sha256_get(uint8_t digest[32], uint8_t *message, int...
MD5(Message-Digest Algorithm 5)、SHA1(Secure Hash Algorithm 1)和SHA256(Secure Hash Algorithm 2,256位版本)是常见的哈希函数,用于生成固定长度的数字指纹,常用于数据完整性校验、密码存储等领域。...
SHA256是一种广泛使用的密码学哈希函数,属于SHA-2家族的一部分,设计目的是为了提供数字信息的完整性验证和防止篡改。SHA256算法可以将任意长度的输入(也称为预映射)转化为固定长度的输出,通常是一个256位的散列...
在VB(Visual Basic)环境中,实现SHA256加密需要借助特定的库或者API。下面,我们将深入探讨SHA256加密的基本原理、VB中的实现方式以及不支持中文的问题。 **1. SHA256算法简介** SHA256是SHA-2家族的一员,由美国...
SHA256算法是一种广泛使用的密码散列函数,设计用于提供强安全性,特别是在数字签名、消息认证码(MAC)和区块链等应用中。Verilog是一种硬件描述语言,用于设计和验证数字系统的逻辑行为,包括集成电路(IC)和系统...
SHA256算法能够将任意长度的数据转化为一个固定长度的输出,即256位的哈希值,通常以16进制表示,长度为64个字符。 C语言实现SHA256算法的核心包括以下几个步骤: 1. **初始化哈希值**:算法开始时,会设置8个32位...
SHA256是一种广泛使用的密码学哈希函数,它能够将任意长度的输入(也称为预映射)转换为固定长度的输出,通常为256位,即32个字节。在IT行业中,SHA256常用于数据完整性验证、数字签名以及密码存储等方面。C#是一种...
在压缩包中的`Sha256`文件很可能是实现了SHA-256算法的C语言源代码,包含上述步骤的详细实现。通过阅读和理解这段代码,可以深入了解SHA-256的工作原理,并学习如何在实际项目中应用这种强大的安全工具。
SHA256是一种广泛使用的密码学哈希函数,它能够将任意长度的输入(也称为预映射消息)转换为固定长度的输出,通常为256位的哈希值。这种哈希函数的设计旨在提供数据完整性检查和密码学安全特性,常用于数字签名、...
SHA256 和 HMAC-SHA256 的C语言实现,只有一个文件,无库依赖。使用方法见源码底部注释说明