int
main(int argc, char** argv){
SndWave infile(argv[1], READ);
SndIn sig1(&infile,1);
SndIn sig2(&infile,2);
SndAiff output1(argv[2], OVERWRITE);
SndAiff output2(argv[3], OVERWRITE);
output1.SetOutput(1, &sig1);
output2.SetOutput(1, &sig1);
while(!infile.Eof()){
infile.Read();
sig1.DoProcess();
sig2.DoProcess();
output1.Write();
output2.Write();
}
return 0;
}
void EMDHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, InputArray _descriptors2, OutputArray _costMatrix)
{
// size of the costMatrix with dummies //
Mat descriptors1=_descriptors1.getMat();
Mat descriptors2=_descriptors2.getMat();
int costrows = std::max(descriptors1.rows, descriptors2.rows)+nDummies;
_costMatrix.create(costrows, costrows, CV_32F);
Mat costMatrix=_costMatrix.getMat();
// Obtain copies of the descriptors //
cv::Mat scd1=descriptors1.clone();
cv::Mat scd2=descriptors2.clone();
// row normalization //
for(int i=0; i<scd1.rows; i++)
{
cv::Mat row = scd1.row(i);
scd1.row(i)/=(sum(row)[0]+FLT_EPSILON);
}
for(int i=0; i<scd2.rows; i++)
{
cv::Mat row = scd2.row(i);
scd2.row(i)/=(sum(row)[0]+FLT_EPSILON);
}
// Compute the Cost Matrix //
for(int i=0; i<costrows; i++)
{
for(int j=0; j<costrows; j++)
{
if (i<scd1.rows && j<scd2.rows)
{
cv::Mat sig1(scd1.cols,2,CV_32F), sig2(scd2.cols,2,CV_32F);
sig1.col(0)=scd1.row(i).t();
sig2.col(0)=scd2.row(j).t();
for (int k=0; k<sig1.rows; k++)
{
sig1.at<float>(k,1)=float(k);
}
for (int k=0; k<sig2.rows; k++)
{
sig2.at<float>(k,1)=float(k);
}
costMatrix.at<float>(i,j) = cv::EMD(sig1, sig2, flag);
}
else
{
costMatrix.at<float>(i,j) = defaultCost;
}
}
}
}
static int what_status(int status)
{
int i;
char **tab;
i = 0;
tab = sig1();
while (i != (status - 1) && tab[i])
i++;
if (tab[i])
printf("Process receive a %s\n", tab[i]);
free_tab(tab);
return (-1);
}
static void SHA256_transform( SHA256_ctx* ctx )
{
int t;
unsigned int A = ctx->H[ 0 ];
unsigned int B = ctx->H[ 1 ];
unsigned int C = ctx->H[ 2 ];
unsigned int D = ctx->H[ 3 ];
unsigned int E = ctx->H[ 4 ];
unsigned int F = ctx->H[ 5 ];
unsigned int G = ctx->H[ 6 ];
unsigned int H = ctx->H[ 7 ];
unsigned int T1, T2;
unsigned int W[ 64 ];
memcpy( W, ctx->M, 64 );
for ( t = 16; t < 64; t++ )
{
W[ t ] = sig1(W[t-2]) + W[t-7] + sig0(W[t-15]) + W[t-16];
}
for ( t = 0; t < 64; t++ )
{
T1 = H + SIG1(E) + Ch(E,F,G) + K[t] + W[t];
T2 = SIG0(A) + Maj(A,B,C);
H = G;
G = F;
F = E;
E = D + T1;
D = C;
C = B;
B = A;
A = T1 + T2;
}
ctx->H[ 0 ] += A;
ctx->H[ 1 ] += B;
ctx->H[ 2 ] += C;
ctx->H[ 3 ] += D;
ctx->H[ 4 ] += E;
ctx->H[ 5 ] += F;
ctx->H[ 6 ] += G;
ctx->H[ 7 ] += H;
}
// Compute the mapping between linear array and the hypercube
// corresponding to all the trees.
void GeneratorTrees::ComputeCubeMapping()
{
assert(trees.length()>=1);
if (trees.length()==1) { // A single tree
ComputeOneGenMapping(map2array, trees[0]);
}
else { // more than one generator
// Compute the sub-mapping for every generator. Also prepare two hypercube
// signature objects for the index calculations, with the two ordering of
// the generators: one for the generators ordered by their index 0,1,2...
// and the other odred the generators by the order of their trees
Vec<long> dims1(INIT_SIZE,trees.length()), dims2(INIT_SIZE,trees.length());
Vec<Permut> genMappings(INIT_SIZE, trees.length());
for (long i=0; i<trees.length(); i++) {
dims1[i] = trees[i][0].getData().size;
ComputeOneGenMapping(genMappings[i], trees[i]);
}
getCubeDims(dims2);
CubeSignature sig1(dims1), sig2(dims2);
// Allocate space for the mapping
map2array.SetLength(sig1.getSize());
// Combine the generator perms to a single permutation over the cube
for (long i=0; i<map2array.length(); i++) {
long t=0;
for (long j1=0; j1<trees.length(); j1++) {
long j2 = trees[j1].getAuxKey();
long digit = sig1.getCoord(i,j1); // the j1 digit of i in base dims
digit = genMappings[j1][digit]; // apply the j1 permutation to it
t += digit * sig2.getProd(j2+1); // adds the permuted digit
}
map2array[i] = t;
}
}
// Compute the inverse permutation
map2cube.SetLength(map2array.length());
for (long i=0; i<map2array.length(); i++) map2cube[ map2array[i] ] = i;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
const size_t MAX_DEPTH = argc == 1 ? 10 : ACE_OS::atoi (argv[1]);
ACE_OS::atexit (exithook);
if (argc > 2)
ACE_Trace::set_nesting_indent (ACE_OS::atoi (argv[2]));
ACE_TRACE ("int ACE_TMAIN (int argc, ACE_TCHAR *argv[])");
ACE_Sig_Action sig1 ((ACE_SignalHandler) ACE_Trace::start_tracing,
SIGUSR1);
ACE_UNUSED_ARG (sig1);
ACE_Sig_Action sig2 ((ACE_SignalHandler) ACE_Trace::stop_tracing,
SIGUSR2);
ACE_UNUSED_ARG (sig2);
My_Task task (MAX_DEPTH);
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
int n_threads = argc > 3 ? ACE_OS::atoi (argv[3]) : 4;
if (task.activate (THR_BOUND | THR_DETACHED, n_threads) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"activate"),
-1);
// Wait for all the threads to exit.
ACE_Thread_Manager::instance ()->wait ();
#else
const int MAX_ITERATIONS = argc > 3 ? ACE_OS::atoi (argv[3]) : 10;
for (int i = 0; i < MAX_ITERATIONS; i++)
task.svc ();
#endif /* ACE_MT_SAFE */
// Destructor automatically called.
return 0;
}
// Elliptic Curve Digital Signature Algorithm Example
void ecdsa_ex () {
// Degree 163 Binary Field from fips186-2
use_NIST_B_163 ();
EC_Domain_Parameters dp = NIST_B_163;
ECPrivKey sk (dp);// generate a key pair from the EC domain parameters
std::string M ("correct message");
ECDSA sig1 (sk, OS2IP(SHA1(M))); // generate the signature
// DER encoding, is a common standard method of representing digital
// signatures
DER der_str (sig1);
HexEncoder hex_str (der_str);
// You might save the DER ecoded signature to a file or send it over
// the network here.
std::cout << "DER Encoding: " << hex_str << std::endl;
ECDSA sig2;
try { // try to catch any DER parsing errors
sig2 = der_str.toECDSA (); // decode the DER string
} catch (borzoiException e) { // print the error message and exit
e.debug_print ();
return;
}
ECPubKey pk (sk);
std::cout << "Checking signature against M: " << M.c_str () << "\n->";
std::cout << "SHA1(M): " << OS2IP(SHA1(M)) << std::endl;
if (sig2.verify(pk, OS2IP(SHA1(M)))) // try to verify the signature
std::cout << "valid signature\n";
else std::cout << "invalid signature\n";
M = "in" + M; // tamper with the message
std::cout << "Checking signature against M: " << M.c_str () << "\n->";
if (sig2.verify(pk, OS2IP(SHA1(M)))) // try to verify the signature
std::cout << "valid signature\n";
else std::cout << "invalid signature\n";
}
void Object::testSignal()
{
db_emit sig1();
}
std::complex<double> signal::correlation(const signal& other) const {
signal sig1(*this), sig2(other);
sig1 /= sig1.abs(); sig2 /= sig2.abs();
return sig1 ^ sig2;
}
void sha384Process(register sha384Param* sp)
{
#ifdef OPTIMIZE_SSE2
# if defined(_MSC_VER) || defined (__INTEL_COMPILER)
static const __m64 MASK = { 0x00FF00FF00FF00FF00 };
# elif defined(__GNUC__)
static const __m64 MASK = { 0x00FF00FF, 0x00FF00FF };
# else
# error
# endif
__m64 a, b, c, d, e, f, g, h, temp;
register __m64 *w;
register const __m64 *k;
register byte t;
w = (__m64*) sp->data;
t = 16;
while (t--)
{
temp = *w;
*(w++) = _m_pxor(
_mm_slli_si64(_m_pshufw(_m_pand(temp, MASK), 27), 8),
_m_pshufw(_m_pand(_mm_srli_si64(temp, 8), MASK), 27)
);
}
t = 64;
while (t--)
{
temp = _mm_add_si64(_mm_add_si64(sig1(w[-2]), w[-7]), _mm_add_si64(sig0(w[-15]), w[-16]));
*(w++) = temp;
}
w = (__m64*) sp->h;
a = w[0]; b = w[1]; c = w[2]; d = w[3];
e = w[4]; f = w[5]; g = w[6]; h = w[7];
w = (__m64*) sp->data;
k = (__m64*) SHA2_64BIT_K;
#else
register uint64_t a, b, c, d, e, f, g, h, temp;
register uint64_t *w;
register const uint64_t *k;
register byte t;
# if WORDS_BIGENDIAN
w = sp->data + 16;
# else
w = sp->data;
t = 16;
while (t--)
{
temp = swapu64(*w);
*(w++) = temp;
}
# endif
t = 64;
while (t--)
{
temp = sig1(w[-2]) + w[-7] + sig0(w[-15]) + w[-16];
*(w++) = temp;
}
w = sp->data;
a = sp->h[0]; b = sp->h[1]; c = sp->h[2]; d = sp->h[3];
e = sp->h[4]; f = sp->h[5]; g = sp->h[6]; h = sp->h[7];
k = SHA2_64BIT_K;
#endif
ROUND(a,b,c,d,e,f,g,h,w[ 0],k[ 0]);
ROUND(h,a,b,c,d,e,f,g,w[ 1],k[ 1]);
ROUND(g,h,a,b,c,d,e,f,w[ 2],k[ 2]);
ROUND(f,g,h,a,b,c,d,e,w[ 3],k[ 3]);
ROUND(e,f,g,h,a,b,c,d,w[ 4],k[ 4]);
ROUND(d,e,f,g,h,a,b,c,w[ 5],k[ 5]);
ROUND(c,d,e,f,g,h,a,b,w[ 6],k[ 6]);
ROUND(b,c,d,e,f,g,h,a,w[ 7],k[ 7]);
ROUND(a,b,c,d,e,f,g,h,w[ 8],k[ 8]);
ROUND(h,a,b,c,d,e,f,g,w[ 9],k[ 9]);
ROUND(g,h,a,b,c,d,e,f,w[10],k[10]);
ROUND(f,g,h,a,b,c,d,e,w[11],k[11]);
ROUND(e,f,g,h,a,b,c,d,w[12],k[12]);
ROUND(d,e,f,g,h,a,b,c,w[13],k[13]);
ROUND(c,d,e,f,g,h,a,b,w[14],k[14]);
ROUND(b,c,d,e,f,g,h,a,w[15],k[15]);
ROUND(a,b,c,d,e,f,g,h,w[16],k[16]);
ROUND(h,a,b,c,d,e,f,g,w[17],k[17]);
ROUND(g,h,a,b,c,d,e,f,w[18],k[18]);
ROUND(f,g,h,a,b,c,d,e,w[19],k[19]);
ROUND(e,f,g,h,a,b,c,d,w[20],k[20]);
ROUND(d,e,f,g,h,a,b,c,w[21],k[21]);
ROUND(c,d,e,f,g,h,a,b,w[22],k[22]);
ROUND(b,c,d,e,f,g,h,a,w[23],k[23]);
ROUND(a,b,c,d,e,f,g,h,w[24],k[24]);
ROUND(h,a,b,c,d,e,f,g,w[25],k[25]);
ROUND(g,h,a,b,c,d,e,f,w[26],k[26]);
ROUND(f,g,h,a,b,c,d,e,w[27],k[27]);
ROUND(e,f,g,h,a,b,c,d,w[28],k[28]);
ROUND(d,e,f,g,h,a,b,c,w[29],k[29]);
ROUND(c,d,e,f,g,h,a,b,w[30],k[30]);
ROUND(b,c,d,e,f,g,h,a,w[31],k[31]);
ROUND(a,b,c,d,e,f,g,h,w[32],k[32]);
ROUND(h,a,b,c,d,e,f,g,w[33],k[33]);
ROUND(g,h,a,b,c,d,e,f,w[34],k[34]);
ROUND(f,g,h,a,b,c,d,e,w[35],k[35]);
ROUND(e,f,g,h,a,b,c,d,w[36],k[36]);
ROUND(d,e,f,g,h,a,b,c,w[37],k[37]);
ROUND(c,d,e,f,g,h,a,b,w[38],k[38]);
ROUND(b,c,d,e,f,g,h,a,w[39],k[39]);
ROUND(a,b,c,d,e,f,g,h,w[40],k[40]);
ROUND(h,a,b,c,d,e,f,g,w[41],k[41]);
ROUND(g,h,a,b,c,d,e,f,w[42],k[42]);
ROUND(f,g,h,a,b,c,d,e,w[43],k[43]);
ROUND(e,f,g,h,a,b,c,d,w[44],k[44]);
ROUND(d,e,f,g,h,a,b,c,w[45],k[45]);
ROUND(c,d,e,f,g,h,a,b,w[46],k[46]);
ROUND(b,c,d,e,f,g,h,a,w[47],k[47]);
ROUND(a,b,c,d,e,f,g,h,w[48],k[48]);
ROUND(h,a,b,c,d,e,f,g,w[49],k[49]);
ROUND(g,h,a,b,c,d,e,f,w[50],k[50]);
ROUND(f,g,h,a,b,c,d,e,w[51],k[51]);
ROUND(e,f,g,h,a,b,c,d,w[52],k[52]);
ROUND(d,e,f,g,h,a,b,c,w[53],k[53]);
ROUND(c,d,e,f,g,h,a,b,w[54],k[54]);
ROUND(b,c,d,e,f,g,h,a,w[55],k[55]);
ROUND(a,b,c,d,e,f,g,h,w[56],k[56]);
ROUND(h,a,b,c,d,e,f,g,w[57],k[57]);
ROUND(g,h,a,b,c,d,e,f,w[58],k[58]);
ROUND(f,g,h,a,b,c,d,e,w[59],k[59]);
ROUND(e,f,g,h,a,b,c,d,w[60],k[60]);
ROUND(d,e,f,g,h,a,b,c,w[61],k[61]);
ROUND(c,d,e,f,g,h,a,b,w[62],k[62]);
ROUND(b,c,d,e,f,g,h,a,w[63],k[63]);
ROUND(a,b,c,d,e,f,g,h,w[64],k[64]);
ROUND(h,a,b,c,d,e,f,g,w[65],k[65]);
ROUND(g,h,a,b,c,d,e,f,w[66],k[66]);
ROUND(f,g,h,a,b,c,d,e,w[67],k[67]);
ROUND(e,f,g,h,a,b,c,d,w[68],k[68]);
ROUND(d,e,f,g,h,a,b,c,w[69],k[69]);
ROUND(c,d,e,f,g,h,a,b,w[70],k[70]);
ROUND(b,c,d,e,f,g,h,a,w[71],k[71]);
ROUND(a,b,c,d,e,f,g,h,w[72],k[72]);
ROUND(h,a,b,c,d,e,f,g,w[73],k[73]);
ROUND(g,h,a,b,c,d,e,f,w[74],k[74]);
ROUND(f,g,h,a,b,c,d,e,w[75],k[75]);
ROUND(e,f,g,h,a,b,c,d,w[76],k[76]);
ROUND(d,e,f,g,h,a,b,c,w[77],k[77]);
ROUND(c,d,e,f,g,h,a,b,w[78],k[78]);
ROUND(b,c,d,e,f,g,h,a,w[79],k[79]);
#ifdef OPTIMIZE_SSE2
w = (__m64*) sp->h;
w[0] = _mm_add_si64(w[0], a);
w[1] = _mm_add_si64(w[1], b);
w[2] = _mm_add_si64(w[2], c);
w[3] = _mm_add_si64(w[3], d);
w[4] = _mm_add_si64(w[4], e);
w[5] = _mm_add_si64(w[5], f);
w[6] = _mm_add_si64(w[6], g);
w[7] = _mm_add_si64(w[7], h);
_mm_empty();
#else
sp->h[0] += a;
sp->h[1] += b;
sp->h[2] += c;
sp->h[3] += d;
sp->h[4] += e;
sp->h[5] += f;
sp->h[6] += g;
sp->h[7] += h;
#endif
}
inline bool TRobustRegressionL1PD(
const MATRIX_TYPE& A,
const Eigen::Matrix<REAL, Eigen::Dynamic, 1>& y,
Eigen::Matrix<REAL, Eigen::Dynamic, 1>& xp,
REAL pdtol=1e-3, unsigned pdmaxiter=50)
{
typedef Eigen::Matrix<REAL, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Matrix;
typedef Eigen::Matrix<REAL, Eigen::Dynamic, 1> Vector;
const unsigned M = (unsigned)y.size();
const unsigned N = (unsigned)xp.size();
assert(A.rows() == M && A.cols() == N);
const REAL alpha(0.01);
const REAL beta(0.5);
const REAL mu(10);
Vector x(xp);
Vector Ax(A*x);
Vector tmpM1(y-Ax);
Vector tmpM2(-tmpM1);
Vector tmpM3(tmpM1.cwiseAbs()), tmpM4(M);
Vector u = (tmpM3*REAL(0.95)).array() + tmpM3.maxCoeff()*REAL(0.10);
Vector fu1 = tmpM2-u;
Vector fu2 = tmpM1-u;
Vector lamu1(M), lamu2(M);
for (unsigned i=0; i<M; ++i) {
lamu1(i) = -1.0/fu1(i);
lamu2(i) = -1.0/fu2(i);
}
const MATRIX_TYPE At(A.transpose());
Vector Atv(At*(lamu1-lamu2));
REAL AtvNormSq = Atv.squaredNorm();
Vector rdual((-lamu1-lamu2).array() + REAL(1));
REAL rdualNormSq = rdual.squaredNorm();
Vector w2(M), sig1(M), sig2(M), sigx(M), dx(N), up(N), Atdv(N);
Vector Axp(M), Atvp(M);
Vector &Adx(sigx), &du(w2), &w1p(dx);
Matrix H11p(N,N);
Vector &dlamu1(tmpM3), &dlamu2(tmpM4);
for (unsigned pditer=0; pditer<pdmaxiter; ++pditer) {
// surrogate duality gap
const REAL sdg(-(fu1.dot(lamu1) + fu2.dot(lamu2)));
if (sdg < pdtol)
break;
const REAL tau(mu*2*M/sdg);
const REAL inv_tau = REAL(-1)/tau;
tmpM1 = (-lamu1.cwiseProduct(fu1)).array() + inv_tau;
tmpM2 = (-lamu2.cwiseProduct(fu2)).array() + inv_tau;
const REAL resnorm = sqrt(AtvNormSq + rdualNormSq + tmpM1.squaredNorm() + tmpM2.squaredNorm());
for (unsigned i=0; i<M; ++i) {
REAL& tmpM3i = tmpM3(i);
tmpM3i = inv_tau/fu1(i);
REAL& tmpM4i = tmpM4(i);
tmpM4i = inv_tau/fu2(i);
w2(i) = tmpM3i + tmpM4i - REAL(1);
}
tmpM1 = lamu1.cwiseQuotient(fu1);
tmpM2 = lamu2.cwiseQuotient(fu2);
sig1 = -tmpM1 - tmpM2;
sig2 = tmpM1 - tmpM2;
sigx = sig1 - sig2.cwiseAbs2().cwiseQuotient(sig1);
H11p = At*(Eigen::DiagonalMatrix<REAL,Eigen::Dynamic>(sigx)*A);
w1p = At*(tmpM4 - tmpM3 - (sig2.cwiseQuotient(sig1).cwiseProduct(w2)));
// optimized solver as A is positive definite and symmetric
dx = H11p.ldlt().solve(w1p);
Adx = A*dx;
du = (w2 - sig2.cwiseProduct(Adx)).cwiseQuotient(sig1);
dlamu1 = -tmpM1.cwiseProduct(Adx-du) - lamu1 + tmpM3;
dlamu2 = tmpM2.cwiseProduct(Adx+du) - lamu2 + tmpM4;
Atdv = At*(dlamu1-dlamu2);
// make sure that the step is feasible: keeps lamu1,lamu2 > 0, fu1,fu2 < 0
REAL s(1);
for (unsigned i=0; i<M; ++i) {
REAL& dlamu1i = dlamu1(i);
if (dlamu1i < 0) {
const REAL tmp = -lamu1(i)/dlamu1i;
if (s > tmp)
s = tmp;
}
REAL& dlamu2i = dlamu2(i);
if (dlamu2i < 0) {
const REAL tmp = -lamu2(i)/dlamu2i;
if (s > tmp)
s = tmp;
}
}
for (unsigned i=0; i<M; ++i) {
REAL& Adxi = Adx(i);
REAL& dui = du(i);
REAL Adx_du = Adxi-dui;
if (Adx_du > 0) {
const REAL tmp = -fu1(i)/Adx_du;
if (s > tmp)
s = tmp;
}
Adx_du = -Adxi-dui;
if (Adx_du > 0) {
const REAL tmp = -fu2(i)/Adx_du;
if (s > tmp)
s = tmp;
}
}
s *= REAL(0.99);
// backtrack
lamu1 += s*dlamu1; lamu2 += s*dlamu2;
rdual = (-lamu1-lamu2).array() + REAL(1);
rdualNormSq = rdual.squaredNorm();
bool suffdec = false;
unsigned backiter = 0;
do {
xp = x + s*dx; up = u + s*du;
Axp = Ax + s*Adx; Atvp = Atv + s*Atdv;
fu1 = Axp - y - up; fu2 = -Axp + y - up;
AtvNormSq = Atvp.squaredNorm();
tmpM1 = (-lamu1.cwiseProduct(fu1)).array() + inv_tau;
tmpM2 = (-lamu2.cwiseProduct(fu2)).array() + inv_tau;
const REAL newresnorm = sqrt(AtvNormSq + rdualNormSq + tmpM1.squaredNorm() + tmpM2.squaredNorm());
suffdec = (newresnorm <= (REAL(1)-alpha*s)*resnorm);
s = beta*s;
if (++backiter > 32) {
//("error: stuck backtracking, returning last iterate"); // see Section 4 of notes for more information
xp.swap(x);
return false;
}
} while (!suffdec);
// next iteration
x.swap(xp); u.swap(up);
Ax.swap(Axp); Atv.swap(Atvp);
}
return true;
}
int main(int argc, char* argv[]) {
if(argc < 2) {
printf("Usage: sha256 <string>\n");
return 0;
}
// 4.2.2
uint32_t K[] = {
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
};
// 5.3.2
uint32_t H[] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};
char* msg = argv[1];
size_t len = strlen(msg);
// 5.1.1
uint64_t l = len * sizeof(char) * 8;
size_t k = (448 - l - 1) % 512;
if(k < 0) k += 512;
assert((l+1+k) % 512 == 448);
size_t msgSize = l + 1 + k + 64;
char* msgPad = (char*)calloc((msgSize / 8), sizeof(char));
memcpy(msgPad, msg, len);
msgPad[len] = 0x80;
l = swapE64(l);
memcpy(msgPad+(msgSize/8)-8, &l, 8);
// 5.2.1
size_t N = msgSize / 512;
// 6.2
uint32_t v[8];
uint32_t W[64];
uint32_t* M = (uint32_t*)msgPad;
uint32_t T1, T2;
for(size_t i = 0; i < N * 16; i++) {
M[i] = swapE32(M[i]);
}
// 6.2.2
for(size_t i = 0; i < N; i++) {
// 1
for(size_t t = 0; t < 16; t++) {
W[t] = M[i*16 + t];
}
for(size_t t = 16; t < 64; t++) {
W[t] = sig1(W[t-2]) + W[t-7] + sig0(W[t-15]) + W[t-16];
}
// 2
for(size_t t = 0; t < 8; t++) {
v[t] = H[t];
}
// 3
for(size_t t = 0; t < 64; t++) {
// a=0 b=1 c=2 d=3 e=4 f=5 g=6 h=7
T1 = v[7] + ep1(v[4]) + Ch(v[4], v[5], v[6]) + K[t] + W[t];
T2 = ep0(v[0]) + Maj(v[0], v[1], v[2]);
v[7] = v[6];
v[6] = v[5];
v[5] = v[4];
v[4] = v[3] + T1;
v[3] = v[2];
v[2] = v[1];
v[1] = v[0];
v[0] = T1 + T2;
}
for(size_t t = 0; t < 8; t++) {
H[t] += v[t];
}
}
for(size_t i = 0; i < 8; i++) {
H[i] = swapE32(H[i]);
hex(&H[i], 4);
}
printf("\n");
free(msgPad);
return 0;
}
