64,660
社区成员
发帖
与我相关
我的任务
分享求一个 sha512算法。 谢谢 50分。
求一个 sha512算法。 谢谢 50分。
求一个 sha512算法。 谢谢 50分。
求一个 sha512算法。 谢谢 50分。
求一个 sha512算法。 谢谢 50分。
求一个 sha512算法。 谢谢 50分。
...全文
请发表友善的回复…
发表回复
waizqfor 2009-01-21
- 打赏
- 举报
C#的代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
namespace MD5Test
{
class Program
{
//MD5 16位加密
public static string md5Encode16(string source)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(source)), 4, 8);
return t2;
}
//MD5 32位加密
public static string md5Encode32(string source)
{
string cl = source;
string pwd = "";
MD5 md5 = MD5.Create();//实例化一个md5对像
// 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择
byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl));
// 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得
for (int i = 0; i < s.Length; i++)
{
// 将得到的字符串使用十六进制类型格式化。'x'格式化后的字符是小写字母，如果使用大写'X',则格式后的字符是大写字符
pwd = pwd + s[i].ToString("X");
}
return pwd;
}
//SHA 512位加密
public static string sha512Encode(string source)
{
string result = "";
SHA512 sha512 = new SHA512Managed();
byte[] s = sha512.ComputeHash(Encoding.UTF8.GetBytes(source));
for (int i = 0; i < s.Length; i++)
{
result += s[i].ToString("X");
}
sha512.Clear();
return result;
}
static void Main(string[] args)
{
Console.WriteLine("Hello World! MD5 16 Encode: " + md5Encode16("Hello World!"));
Console.WriteLine("Hello World! MD5 32 Encode: " + md5Encode32("Hello World!"));
Console.WriteLine("Hello World! SHA 512 Encode: " + sha512Encode("Hello World!"));
}
}
}
xiaoyisnail 2009-01-21
- 打赏
- 举报
星羽 2009-01-21
- 打赏
- 举报
string Sha512::calcSha384(const string &filename, int *commSocket)
{
FILE *fd;
struct stat file_stat;
size_t read;
unsigned int bufSize;
off_t fileSize, i;
uint8_t ret[SHA384_DIGEST_SIZE];
struct sha512_ctx ctx;
if (unlikely(stat(filename.c_str(), &file_stat)))
return "";
fd = fopen(filename.c_str(), "r");
if (unlikely(!fd))
return "";
fileSize = file_stat.st_size;
string progrTmp(string("S") + tostr(fileSize) + '\n');
ThreadComm comm(commSocket);
comm.send(&progrTmp);
sha384_init(&ctx);
bufSize = calcBufSize(file_stat);
char *buf = new char[bufSize];
i = 0;
while (i < fileSize) {
read = fread(buf, 1, bufSize, fd);
i += read;
sha512_update(&ctx, reinterpret_cast<const uint8_t *>(buf),
read);
progrTmp = tostr(i) + '\n';
comm.send(&progrTmp);
}
fclose(fd);
delete [] buf;
sha384_final(&ctx, ret);
return charToHex(reinterpret_cast<const char *>(ret),
SHA384_DIGEST_SIZE);
}
string Sha512::calcSha512(const string &buf)
{
uint8_t ret[SHA512_DIGEST_SIZE];
struct sha512_ctx ctx;
sha512_init(&ctx);
sha512_update(&ctx, reinterpret_cast<const uint8_t *>(buf.c_str()),
static_cast<unsigned int>(buf.length()));
sha512_final(&ctx, ret);
return charToHex(reinterpret_cast<const char *>(ret),
SHA512_DIGEST_SIZE);
}
string Sha512::calcSha512(const string &filename, int *commSocket)
{
FILE *fd;
struct stat file_stat;
size_t read;
unsigned int bufSize;
off_t fileSize, i;
uint8_t ret[SHA512_DIGEST_SIZE];
struct sha512_ctx ctx;
if (unlikely(stat(filename.c_str(), &file_stat)))
return "";
fd = fopen(filename.c_str(), "r");
if (unlikely(!fd))
return "";
fileSize = file_stat.st_size;
string progrTmp(string("S") + tostr(fileSize) + '\n');
ThreadComm comm(commSocket);
comm.send(&progrTmp);
sha512_init(&ctx);
bufSize = calcBufSize(file_stat);
char *buf = new char[bufSize];
i = 0;
while (i < fileSize) {
read = fread(buf, 1, bufSize, fd);
i += read;
sha512_update(&ctx, reinterpret_cast<const uint8_t *>(buf),
read);
progrTmp = tostr(i) + '\n';
comm.send(&progrTmp);
}
fclose(fd);
delete [] buf;
sha512_final(&ctx, ret);
return charToHex(reinterpret_cast<const char *>(ret),
SHA512_DIGEST_SIZE);星羽 2009-01-21
- 打赏
- 举报
void Sha512::sha384_init(struct sha512_ctx *ctx)
{
struct sha512_ctx *sctx = ctx;
sctx->state[0] = SHA512HP0;
sctx->state[1] = SHA512HP1;
sctx->state[2] = SHA512HP2;
sctx->state[3] = SHA512HP3;
sctx->state[4] = SHA512HP4;
sctx->state[5] = SHA512HP5;
sctx->state[6] = SHA512HP6;
sctx->state[7] = SHA512HP7;
sctx->count[0] = sctx->count[1] = sctx->count[2] = sctx->count[3] = 0;
memset(sctx->buf, 0, sizeof(sctx->buf));
}
void Sha512::sha512_update(struct sha512_ctx *ctx, const uint8_t *data, unsigned int len)
{
struct sha512_ctx *sctx = ctx;
unsigned int i, index, part_len;
/* Compute number of bytes mod 128 */
index = (unsigned int)((sctx->count[0] >> 3) & 0x7F);
/* Update number of bits */
if ((sctx->count[0] += (len << 3)) < (len << 3)) {
if ((sctx->count[1] += 1) < 1)
if ((sctx->count[2] += 1) < 1)
sctx->count[3]++;
sctx->count[1] += (len >> 29);
}
part_len = 128 - index;
/* Transform as many times as possible. */
if (len >= part_len) {
memcpy(&sctx->buf[index], data, part_len);
sha512_transform(sctx->state, sctx->buf);
for (i = part_len; i + 127 < len; i+=128)
sha512_transform(sctx->state, &data[i]);
index = 0;
} else {
i = 0;
}
/* Buffer remaining input */
memcpy(&sctx->buf[index], &data[i], len - i);
}
void Sha512::sha512_final(struct sha512_ctx *ctx, uint8_t *hash)
{
struct sha512_ctx *sctx = ctx;
static const uint8_t padding[128] = { 0x80, };
uint32_t t;
uint64_t t2;
uint8_t bits[128];
unsigned int index, pad_len;
int i, j;
index = pad_len = t = i = j = 0;
t2 = 0;
/* Save number of bits */
t = sctx->count[0];
bits[15] = t; t>>=8;
bits[14] = t; t>>=8;
bits[13] = t; t>>=8;
bits[12] = t;
t = sctx->count[1];
bits[11] = t; t>>=8;
bits[10] = t; t>>=8;
bits[9 ] = t; t>>=8;
bits[8 ] = t;
t = sctx->count[2];
bits[7 ] = t; t>>=8;
bits[6 ] = t; t>>=8;
bits[5 ] = t; t>>=8;
bits[4 ] = t;
t = sctx->count[3];
bits[3 ] = t; t>>=8;
bits[2 ] = t; t>>=8;
bits[1 ] = t; t>>=8;
bits[0 ] = t;
/* Pad out to 112 mod 128. */
index = (sctx->count[0] >> 3) & 0x7f;
pad_len = (index < 112) ? (112 - index) : ((128+112) - index);
sha512_update(sctx, padding, pad_len);
/* Append length (before padding) */
sha512_update(sctx, bits, 16);
/* Store state in digest */
for (i = j = 0; i < 8; i++, j += 8) {
t2 = sctx->state[i];
hash[j+7] = (char)t2 & 0xff; t2>>=8;
hash[j+6] = (char)t2 & 0xff; t2>>=8;
hash[j+5] = (char)t2 & 0xff; t2>>=8;
hash[j+4] = (char)t2 & 0xff; t2>>=8;
hash[j+3] = (char)t2 & 0xff; t2>>=8;
hash[j+2] = (char)t2 & 0xff; t2>>=8;
hash[j+1] = (char)t2 & 0xff; t2>>=8;
hash[j ] = (char)t2 & 0xff;
}
/* Zeroize sensitive information. */
memset(sctx, 0, sizeof(struct sha512_ctx));
}
void Sha512::sha384_final(struct sha512_ctx *ctx, uint8_t *hash)
{
struct sha512_ctx *sctx = ctx;
uint8_t D[64];
sha512_final(sctx, D);
memcpy(hash, D, 48);
memset(D, 0, 64);
}
bool Sha512::selfTest()
{
Sha512 sha512;
if (unlikely(!sha512.sha384_selfTest()))
return false;
if (unlikely(!sha512.sha512_selfTest()))
return false;
return true;
}
bool Sha512::sha384_selfTest()
{
string test1("abc");
string test1_md("CB00753F45A35E8BB5A03D699AC65007"
"272C32AB0EDED1631A8B605A43FF5BED"
"8086072BA1E7CC2358BAECA134C825A7");
string test2("abcdbcdecdefdefgefghfghighij"
"hijkijkljklmklmnlmnomnopnopq");
string test2_md("3391FDDDFC8DC7393707A65B1B470939"
"7CF8B1D162AF05ABFE8F450DE5F36BC6"
"B0455A8520BC4E6F5FE95B1FE3C8452B");
string test3("abcdefghbcdefghicdefghijdefg"
"hijkefghijklfghijklmghijklmn"
"hijklmnoijklmnopjklmnopqklmn"
"opqrlmnopqrsmnopqrstnopqrstu");
string test3_md("09330C33F71147E83D192FC782CD1B47"
"53111B173B3B05D22FA08086E3B0F712"
"FCC7C71A557E2DB966C3E9FA91746039");
string test4("abcdefghijklmnopqrstuvwxyzab"
"cdefghijklmnopqrstuvwxyzabcd"
"efghijklmnopqrstuvwxyzabcdef"
"ghijklmnopqrstuvwxyz");
string test4_md("3D208973AB3508DBBD7E2C2862BA290A"
"D3010E4978C198DC4D8FD014E582823A"
"89E16F9B2A7BBC1AC938E2D199E8BEA4");
if (unlikely(calcSha384(test1) != test1_md))
return false;
if (unlikely(calcSha384(test2) != test2_md))
return false;
if (unlikely(calcSha384(test3) != test3_md))
return false;
if (unlikely(calcSha384(test4) != test4_md))
return false;
return true;
}
bool Sha512::sha512_selfTest()
{
string test1("abc");
string test1_md("DDAF35A193617ABACC417349AE204131"
"12E6FA4E89A97EA20A9EEEE64B55D39A"
"2192992A274FC1A836BA3C23A3FEEBBD"
"454D4423643CE80E2A9AC94FA54CA49F");
string test2("abcdbcdecdefdefgefghfghighij"
"hijkijkljklmklmnlmnomnopnopq");
string test2_md("204A8FC6DDA82F0A0CED7BEB8E08A416"
"57C16EF468B228A8279BE331A703C335"
"96FD15C13B1B07F9AA1D3BEA57789CA0"
"31AD85C7A71DD70354EC631238CA3445");
string test3("abcdefghbcdefghicdefghijdefg"
"hijkefghijklfghijklmghijklmn"
"hijklmnoijklmnopjklmnopqklmn"
"opqrlmnopqrsmnopqrstnopqrstu");
string test3_md("8E959B75DAE313DA8CF4F72814FC143F"
"8F7779C6EB9F7FA17299AEADB6889018"
"501D289E4900F7E4331B99DEC4B5433A"
"C7D329EEB6DD26545E96E55B874BE909");
string test4("abcdefghijklmnopqrstuvwxyzab"
"cdefghijklmnopqrstuvwxyzabcd"
"efghijklmnopqrstuvwxyzabcdef"
"ghijklmnopqrstuvwxyz");
string test4_md("930D0CEFCB30FF1133B6898121F1CF3D"
"27578AFCAFE8677C5257CF069911F75D"
"8F5831B56EBFDA67B278E66DFF8B84FE"
"2B2870F742A580D8EDB41987232850C9");
if (unlikely(calcSha512(test1) != test1_md))
return false;
if (unlikely(calcSha512(test2) != test2_md))
return false;
if (unlikely(calcSha512(test3) != test3_md))
return false;
if (unlikely(calcSha512(test4) != test4_md))
return false;
return true;
}
string Sha512::calcSha384(const string &buf)
{
uint8_t ret[SHA384_DIGEST_SIZE];
struct sha512_ctx ctx;
sha384_init(&ctx);
sha512_update(&ctx, reinterpret_cast<const uint8_t *>(buf.c_str()),
static_cast<unsigned int>(buf.length()));
sha384_final(&ctx, ret);
return charToHex(reinterpret_cast<const char *>(ret),
SHA384_DIGEST_SIZE);
}星羽 2009-01-21
- 打赏
- 举报
.cpp
/
#include "sha512.h"
#include "threadcomm.h"
#include <stdio.h>
#include <sys/stat.h>
#define SHA384_DIGEST_SIZE 48
#define SHA512_DIGEST_SIZE 64
#define SHA384_HMAC_BLOCK_SIZE 96
#define SHA512_HMAC_BLOCK_SIZE 128
static const uint64_t sha512_K[80] = {
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,
};
#define SHA512e0(x) (RORuint64_t(x,28) ^ RORuint64_t(x,34) ^ RORuint64_t(x,39))
#define SHA512e1(x) (RORuint64_t(x,14) ^ RORuint64_t(x,18) ^ RORuint64_t(x,41))
#define SHA512s0(x) (RORuint64_t(x, 1) ^ RORuint64_t(x, 8) ^ (x >> 7))
#define SHA512s1(x) (RORuint64_t(x,19) ^ RORuint64_t(x,61) ^ (x >> 6))
/* H* initial state for SHA-512 */
#define SHA512H0 0x6a09e667f3bcc908ULL
#define SHA512H1 0xbb67ae8584caa73bULL
#define SHA512H2 0x3c6ef372fe94f82bULL
#define SHA512H3 0xa54ff53a5f1d36f1ULL
#define SHA512H4 0x510e527fade682d1ULL
#define SHA512H5 0x9b05688c2b3e6c1fULL
#define SHA512H6 0x1f83d9abfb41bd6bULL
#define SHA512H7 0x5be0cd19137e2179ULL
/* H'* initial state for SHA-384 */
#define SHA512HP0 0xcbbb9d5dc1059ed8ULL
#define SHA512HP1 0x629a292a367cd507ULL
#define SHA512HP2 0x9159015a3070dd17ULL
#define SHA512HP3 0x152fecd8f70e5939ULL
#define SHA512HP4 0x67332667ffc00b31ULL
#define SHA512HP5 0x8eb44a8768581511ULL
#define SHA512HP6 0xdb0c2e0d64f98fa7ULL
#define SHA512HP7 0x47b5481dbefa4fa4ULL
void Sha512::LOAD_OP(int I, uint64_t *W, const uint8_t *input)
{
uint64_t t1 = input[(8*I) ] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+1] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+2] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+3] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+4] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+5] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+6] & 0xff;
t1 <<= 8;
t1 |= input[(8*I)+7] & 0xff;
W[I] = t1;
}
void Sha512::BLEND_OP(int I, uint64_t *W)
{
W[I] = SHA512s1(W[I-2]) + W[I-7] + SHA512s0(W[I-15]) + W[I-16];
}
void Sha512::sha512_transform(uint64_t *state, const uint8_t *input)
{
uint64_t a, b, c, d, e, f, g, h, t1, t2;
uint64_t W[80];
int i;
/* load the input */
for (i = 0; i < 16; i++)
LOAD_OP(i, W, input);
for (i = 16; i < 80; i++) {
BLEND_OP(i, W);
}
/* load the state into our registers */
a=state[0]; b=state[1]; c=state[2]; d=state[3];
e=state[4]; f=state[5]; g=state[6]; h=state[7];
/* now iterate */
for (i=0; i<80; i+=8) {
t1 = h + SHA512e1(e) + Ch(e,f,g) + sha512_K[i ] + W[i ];
t2 = SHA512e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + SHA512e1(d) + Ch(d,e,f) + sha512_K[i+1] + W[i+1];
t2 = SHA512e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + SHA512e1(c) + Ch(c,d,e) + sha512_K[i+2] + W[i+2];
t2 = SHA512e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + SHA512e1(b) + Ch(b,c,d) + sha512_K[i+3] + W[i+3];
t2 = SHA512e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + SHA512e1(a) + Ch(a,b,c) + sha512_K[i+4] + W[i+4];
t2 = SHA512e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + SHA512e1(h) + Ch(h,a,b) + sha512_K[i+5] + W[i+5];
t2 = SHA512e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + SHA512e1(g) + Ch(g,h,a) + sha512_K[i+6] + W[i+6];
t2 = SHA512e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + SHA512e1(f) + Ch(f,g,h) + sha512_K[i+7] + W[i+7];
t2 = SHA512e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
}
state[0] += a; state[1] += b; state[2] += c; state[3] += d;
state[4] += e; state[5] += f; state[6] += g; state[7] += h;
/* erase our data */
a = b = c = d = e = f = g = h = t1 = t2 = 0;
memset(W, 0, 80 * sizeof(uint64_t));
}
void Sha512::sha512_init(struct sha512_ctx *ctx)
{
struct sha512_ctx *sctx = ctx;
sctx->state[0] = SHA512H0;
sctx->state[1] = SHA512H1;
sctx->state[2] = SHA512H2;
sctx->state[3] = SHA512H3;
sctx->state[4] = SHA512H4;
sctx->state[5] = SHA512H5;
sctx->state[6] = SHA512H6;
sctx->state[7] = SHA512H7;
sctx->count[0] = sctx->count[1] = sctx->count[2] = sctx->count[3] = 0;
memset(sctx->buf, 0, sizeof(sctx->buf));
}
星羽 2009-01-21
- 打赏
- 举报
.h
/***************************************************************************
* *
* copyright (C) 2003, 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* SHA-512 code by Jean-Luc Cooke <jlcooke@certainkey.com> *
* Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com> *
* Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk> *
* Copyright (c) 2003 Kyle McMartin <kyle@debian.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 *
* as published by the Free Software Foundation. *
* *
***************************************************************************/
#ifndef SHA512_H
#define SHA512_H
#include "globalstuff.h"
#include <stdint.h>
#include <string>
using std::string;
/** SHA512 and SHA384 hash algorithms */
class Sha512
{
struct sha512_ctx
{
uint64_t state[8];
uint32_t count[4];
uint8_t buf[128];
};
public:
Sha512() {}
virtual ~Sha512() {}
static bool selfTest();
string calcSha384(const string &buf);
string calcSha384(const string &filename, int *commSocket);
string calcSha512(const string &buf);
string calcSha512(const string &filename, int *commSocket);
protected:
uint64_t Ch(uint64_t x, uint64_t y, uint64_t z)
{ return ((x & y) ^ (~x & z)); }
uint64_t Maj(uint64_t x, uint64_t y, uint64_t z)
{ return ((x & y) ^ (x & z) ^ (y & z)); }
uint64_t RORuint64_t(uint64_t x, uint64_t y)
{ return (x >> y) | (x << (64 - y)); }
inline void LOAD_OP(int I, uint64_t *W, const uint8_t *input);
inline void BLEND_OP(int I, uint64_t *W);
void sha512_transform(uint64_t *state, const uint8_t *input);
void sha512_init(struct sha512_ctx *ctx);
void sha384_init(struct sha512_ctx *ctx);
void sha512_update(struct sha512_ctx *ctx, const uint8_t *data, unsigned int len);
void sha512_final(struct sha512_ctx *ctx, uint8_t *hash);
void sha384_final(struct sha512_ctx *ctx, uint8_t *hash);
bool sha384_selfTest();
bool sha512_selfTest();
};
#endif
