Duke Leto
3 years ago
2 changed files with 47 additions and 905 deletions
@ -1,901 +0,0 @@ |
|||
// Copyright (c) 2016-2020 The Hush developers
|
|||
// Distributed under the GPLv3 software license, see the accompanying
|
|||
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|||
/******************************************************************************
|
|||
* Copyright © 2014-2019 The SuperNET Developers. * |
|||
* * |
|||
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * |
|||
* the top-level directory of this distribution for the individual copyright * |
|||
* holder information and the developer policies on copyright and licensing. * |
|||
* * |
|||
* Unless otherwise agreed in a custom licensing agreement, no part of the * |
|||
* SuperNET software, including this file may be copied, modified, propagated * |
|||
* or distributed except according to the terms contained in the LICENSE file * |
|||
* * |
|||
* Removal or modification of this copyright notice is prohibited. * |
|||
* * |
|||
******************************************************************************/ |
|||
#include <stdio.h> |
|||
#include <stdint.h> |
|||
#include <stdlib.h> |
|||
#include <memory.h> |
|||
|
|||
uint64_t ASSETCHAINS_COMMISSION; |
|||
uint32_t ASSETCHAINS_MAGIC = 2387029918; |
|||
uint8_t ASSETCHAINS_OVERRIDE_PUBKEY33[33]; |
|||
|
|||
struct sha256_vstate { uint64_t length; uint32_t state[8],curlen; uint8_t buf[64]; }; |
|||
struct rmd160_vstate { uint64_t length; uint8_t buf[64]; uint32_t curlen, state[5]; }; |
|||
union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; }; |
|||
typedef union _bits256 bits256; |
|||
|
|||
// following is ported from libtom
|
|||
|
|||
#define STORE32L(x, y) \ |
|||
{ (y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); \ |
|||
(y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); } |
|||
|
|||
#define LOAD32L(x, y) \ |
|||
{ x = (uint32_t)(((uint64_t)((y)[3] & 255)<<24) | \ |
|||
((uint32_t)((y)[2] & 255)<<16) | \ |
|||
((uint32_t)((y)[1] & 255)<<8) | \ |
|||
((uint32_t)((y)[0] & 255))); } |
|||
|
|||
#define STORE64L(x, y) \ |
|||
{ (y)[7] = (uint8_t)(((x)>>56)&255); (y)[6] = (uint8_t)(((x)>>48)&255); \ |
|||
(y)[5] = (uint8_t)(((x)>>40)&255); (y)[4] = (uint8_t)(((x)>>32)&255); \ |
|||
(y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); \ |
|||
(y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); } |
|||
|
|||
#define LOAD64L(x, y) \ |
|||
{ x = (((uint64_t)((y)[7] & 255))<<56)|(((uint64_t)((y)[6] & 255))<<48)| \ |
|||
(((uint64_t)((y)[5] & 255))<<40)|(((uint64_t)((y)[4] & 255))<<32)| \ |
|||
(((uint64_t)((y)[3] & 255))<<24)|(((uint64_t)((y)[2] & 255))<<16)| \ |
|||
(((uint64_t)((y)[1] & 255))<<8)|(((uint64_t)((y)[0] & 255))); } |
|||
|
|||
#define STORE32H(x, y) \ |
|||
{ (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255); \ |
|||
(y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); } |
|||
|
|||
#define LOAD32H(x, y) \ |
|||
{ x = (uint32_t)(((uint64_t)((y)[0] & 255)<<24) | \ |
|||
((uint32_t)((y)[1] & 255)<<16) | \ |
|||
((uint32_t)((y)[2] & 255)<<8) | \ |
|||
((uint32_t)((y)[3] & 255))); } |
|||
|
|||
#define STORE64H(x, y) \ |
|||
{ (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \ |
|||
(y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \ |
|||
(y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \ |
|||
(y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); } |
|||
|
|||
#define LOAD64H(x, y) \ |
|||
{ x = (((uint64_t)((y)[0] & 255))<<56)|(((uint64_t)((y)[1] & 255))<<48) | \ |
|||
(((uint64_t)((y)[2] & 255))<<40)|(((uint64_t)((y)[3] & 255))<<32) | \ |
|||
(((uint64_t)((y)[4] & 255))<<24)|(((uint64_t)((y)[5] & 255))<<16) | \ |
|||
(((uint64_t)((y)[6] & 255))<<8)|(((uint64_t)((y)[7] & 255))); } |
|||
|
|||
// Various logical functions
|
|||
#define RORc(x, y) ( ((((uint32_t)(x)&0xFFFFFFFFUL)>>(uint32_t)((y)&31)) | ((uint32_t)(x)<<(uint32_t)(32-((y)&31)))) & 0xFFFFFFFFUL) |
|||
#define Ch(x,y,z) (z ^ (x & (y ^ z))) |
|||
#define Maj(x,y,z) (((x | y) & z) | (x & y)) |
|||
#define S(x, n) RORc((x),(n)) |
|||
#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n)) |
|||
#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) |
|||
#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) |
|||
#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) |
|||
#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) |
|||
#define MIN(x, y) ( ((x)<(y))?(x):(y) ) |
|||
|
|||
static inline int32_t sha256_vcompress(struct sha256_vstate * md,uint8_t *buf) |
|||
{ |
|||
uint32_t S[8],W[64],t0,t1,i; |
|||
for (i=0; i<8; i++) // copy state into S
|
|||
S[i] = md->state[i]; |
|||
for (i=0; i<16; i++) // copy the state into 512-bits into W[0..15]
|
|||
LOAD32H(W[i],buf + (4*i)); |
|||
for (i=16; i<64; i++) // fill W[16..63]
|
|||
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; |
|||
|
|||
#define RND(a,b,c,d,e,f,g,h,i,ki) \ |
|||
t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]; \ |
|||
t1 = Sigma0(a) + Maj(a, b, c); \ |
|||
d += t0; \ |
|||
h = t0 + t1; |
|||
|
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3); |
|||
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee); |
|||
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f); |
|||
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814); |
|||
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208); |
|||
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa); |
|||
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb); |
|||
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7); |
|||
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2); |
|||
#undef RND |
|||
for (i=0; i<8; i++) // feedback
|
|||
md->state[i] = md->state[i] + S[i]; |
|||
return(0); |
|||
} |
|||
|
|||
#undef RORc |
|||
#undef Ch |
|||
#undef Maj |
|||
#undef S |
|||
#undef R |
|||
#undef Sigma0 |
|||
#undef Sigma1 |
|||
#undef Gamma0 |
|||
#undef Gamma1 |
|||
|
|||
static inline void sha256_vinit(struct sha256_vstate * md) |
|||
{ |
|||
md->curlen = 0; |
|||
md->length = 0; |
|||
md->state[0] = 0x6A09E667UL; |
|||
md->state[1] = 0xBB67AE85UL; |
|||
md->state[2] = 0x3C6EF372UL; |
|||
md->state[3] = 0xA54FF53AUL; |
|||
md->state[4] = 0x510E527FUL; |
|||
md->state[5] = 0x9B05688CUL; |
|||
md->state[6] = 0x1F83D9ABUL; |
|||
md->state[7] = 0x5BE0CD19UL; |
|||
} |
|||
|
|||
static inline int32_t sha256_vprocess(struct sha256_vstate *md,const uint8_t *in,uint64_t inlen) |
|||
{ |
|||
uint64_t n; int32_t err; |
|||
if ( md->curlen > sizeof(md->buf) ) |
|||
return(-1); |
|||
while ( inlen > 0 ) |
|||
{ |
|||
if ( md->curlen == 0 && inlen >= 64 ) |
|||
{ |
|||
if ( (err= sha256_vcompress(md,(uint8_t *)in)) != 0 ) |
|||
return(err); |
|||
md->length += 64 * 8, in += 64, inlen -= 64; |
|||
} |
|||
else |
|||
{ |
|||
n = MIN(inlen,64 - md->curlen); |
|||
memcpy(md->buf + md->curlen,in,(size_t)n); |
|||
md->curlen += n, in += n, inlen -= n; |
|||
if ( md->curlen == 64 ) |
|||
{ |
|||
if ( (err= sha256_vcompress(md,md->buf)) != 0 ) |
|||
return(err); |
|||
md->length += 8*64; |
|||
md->curlen = 0; |
|||
} |
|||
} |
|||
} |
|||
return(0); |
|||
} |
|||
|
|||
static inline int32_t sha256_vdone(struct sha256_vstate *md,uint8_t *out) |
|||
{ |
|||
int32_t i; |
|||
if ( md->curlen >= sizeof(md->buf) ) |
|||
return(-1); |
|||
md->length += md->curlen * 8; // increase the length of the message
|
|||
md->buf[md->curlen++] = (uint8_t)0x80; // append the '1' bit
|
|||
// if len > 56 bytes we append zeros then compress. Then we can fall back to padding zeros and length encoding like normal.
|
|||
if ( md->curlen > 56 ) |
|||
{ |
|||
while ( md->curlen < 64 ) |
|||
md->buf[md->curlen++] = (uint8_t)0; |
|||
sha256_vcompress(md,md->buf); |
|||
md->curlen = 0; |
|||
} |
|||
while ( md->curlen < 56 ) // pad upto 56 bytes of zeroes
|
|||
md->buf[md->curlen++] = (uint8_t)0; |
|||
STORE64H(md->length,md->buf+56); // store length
|
|||
sha256_vcompress(md,md->buf); |
|||
for (i=0; i<8; i++) // copy output
|
|||
STORE32H(md->state[i],out+(4*i)); |
|||
return(0); |
|||
} |
|||
|
|||
void vcalc_sha256(char deprecated[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len) |
|||
{ |
|||
struct sha256_vstate md; |
|||
sha256_vinit(&md); |
|||
sha256_vprocess(&md,src,len); |
|||
sha256_vdone(&md,hash); |
|||
} |
|||
|
|||
bits256 bits256_doublesha256(char *deprecated,uint8_t *data,int32_t datalen) |
|||
{ |
|||
bits256 hash,hash2; int32_t i; |
|||
vcalc_sha256(0,hash.bytes,data,datalen); |
|||
vcalc_sha256(0,hash2.bytes,hash.bytes,sizeof(hash)); |
|||
for (i=0; i<sizeof(hash); i++) |
|||
hash.bytes[i] = hash2.bytes[sizeof(hash) - 1 - i]; |
|||
return(hash); |
|||
} |
|||
|
|||
|
|||
// rmd160: the five basic functions F(), G() and H()
|
|||
#define F(x, y, z) ((x) ^ (y) ^ (z)) |
|||
#define G(x, y, z) (((x) & (y)) | (~(x) & (z))) |
|||
#define H(x, y, z) (((x) | ~(y)) ^ (z)) |
|||
#define I(x, y, z) (((x) & (z)) | ((y) & ~(z))) |
|||
#define J(x, y, z) ((x) ^ ((y) | ~(z))) |
|||
#define ROLc(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL) |
|||
|
|||
/* the ten basic operations FF() through III() */ |
|||
#define FF(a, b, c, d, e, x, s) \ |
|||
(a) += F((b), (c), (d)) + (x);\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define GG(a, b, c, d, e, x, s) \ |
|||
(a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define HH(a, b, c, d, e, x, s) \ |
|||
(a) += H((b), (c), (d)) + (x) + 0x6ed9eba1UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define II(a, b, c, d, e, x, s) \ |
|||
(a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcUL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define JJ(a, b, c, d, e, x, s) \ |
|||
(a) += J((b), (c), (d)) + (x) + 0xa953fd4eUL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define FFF(a, b, c, d, e, x, s) \ |
|||
(a) += F((b), (c), (d)) + (x);\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define GGG(a, b, c, d, e, x, s) \ |
|||
(a) += G((b), (c), (d)) + (x) + 0x7a6d76e9UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define HHH(a, b, c, d, e, x, s) \ |
|||
(a) += H((b), (c), (d)) + (x) + 0x6d703ef3UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define III(a, b, c, d, e, x, s) \ |
|||
(a) += I((b), (c), (d)) + (x) + 0x5c4dd124UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
#define JJJ(a, b, c, d, e, x, s) \ |
|||
(a) += J((b), (c), (d)) + (x) + 0x50a28be6UL;\ |
|||
(a) = ROLc((a), (s)) + (e);\ |
|||
(c) = ROLc((c), 10); |
|||
|
|||
static int32_t rmd160_vcompress(struct rmd160_vstate *md,uint8_t *buf) |
|||
{ |
|||
uint32_t aa,bb,cc,dd,ee,aaa,bbb,ccc,ddd,eee,X[16]; |
|||
int i; |
|||
|
|||
/* load words X */ |
|||
for (i = 0; i < 16; i++){ |
|||
LOAD32L(X[i], buf + (4 * i)); |
|||
} |
|||
|
|||
/* load state */ |
|||
aa = aaa = md->state[0]; |
|||
bb = bbb = md->state[1]; |
|||
cc = ccc = md->state[2]; |
|||
dd = ddd = md->state[3]; |
|||
ee = eee = md->state[4]; |
|||
|
|||
/* round 1 */ |
|||
FF(aa, bb, cc, dd, ee, X[ 0], 11); |
|||
FF(ee, aa, bb, cc, dd, X[ 1], 14); |
|||
FF(dd, ee, aa, bb, cc, X[ 2], 15); |
|||
FF(cc, dd, ee, aa, bb, X[ 3], 12); |
|||
FF(bb, cc, dd, ee, aa, X[ 4], 5); |
|||
FF(aa, bb, cc, dd, ee, X[ 5], 8); |
|||
FF(ee, aa, bb, cc, dd, X[ 6], 7); |
|||
FF(dd, ee, aa, bb, cc, X[ 7], 9); |
|||
FF(cc, dd, ee, aa, bb, X[ 8], 11); |
|||
FF(bb, cc, dd, ee, aa, X[ 9], 13); |
|||
FF(aa, bb, cc, dd, ee, X[10], 14); |
|||
FF(ee, aa, bb, cc, dd, X[11], 15); |
|||
FF(dd, ee, aa, bb, cc, X[12], 6); |
|||
FF(cc, dd, ee, aa, bb, X[13], 7); |
|||
FF(bb, cc, dd, ee, aa, X[14], 9); |
|||
FF(aa, bb, cc, dd, ee, X[15], 8); |
|||
|
|||
/* round 2 */ |
|||
GG(ee, aa, bb, cc, dd, X[ 7], 7); |
|||
GG(dd, ee, aa, bb, cc, X[ 4], 6); |
|||
GG(cc, dd, ee, aa, bb, X[13], 8); |
|||
GG(bb, cc, dd, ee, aa, X[ 1], 13); |
|||
GG(aa, bb, cc, dd, ee, X[10], 11); |
|||
GG(ee, aa, bb, cc, dd, X[ 6], 9); |
|||
GG(dd, ee, aa, bb, cc, X[15], 7); |
|||
GG(cc, dd, ee, aa, bb, X[ 3], 15); |
|||
GG(bb, cc, dd, ee, aa, X[12], 7); |
|||
GG(aa, bb, cc, dd, ee, X[ 0], 12); |
|||
GG(ee, aa, bb, cc, dd, X[ 9], 15); |
|||
GG(dd, ee, aa, bb, cc, X[ 5], 9); |
|||
GG(cc, dd, ee, aa, bb, X[ 2], 11); |
|||
GG(bb, cc, dd, ee, aa, X[14], 7); |
|||
GG(aa, bb, cc, dd, ee, X[11], 13); |
|||
GG(ee, aa, bb, cc, dd, X[ 8], 12); |
|||
|
|||
/* round 3 */ |
|||
HH(dd, ee, aa, bb, cc, X[ 3], 11); |
|||
HH(cc, dd, ee, aa, bb, X[10], 13); |
|||
HH(bb, cc, dd, ee, aa, X[14], 6); |
|||
HH(aa, bb, cc, dd, ee, X[ 4], 7); |
|||
HH(ee, aa, bb, cc, dd, X[ 9], 14); |
|||
HH(dd, ee, aa, bb, cc, X[15], 9); |
|||
HH(cc, dd, ee, aa, bb, X[ 8], 13); |
|||
HH(bb, cc, dd, ee, aa, X[ 1], 15); |
|||
HH(aa, bb, cc, dd, ee, X[ 2], 14); |
|||
HH(ee, aa, bb, cc, dd, X[ 7], 8); |
|||
HH(dd, ee, aa, bb, cc, X[ 0], 13); |
|||
HH(cc, dd, ee, aa, bb, X[ 6], 6); |
|||
HH(bb, cc, dd, ee, aa, X[13], 5); |
|||
HH(aa, bb, cc, dd, ee, X[11], 12); |
|||
HH(ee, aa, bb, cc, dd, X[ 5], 7); |
|||
HH(dd, ee, aa, bb, cc, X[12], 5); |
|||
|
|||
/* round 4 */ |
|||
II(cc, dd, ee, aa, bb, X[ 1], 11); |
|||
II(bb, cc, dd, ee, aa, X[ 9], 12); |
|||
II(aa, bb, cc, dd, ee, X[11], 14); |
|||
II(ee, aa, bb, cc, dd, X[10], 15); |
|||
II(dd, ee, aa, bb, cc, X[ 0], 14); |
|||
II(cc, dd, ee, aa, bb, X[ 8], 15); |
|||
II(bb, cc, dd, ee, aa, X[12], 9); |
|||
II(aa, bb, cc, dd, ee, X[ 4], 8); |
|||
II(ee, aa, bb, cc, dd, X[13], 9); |
|||
II(dd, ee, aa, bb, cc, X[ 3], 14); |
|||
II(cc, dd, ee, aa, bb, X[ 7], 5); |
|||
II(bb, cc, dd, ee, aa, X[15], 6); |
|||
II(aa, bb, cc, dd, ee, X[14], 8); |
|||
II(ee, aa, bb, cc, dd, X[ 5], 6); |
|||
II(dd, ee, aa, bb, cc, X[ 6], 5); |
|||
II(cc, dd, ee, aa, bb, X[ 2], 12); |
|||
|
|||
/* round 5 */ |
|||
JJ(bb, cc, dd, ee, aa, X[ 4], 9); |
|||
JJ(aa, bb, cc, dd, ee, X[ 0], 15); |
|||
JJ(ee, aa, bb, cc, dd, X[ 5], 5); |
|||
JJ(dd, ee, aa, bb, cc, X[ 9], 11); |
|||
JJ(cc, dd, ee, aa, bb, X[ 7], 6); |
|||
JJ(bb, cc, dd, ee, aa, X[12], 8); |
|||
JJ(aa, bb, cc, dd, ee, X[ 2], 13); |
|||
JJ(ee, aa, bb, cc, dd, X[10], 12); |
|||
JJ(dd, ee, aa, bb, cc, X[14], 5); |
|||
JJ(cc, dd, ee, aa, bb, X[ 1], 12); |
|||
JJ(bb, cc, dd, ee, aa, X[ 3], 13); |
|||
JJ(aa, bb, cc, dd, ee, X[ 8], 14); |
|||
JJ(ee, aa, bb, cc, dd, X[11], 11); |
|||
JJ(dd, ee, aa, bb, cc, X[ 6], 8); |
|||
JJ(cc, dd, ee, aa, bb, X[15], 5); |
|||
JJ(bb, cc, dd, ee, aa, X[13], 6); |
|||
|
|||
/* parallel round 1 */ |
|||
JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8); |
|||
JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9); |
|||
JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9); |
|||
JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11); |
|||
JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13); |
|||
JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15); |
|||
JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15); |
|||
JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5); |
|||
JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7); |
|||
JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7); |
|||
JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8); |
|||
JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11); |
|||
JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14); |
|||
JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14); |
|||
JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12); |
|||
JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6); |
|||
|
|||
/* parallel round 2 */ |
|||
III(eee, aaa, bbb, ccc, ddd, X[ 6], 9); |
|||
III(ddd, eee, aaa, bbb, ccc, X[11], 13); |
|||
III(ccc, ddd, eee, aaa, bbb, X[ 3], 15); |
|||
III(bbb, ccc, ddd, eee, aaa, X[ 7], 7); |
|||
III(aaa, bbb, ccc, ddd, eee, X[ 0], 12); |
|||
III(eee, aaa, bbb, ccc, ddd, X[13], 8); |
|||
III(ddd, eee, aaa, bbb, ccc, X[ 5], 9); |
|||
III(ccc, ddd, eee, aaa, bbb, X[10], 11); |
|||
III(bbb, ccc, ddd, eee, aaa, X[14], 7); |
|||
III(aaa, bbb, ccc, ddd, eee, X[15], 7); |
|||
III(eee, aaa, bbb, ccc, ddd, X[ 8], 12); |
|||
III(ddd, eee, aaa, bbb, ccc, X[12], 7); |
|||
III(ccc, ddd, eee, aaa, bbb, X[ 4], 6); |
|||
III(bbb, ccc, ddd, eee, aaa, X[ 9], 15); |
|||
III(aaa, bbb, ccc, ddd, eee, X[ 1], 13); |
|||
III(eee, aaa, bbb, ccc, ddd, X[ 2], 11); |
|||
|
|||
/* parallel round 3 */ |
|||
HHH(ddd, eee, aaa, bbb, ccc, X[15], 9); |
|||
HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7); |
|||
HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15); |
|||
HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11); |
|||
HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8); |
|||
HHH(ddd, eee, aaa, bbb, ccc, X[14], 6); |
|||
HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6); |
|||
HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14); |
|||
HHH(aaa, bbb, ccc, ddd, eee, X[11], 12); |
|||
HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13); |
|||
HHH(ddd, eee, aaa, bbb, ccc, X[12], 5); |
|||
HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14); |
|||
HHH(bbb, ccc, ddd, eee, aaa, X[10], 13); |
|||
HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13); |
|||
HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7); |
|||
HHH(ddd, eee, aaa, bbb, ccc, X[13], 5); |
|||
|
|||
/* parallel round 4 */ |
|||
GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15); |
|||
GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5); |
|||
GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8); |
|||
GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11); |
|||
GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14); |
|||
GGG(ccc, ddd, eee, aaa, bbb, X[11], 14); |
|||
GGG(bbb, ccc, ddd, eee, aaa, X[15], 6); |
|||
GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14); |
|||
GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6); |
|||
GGG(ddd, eee, aaa, bbb, ccc, X[12], 9); |
|||
GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12); |
|||
GGG(bbb, ccc, ddd, eee, aaa, X[13], 9); |
|||
GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12); |
|||
GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5); |
|||
GGG(ddd, eee, aaa, bbb, ccc, X[10], 15); |
|||
GGG(ccc, ddd, eee, aaa, bbb, X[14], 8); |
|||
|
|||
/* parallel round 5 */ |
|||
FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8); |
|||
FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5); |
|||
FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12); |
|||
FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9); |
|||
FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12); |
|||
FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5); |
|||
FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14); |
|||
FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6); |
|||
FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8); |
|||
FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13); |
|||
FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6); |
|||
FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5); |
|||
FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15); |
|||
FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13); |
|||
FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11); |
|||
FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11); |
|||
|
|||
/* combine results */ |
|||
ddd += cc + md->state[1]; /* final result for md->state[0] */ |
|||
md->state[1] = md->state[2] + dd + eee; |
|||
md->state[2] = md->state[3] + ee + aaa; |
|||
md->state[3] = md->state[4] + aa + bbb; |
|||
md->state[4] = md->state[0] + bb + ccc; |
|||
md->state[0] = ddd; |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
/**
|
|||
Initialize the hash state |
|||
@param md The hash state you wish to initialize |
|||
@return 0 if successful |
|||
*/ |
|||
int rmd160_vinit(struct rmd160_vstate * md) |
|||
{ |
|||
md->state[0] = 0x67452301UL; |
|||
md->state[1] = 0xefcdab89UL; |
|||
md->state[2] = 0x98badcfeUL; |
|||
md->state[3] = 0x10325476UL; |
|||
md->state[4] = 0xc3d2e1f0UL; |
|||
md->curlen = 0; |
|||
md->length = 0; |
|||
return 0; |
|||
} |
|||
#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \ |
|||
int func_name (struct rmd160_vstate * md, const unsigned char *in, unsigned long inlen) \ |
|||
{ \ |
|||
unsigned long n; \ |
|||
int err; \ |
|||
if (md->curlen > sizeof(md->buf)) { \ |
|||
return -1; \ |
|||
} \ |
|||
while (inlen > 0) { \ |
|||
if (md->curlen == 0 && inlen >= block_size) { \ |
|||
if ((err = compress_name (md, (unsigned char *)in)) != 0) { \ |
|||
return err; \ |
|||
} \ |
|||
md->length += block_size * 8; \ |
|||
in += block_size; \ |
|||
inlen -= block_size; \ |
|||
} else { \ |
|||
n = MIN(inlen, (block_size - md->curlen)); \ |
|||
memcpy(md->buf + md->curlen, in, (size_t)n); \ |
|||
md->curlen += n; \ |
|||
in += n; \ |
|||
inlen -= n; \ |
|||
if (md->curlen == block_size) { \ |
|||
if ((err = compress_name (md, md->buf)) != 0) { \ |
|||
return err; \ |
|||
} \ |
|||
md->length += 8*block_size; \ |
|||
md->curlen = 0; \ |
|||
} \ |
|||
} \ |
|||
} \ |
|||
return 0; \ |
|||
} |
|||
|
|||
/**
|
|||
Process a block of memory though the hash |
|||
@param md The hash state |
|||
@param in The data to hash |
|||
@param inlen The length of the data (octets) |
|||
@return 0 if successful |
|||
*/ |
|||
HASH_PROCESS(rmd160_vprocess, rmd160_vcompress, rmd160, 64) |
|||
|
|||
/**
|
|||
Terminate the hash to get the digest |
|||
@param md The hash state |
|||
@param out [out] The destination of the hash (20 bytes) |
|||
@return 0 if successful |
|||
*/ |
|||
int rmd160_vdone(struct rmd160_vstate * md, unsigned char *out) |
|||
{ |
|||
int i; |
|||
if (md->curlen >= sizeof(md->buf)) { |
|||
return -1; |
|||
} |
|||
/* increase the length of the message */ |
|||
md->length += md->curlen * 8; |
|||
|
|||
/* append the '1' bit */ |
|||
md->buf[md->curlen++] = (unsigned char)0x80; |
|||
|
|||
/* if the length is currently above 56 bytes we append zeros
|
|||
* then compress. Then we can fall back to padding zeros and length |
|||
* encoding like normal. |
|||
*/ |
|||
if (md->curlen > 56) { |
|||
while (md->curlen < 64) { |
|||
md->buf[md->curlen++] = (unsigned char)0; |
|||
} |
|||
rmd160_vcompress(md, md->buf); |
|||
md->curlen = 0; |
|||
} |
|||
/* pad upto 56 bytes of zeroes */ |
|||
while (md->curlen < 56) { |
|||
md->buf[md->curlen++] = (unsigned char)0; |
|||
} |
|||
/* store length */ |
|||
STORE64L(md->length, md->buf+56); |
|||
rmd160_vcompress(md, md->buf); |
|||
/* copy output */ |
|||
for (i = 0; i < 5; i++) { |
|||
STORE32L(md->state[i], out+(4*i)); |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
void calc_rmd160(char deprecated[41],uint8_t buf[20],uint8_t *msg,int32_t len) |
|||
{ |
|||
struct rmd160_vstate md; |
|||
rmd160_vinit(&md); |
|||
rmd160_vprocess(&md,msg,len); |
|||
rmd160_vdone(&md, buf); |
|||
} |
|||
#undef F |
|||
#undef G |
|||
#undef H |
|||
#undef I |
|||
#undef J |
|||
#undef ROLc |
|||
#undef FF |
|||
#undef GG |
|||
#undef HH |
|||
#undef II |
|||
#undef JJ |
|||
#undef FFF |
|||
#undef GGG |
|||
#undef HHH |
|||
#undef III |
|||
#undef JJJ |
|||
|
|||
static const uint32_t crc32_tab[] = { |
|||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, |
|||
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, |
|||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, |
|||
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, |
|||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, |
|||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, |
|||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, |
|||
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, |
|||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, |
|||
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, |
|||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, |
|||
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, |
|||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, |
|||
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, |
|||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, |
|||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, |
|||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, |
|||
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, |
|||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, |
|||
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, |
|||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, |
|||
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, |
|||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, |
|||
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, |
|||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, |
|||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, |
|||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, |
|||
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, |
|||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, |
|||
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, |
|||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, |
|||
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, |
|||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, |
|||
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, |
|||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, |
|||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, |
|||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, |
|||
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, |
|||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, |
|||
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, |
|||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, |
|||
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, |
|||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d |
|||
}; |
|||
|
|||
uint32_t calc_crc32(uint32_t crc,const void *buf,size_t size) |
|||
{ |
|||
const uint8_t *p; |
|||
|
|||
p = (const uint8_t *)buf; |
|||
crc = crc ^ ~0U; |
|||
|
|||
while (size--) |
|||
crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); |
|||
|
|||
return crc ^ ~0U; |
|||
} |
|||
|
|||
void calc_rmd160_sha256(uint8_t rmd160[20],uint8_t *data,int32_t datalen) |
|||
{ |
|||
bits256 hash; |
|||
vcalc_sha256(0,hash.bytes,data,datalen); |
|||
calc_rmd160(0,rmd160,hash.bytes,sizeof(hash)); |
|||
} |
|||
|
|||
int32_t dragon_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp) |
|||
{ |
|||
int32_t i; uint64_t x; |
|||
if ( rwflag == 0 ) |
|||
{ |
|||
x = 0; |
|||
for (i=len-1; i>=0; i--) |
|||
{ |
|||
x <<= 8; |
|||
x |= serialized[i]; |
|||
} |
|||
switch ( len ) |
|||
{ |
|||
case 1: *(uint8_t *)endianedp = (uint8_t)x; break; |
|||
case 2: *(uint16_t *)endianedp = (uint16_t)x; break; |
|||
case 4: *(uint32_t *)endianedp = (uint32_t)x; break; |
|||
case 8: *(uint64_t *)endianedp = (uint64_t)x; break; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
x = 0; |
|||
switch ( len ) |
|||
{ |
|||
case 1: x = *(uint8_t *)endianedp; break; |
|||
case 2: x = *(uint16_t *)endianedp; break; |
|||
case 4: x = *(uint32_t *)endianedp; break; |
|||
case 8: x = *(uint64_t *)endianedp; break; |
|||
} |
|||
for (i=0; i<len; i++,x >>= 8) |
|||
serialized[i] = (uint8_t)(x & 0xff); |
|||
} |
|||
return(len); |
|||
} |
|||
|
|||
uint32_t hush_smartmagic(char *symbol,uint64_t supply,uint8_t *extraptr,int32_t extralen) |
|||
{ |
|||
uint8_t buf[512]; uint32_t crc0=0; int32_t len = 0; bits256 hash; |
|||
if ( strcmp(symbol,"KMD") == 0 ) |
|||
return(0x8de4eef9); |
|||
len = dragon_rwnum(1,&buf[len],sizeof(supply),(void *)&supply); |
|||
strcpy((char *)&buf[len],symbol); |
|||
len += strlen(symbol); |
|||
if ( extraptr != 0 && extralen != 0 ) |
|||
{ |
|||
vcalc_sha256(0,hash.bytes,extraptr,extralen); |
|||
crc0 = hash.uints[0]; |
|||
} |
|||
return(calc_crc32(crc0,buf,len)); |
|||
} |
|||
|
|||
uint16_t komodo_assetport(uint32_t magic,int32_t extralen) |
|||
{ |
|||
if ( magic == 0x8de4eef9 ) |
|||
return(7770); |
|||
else if ( extralen == 0 ) |
|||
return(8000 + (magic % 7777)); |
|||
else return(16000 + (magic % 49500)); |
|||
} |
|||
|
|||
uint16_t hush_port(char *symbol,uint64_t supply,uint32_t *magicp,uint8_t *extraptr,int32_t extralen) |
|||
{ |
|||
if ( symbol == 0 || symbol[0] == 0 || strcmp("KMD",symbol) == 0 ) |
|||
{ |
|||
*magicp = 0x8de4eef9; |
|||
return(7770); |
|||
} |
|||
*magicp = hush_smartmagic(symbol,supply,extraptr,extralen); |
|||
return(komodo_assetport(*magicp,extralen)); |
|||
} |
|||
|
|||
uint16_t komodo_calcport(char *name,uint64_t supply,uint64_t endsubsidy,uint64_t reward,uint64_t halving,uint64_t decay,uint64_t commission,uint8_t staked,int32_t cc) |
|||
{ |
|||
uint8_t extrabuf[4096],*extraptr=0; int32_t extralen=0; uint64_t val; |
|||
if ( halving != 0 && halving < 1440 ) |
|||
{ |
|||
halving = 1440; |
|||
printf("halving must be at least 1440 blocks\n"); |
|||
} |
|||
if ( decay == 100000000 && endsubsidy == 0 ) |
|||
{ |
|||
decay = 0; |
|||
printf("decay of 100000000 means linear and that needs endsubsidy\n"); |
|||
} |
|||
else if ( decay > 100000000 ) |
|||
{ |
|||
decay = 0; |
|||
printf("decay cant be more than 100000000\n"); |
|||
} |
|||
if ( endsubsidy != 0 || reward != 0 || halving != 0 || decay != 0 || commission != 0 || cc != 0 || staked != 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 ) |
|||
{ |
|||
//printf("end.%llu reward.%llu halving.%llu decay.%llu perc.%llu\n",(long long)endsubsidy,(long long)reward,(long long)halving,(long long)decay,(long long)commission);
|
|||
extraptr = extrabuf; |
|||
memcpy(extraptr,ASSETCHAINS_OVERRIDE_PUBKEY33,33), extralen = 33; |
|||
extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(endsubsidy),(void *)&endsubsidy); |
|||
extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(reward),(void *)&reward); |
|||
extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(halving),(void *)&halving); |
|||
extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(decay),(void *)&decay); |
|||
val = commission | (((uint64_t)staked & 0xff) << 32) | (((uint64_t)cc & 0xffffff) << 40); |
|||
extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(val),(void *)&val); |
|||
} |
|||
return(hush_port(name,supply,&ASSETCHAINS_MAGIC,extraptr,extralen)); |
|||
} |
|||
|
|||
int main(int argc, char * argv[]) |
|||
{ |
|||
uint16_t rpcport; int32_t i,j,offset=0,jsonflag=0,num = 1; uint64_t supply=10,commission=0,endsubsidy,reward,halving,decay; uint8_t *allocated=0,staked=0; uint32_t cc = 3; |
|||
endsubsidy = reward = halving = decay = 0; |
|||
if ( argc < 2 ) |
|||
{ |
|||
// staked, commission and cc hardcoded
|
|||
printf("%s name supply endsubsidy reward halving decay\n",argv[0]); |
|||
printf("%s -gen num name supply endsubsidy reward halving decay\n",argv[0]); |
|||
return(-1); |
|||
} |
|||
if ( strncmp(argv[1],"-gen",3) == 0 ) |
|||
{ |
|||
num = atoi(argv[2]); |
|||
if ( strcmp(argv[1],"-genjson") == 0 ) |
|||
jsonflag = 1; |
|||
offset = 2; |
|||
allocated = calloc(1,1 << 16); |
|||
} |
|||
if ( argc > offset + 2 ) |
|||
supply = (long long)atof(argv[offset + 2]); |
|||
if ( argc > offset + 3 ) |
|||
endsubsidy = (long long)atof(argv[offset + 3]); |
|||
if ( argc > offset + 4 ) |
|||
reward = (long long)atof(argv[offset + 4]); |
|||
if ( argc > offset + 5 ) |
|||
halving = (long long)atof(argv[offset + 5]); |
|||
if ( argc > offset + 6 ) |
|||
decay = (long long)atof(argv[offset + 6]); |
|||
rpcport = 1 + komodo_calcport(argv[offset + 1],supply,endsubsidy,reward,halving,decay,commission,staked,cc); |
|||
printf("./komodod -ac_name=%s -ac_cc=%u -ac_supply=%llu -ac_end=%llu -ac_reward=%llu -ac_halving=%llu -ac_decay=%llu & # rpcport %u\n[",argv[offset + 1],cc,(long long)supply,(long long)endsubsidy,(long long)reward,(long long)halving,(long long)decay,rpcport); |
|||
if ( allocated != 0 ) |
|||
{ |
|||
char name[64],newname[64]; |
|||
strcpy(name,argv[offset + 1]); |
|||
allocated[rpcport] = 1; |
|||
allocated[rpcport-1] = 1; |
|||
for (i=0; i<num; i++) |
|||
{ |
|||
sprintf(newname,"%s%03x",name,i); // limit 4096
|
|||
j = 0; |
|||
while ( 1 ) |
|||
{ |
|||
rpcport = 1 + komodo_calcport(newname,supply+j,endsubsidy,reward,halving,decay,commission,staked,cc); |
|||
if ( allocated[rpcport] == 0 && allocated[rpcport-1] == 0 ) |
|||
{ |
|||
if ( jsonflag == 0 ) |
|||
{ |
|||
printf("./komodod -ac_name=%s -ac_cc=%u -ac_supply=%llu -ac_end=%llu -ac_reward=%llu -ac_halving=%llu -ac_decay=%llu & # rpcport %u\n",newname,cc,(long long)supply+j,(long long)endsubsidy,(long long)reward,(long long)halving,(long long)decay,rpcport); |
|||
} |
|||
else |
|||
{ |
|||
printf("{ \"assetname\": \"%s\", \"p2p\": %u, \"rpc\": %u, \"supply\": %llu, \"ac_cc\": %u, \"ac_reward\": %llu, \"notarize\": %s }%s ",newname,rpcport-1,rpcport,(long long)supply+j,cc,(long long)reward,i<64?"true":"false",i<num-1?",":""); |
|||
} |
|||
allocated[rpcport] = 1; |
|||
allocated[rpcport-1] = 1; |
|||
break; |
|||
} |
|||
j++; |
|||
} |
|||
} |
|||
free(allocated); |
|||
} |
|||
printf("]\n"); |
|||
return(0); |
|||
} |
Loading…
Reference in new issue