]> Git Repo - VerusCoin.git/blame - src/komodo_utils.h
projects / VerusCoin.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
test
[VerusCoin.git] / src / komodo_utils.h
CommitLineData
d019c447 1/******************************************************************************
2 * Copyright © 2014-2016 The SuperNET Developers. *
3 * *
4 * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
5 * the top-level directory of this distribution for the individual copyright *
6 * holder information and the developer policies on copyright and licensing. *
7 * *
8 * Unless otherwise agreed in a custom licensing agreement, no part of the *
9 * SuperNET software, including this file may be copied, modified, propagated *
10 * or distributed except according to the terms contained in the LICENSE file *
11 * *
12 * Removal or modification of this copyright notice is prohibited. *
13 * *
14 ******************************************************************************/
3eea72f2 15
48fa27d9 16union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
17typedef union _bits256 bits256;
18
d019c447 19#include "mini-gmp.c"
20#include "uthash.h"
3eea72f2 21
22#define CRYPTO777_PUBSECPSTR "020e46e79a2a8d12b9b5d12c7a91adb4e454edfae43c0a0cb805427d2ac7613fd9"
b62d7030 23#define CRYPTO777_KMDADDR "RXL3YXG2ceaB6C5hfJcN4fvmLH2C34knhA"
24
d019c447 25#define KOMODO_PUBTYPE 60
26
d019c447 27struct sha256_vstate { uint64_t length; uint32_t state[8],curlen; uint8_t buf[64]; };
28struct rmd160_vstate { uint64_t length; uint8_t buf[64]; uint32_t curlen, state[5]; };
29
30// following is ported from libtom
31
32#define STORE32L(x, y) \
33{ (y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); \
34(y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); }
35
36#define LOAD32L(x, y) \
37{ x = (uint32_t)(((uint64_t)((y)[3] & 255)<<24) | \
38((uint32_t)((y)[2] & 255)<<16) | \
39((uint32_t)((y)[1] & 255)<<8) | \
40((uint32_t)((y)[0] & 255))); }
41
42#define STORE64L(x, y) \
43{ (y)[7] = (uint8_t)(((x)>>56)&255); (y)[6] = (uint8_t)(((x)>>48)&255); \
44(y)[5] = (uint8_t)(((x)>>40)&255); (y)[4] = (uint8_t)(((x)>>32)&255); \
45(y)[3] = (uint8_t)(((x)>>24)&255); (y)[2] = (uint8_t)(((x)>>16)&255); \
46(y)[1] = (uint8_t)(((x)>>8)&255); (y)[0] = (uint8_t)((x)&255); }
47
48#define LOAD64L(x, y) \
49{ x = (((uint64_t)((y)[7] & 255))<<56)|(((uint64_t)((y)[6] & 255))<<48)| \
50(((uint64_t)((y)[5] & 255))<<40)|(((uint64_t)((y)[4] & 255))<<32)| \
51(((uint64_t)((y)[3] & 255))<<24)|(((uint64_t)((y)[2] & 255))<<16)| \
52(((uint64_t)((y)[1] & 255))<<8)|(((uint64_t)((y)[0] & 255))); }
53
54#define STORE32H(x, y) \
55{ (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255); \
56(y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); }
57
58#define LOAD32H(x, y) \
59{ x = (uint32_t)(((uint64_t)((y)[0] & 255)<<24) | \
60((uint32_t)((y)[1] & 255)<<16) | \
61((uint32_t)((y)[2] & 255)<<8) | \
62((uint32_t)((y)[3] & 255))); }
63
64#define STORE64H(x, y) \
65{ (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \
66(y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \
67(y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \
68(y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); }
69
70#define LOAD64H(x, y) \
71{ x = (((uint64_t)((y)[0] & 255))<<56)|(((uint64_t)((y)[1] & 255))<<48) | \
72(((uint64_t)((y)[2] & 255))<<40)|(((uint64_t)((y)[3] & 255))<<32) | \
73(((uint64_t)((y)[4] & 255))<<24)|(((uint64_t)((y)[5] & 255))<<16) | \
74(((uint64_t)((y)[6] & 255))<<8)|(((uint64_t)((y)[7] & 255))); }
75
76// Various logical functions
77#define RORc(x, y) ( ((((uint32_t)(x)&0xFFFFFFFFUL)>>(uint32_t)((y)&31)) | ((uint32_t)(x)<<(uint32_t)(32-((y)&31)))) & 0xFFFFFFFFUL)
78#define Ch(x,y,z) (z ^ (x & (y ^ z)))
79#define Maj(x,y,z) (((x | y) & z) | (x & y))
80#define S(x, n) RORc((x),(n))
81#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
82#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
83#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
84#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
85#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
86#define MIN(x, y) ( ((x)<(y))?(x):(y) )
87
88static inline int32_t sha256_vcompress(struct sha256_vstate * md,uint8_t *buf)
89{
90 uint32_t S[8],W[64],t0,t1,i;
91 for (i=0; i<8; i++) // copy state into S
92 S[i] = md->state[i];
93 for (i=0; i<16; i++) // copy the state into 512-bits into W[0..15]
94 LOAD32H(W[i],buf + (4*i));
95 for (i=16; i<64; i++) // fill W[16..63]
96 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
97
98#define RND(a,b,c,d,e,f,g,h,i,ki) \
99t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]; \
100t1 = Sigma0(a) + Maj(a, b, c); \
101d += t0; \
102h = t0 + t1;
103
104 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98);
105 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491);
106 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf);
107 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5);
108 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b);
109 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1);
110 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4);
111 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5);
112 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98);
113 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01);
114 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be);
115 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3);
116 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74);
117 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe);
118 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7);
119 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174);
120 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1);
121 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786);
122 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6);
123 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc);
124 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f);
125 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa);
126 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc);
127 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da);
128 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152);
129 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d);
130 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8);
131 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7);
132 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3);
133 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147);
134 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351);
135 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967);
136 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85);
137 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138);
138 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc);
139 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13);
140 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354);
141 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb);
142 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e);
143 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85);
144 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1);
145 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b);
146 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70);
147 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3);
148 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819);
149 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624);
150 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585);
151 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070);
152 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116);
153 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08);
154 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c);
155 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5);
156 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3);
157 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a);
158 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f);
159 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3);
160 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee);
161 RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f);
162 RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814);
163 RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208);
164 RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa);
165 RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb);
166 RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7);
167 RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2);
168#undef RND
169 for (i=0; i<8; i++) // feedback
170 md->state[i] = md->state[i] + S[i];
171 return(0);
172}
173
174#undef RORc
175#undef Ch
176#undef Maj
177#undef S
178#undef R
179#undef Sigma0
180#undef Sigma1
181#undef Gamma0
182#undef Gamma1
183
184static inline void sha256_vinit(struct sha256_vstate * md)
185{
186 md->curlen = 0;
187 md->length = 0;
188 md->state[0] = 0x6A09E667UL;
189 md->state[1] = 0xBB67AE85UL;
190 md->state[2] = 0x3C6EF372UL;
191 md->state[3] = 0xA54FF53AUL;
192 md->state[4] = 0x510E527FUL;
193 md->state[5] = 0x9B05688CUL;
194 md->state[6] = 0x1F83D9ABUL;
195 md->state[7] = 0x5BE0CD19UL;
196}
197
198static inline int32_t sha256_vprocess(struct sha256_vstate *md,const uint8_t *in,uint64_t inlen)
199{
200 uint64_t n; int32_t err;
201 if ( md->curlen > sizeof(md->buf) )
202 return(-1);
203 while ( inlen > 0 )
204 {
205 if ( md->curlen == 0 && inlen >= 64 )
206 {
207 if ( (err= sha256_vcompress(md,(uint8_t *)in)) != 0 )
208 return(err);
209 md->length += 64 * 8, in += 64, inlen -= 64;
210 }
211 else
212 {
213 n = MIN(inlen,64 - md->curlen);
214 memcpy(md->buf + md->curlen,in,(size_t)n);
215 md->curlen += n, in += n, inlen -= n;
216 if ( md->curlen == 64 )
217 {
218 if ( (err= sha256_vcompress(md,md->buf)) != 0 )
219 return(err);
220 md->length += 8*64;
221 md->curlen = 0;
222 }
223 }
224 }
225 return(0);
226}
227
228static inline int32_t sha256_vdone(struct sha256_vstate *md,uint8_t *out)
229{
230 int32_t i;
231 if ( md->curlen >= sizeof(md->buf) )
232 return(-1);
233 md->length += md->curlen * 8; // increase the length of the message
234 md->buf[md->curlen++] = (uint8_t)0x80; // append the '1' bit
235 // if len > 56 bytes we append zeros then compress. Then we can fall back to padding zeros and length encoding like normal.
236 if ( md->curlen > 56 )
237 {
238 while ( md->curlen < 64 )
239 md->buf[md->curlen++] = (uint8_t)0;
240 sha256_vcompress(md,md->buf);
241 md->curlen = 0;
242 }
243 while ( md->curlen < 56 ) // pad upto 56 bytes of zeroes
244 md->buf[md->curlen++] = (uint8_t)0;
245 STORE64H(md->length,md->buf+56); // store length
246 sha256_vcompress(md,md->buf);
247 for (i=0; i<8; i++) // copy output
248 STORE32H(md->state[i],out+(4*i));
249 return(0);
250}
251
252void vcalc_sha256(char deprecated[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len)
253{
254 struct sha256_vstate md;
255 sha256_vinit(&md);
256 sha256_vprocess(&md,src,len);
257 sha256_vdone(&md,hash);
258}
259
260bits256 bits256_doublesha256(char *deprecated,uint8_t *data,int32_t datalen)
261{
262 bits256 hash,hash2; int32_t i;
263 vcalc_sha256(0,hash.bytes,data,datalen);
264 vcalc_sha256(0,hash2.bytes,hash.bytes,sizeof(hash));
265 for (i=0; i<sizeof(hash); i++)
266 hash.bytes[i] = hash2.bytes[sizeof(hash) - 1 - i];
267 return(hash);
268}
269
270// rmd160: the five basic functions F(), G() and H()
271#define F(x, y, z) ((x) ^ (y) ^ (z))
272#define G(x, y, z) (((x) & (y)) | (~(x) & (z)))
273#define H(x, y, z) (((x) | ~(y)) ^ (z))
274#define I(x, y, z) (((x) & (z)) | ((y) & ~(z)))
275#define J(x, y, z) ((x) ^ ((y) | ~(z)))
276#define ROLc(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
277
278/* the ten basic operations FF() through III() */
279#define FF(a, b, c, d, e, x, s) \
280(a) += F((b), (c), (d)) + (x);\
281(a) = ROLc((a), (s)) + (e);\
282(c) = ROLc((c), 10);
283
284#define GG(a, b, c, d, e, x, s) \
285(a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\
286(a) = ROLc((a), (s)) + (e);\
287(c) = ROLc((c), 10);
288
289#define HH(a, b, c, d, e, x, s) \
290(a) += H((b), (c), (d)) + (x) + 0x6ed9eba1UL;\
291(a) = ROLc((a), (s)) + (e);\
292(c) = ROLc((c), 10);
293
294#define II(a, b, c, d, e, x, s) \
295(a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcUL;\
296(a) = ROLc((a), (s)) + (e);\
297(c) = ROLc((c), 10);
298
299#define JJ(a, b, c, d, e, x, s) \
300(a) += J((b), (c), (d)) + (x) + 0xa953fd4eUL;\
301(a) = ROLc((a), (s)) + (e);\
302(c) = ROLc((c), 10);
303
304#define FFF(a, b, c, d, e, x, s) \
305(a) += F((b), (c), (d)) + (x);\
306(a) = ROLc((a), (s)) + (e);\
307(c) = ROLc((c), 10);
308
309#define GGG(a, b, c, d, e, x, s) \
310(a) += G((b), (c), (d)) + (x) + 0x7a6d76e9UL;\
311(a) = ROLc((a), (s)) + (e);\
312(c) = ROLc((c), 10);
313
314#define HHH(a, b, c, d, e, x, s) \
315(a) += H((b), (c), (d)) + (x) + 0x6d703ef3UL;\
316(a) = ROLc((a), (s)) + (e);\
317(c) = ROLc((c), 10);
318
319#define III(a, b, c, d, e, x, s) \
320(a) += I((b), (c), (d)) + (x) + 0x5c4dd124UL;\
321(a) = ROLc((a), (s)) + (e);\
322(c) = ROLc((c), 10);
323
324#define JJJ(a, b, c, d, e, x, s) \
325(a) += J((b), (c), (d)) + (x) + 0x50a28be6UL;\
326(a) = ROLc((a), (s)) + (e);\
327(c) = ROLc((c), 10);
328
329static int32_t rmd160_vcompress(struct rmd160_vstate *md,uint8_t *buf)
330{
331 uint32_t aa,bb,cc,dd,ee,aaa,bbb,ccc,ddd,eee,X[16];
332 int i;
333
334 /* load words X */
335 for (i = 0; i < 16; i++){
336 LOAD32L(X[i], buf + (4 * i));
337 }
338
339 /* load state */
340 aa = aaa = md->state[0];
341 bb = bbb = md->state[1];
342 cc = ccc = md->state[2];
343 dd = ddd = md->state[3];
344 ee = eee = md->state[4];
345
346 /* round 1 */
347 FF(aa, bb, cc, dd, ee, X[ 0], 11);
348 FF(ee, aa, bb, cc, dd, X[ 1], 14);
349 FF(dd, ee, aa, bb, cc, X[ 2], 15);
350 FF(cc, dd, ee, aa, bb, X[ 3], 12);
351 FF(bb, cc, dd, ee, aa, X[ 4], 5);
352 FF(aa, bb, cc, dd, ee, X[ 5], 8);
353 FF(ee, aa, bb, cc, dd, X[ 6], 7);
354 FF(dd, ee, aa, bb, cc, X[ 7], 9);
355 FF(cc, dd, ee, aa, bb, X[ 8], 11);
356 FF(bb, cc, dd, ee, aa, X[ 9], 13);
357 FF(aa, bb, cc, dd, ee, X[10], 14);
358 FF(ee, aa, bb, cc, dd, X[11], 15);
359 FF(dd, ee, aa, bb, cc, X[12], 6);
360 FF(cc, dd, ee, aa, bb, X[13], 7);
361 FF(bb, cc, dd, ee, aa, X[14], 9);
362 FF(aa, bb, cc, dd, ee, X[15], 8);
363
364 /* round 2 */
365 GG(ee, aa, bb, cc, dd, X[ 7], 7);
366 GG(dd, ee, aa, bb, cc, X[ 4], 6);
367 GG(cc, dd, ee, aa, bb, X[13], 8);
368 GG(bb, cc, dd, ee, aa, X[ 1], 13);
369 GG(aa, bb, cc, dd, ee, X[10], 11);
370 GG(ee, aa, bb, cc, dd, X[ 6], 9);
371 GG(dd, ee, aa, bb, cc, X[15], 7);
372 GG(cc, dd, ee, aa, bb, X[ 3], 15);
373 GG(bb, cc, dd, ee, aa, X[12], 7);
374 GG(aa, bb, cc, dd, ee, X[ 0], 12);
375 GG(ee, aa, bb, cc, dd, X[ 9], 15);
376 GG(dd, ee, aa, bb, cc, X[ 5], 9);
377 GG(cc, dd, ee, aa, bb, X[ 2], 11);
378 GG(bb, cc, dd, ee, aa, X[14], 7);
379 GG(aa, bb, cc, dd, ee, X[11], 13);
380 GG(ee, aa, bb, cc, dd, X[ 8], 12);
381
382 /* round 3 */
383 HH(dd, ee, aa, bb, cc, X[ 3], 11);
384 HH(cc, dd, ee, aa, bb, X[10], 13);
385 HH(bb, cc, dd, ee, aa, X[14], 6);
386 HH(aa, bb, cc, dd, ee, X[ 4], 7);
387 HH(ee, aa, bb, cc, dd, X[ 9], 14);
388 HH(dd, ee, aa, bb, cc, X[15], 9);
389 HH(cc, dd, ee, aa, bb, X[ 8], 13);
390 HH(bb, cc, dd, ee, aa, X[ 1], 15);
391 HH(aa, bb, cc, dd, ee, X[ 2], 14);
392 HH(ee, aa, bb, cc, dd, X[ 7], 8);
393 HH(dd, ee, aa, bb, cc, X[ 0], 13);
394 HH(cc, dd, ee, aa, bb, X[ 6], 6);
395 HH(bb, cc, dd, ee, aa, X[13], 5);
396 HH(aa, bb, cc, dd, ee, X[11], 12);
397 HH(ee, aa, bb, cc, dd, X[ 5], 7);
398 HH(dd, ee, aa, bb, cc, X[12], 5);
399
400 /* round 4 */
401 II(cc, dd, ee, aa, bb, X[ 1], 11);
402 II(bb, cc, dd, ee, aa, X[ 9], 12);
403 II(aa, bb, cc, dd, ee, X[11], 14);
404 II(ee, aa, bb, cc, dd, X[10], 15);
405 II(dd, ee, aa, bb, cc, X[ 0], 14);
406 II(cc, dd, ee, aa, bb, X[ 8], 15);
407 II(bb, cc, dd, ee, aa, X[12], 9);
408 II(aa, bb, cc, dd, ee, X[ 4], 8);
409 II(ee, aa, bb, cc, dd, X[13], 9);
410 II(dd, ee, aa, bb, cc, X[ 3], 14);
411 II(cc, dd, ee, aa, bb, X[ 7], 5);
412 II(bb, cc, dd, ee, aa, X[15], 6);
413 II(aa, bb, cc, dd, ee, X[14], 8);
414 II(ee, aa, bb, cc, dd, X[ 5], 6);
415 II(dd, ee, aa, bb, cc, X[ 6], 5);
416 II(cc, dd, ee, aa, bb, X[ 2], 12);
417
418 /* round 5 */
419 JJ(bb, cc, dd, ee, aa, X[ 4], 9);
420 JJ(aa, bb, cc, dd, ee, X[ 0], 15);
421 JJ(ee, aa, bb, cc, dd, X[ 5], 5);
422 JJ(dd, ee, aa, bb, cc, X[ 9], 11);
423 JJ(cc, dd, ee, aa, bb, X[ 7], 6);
424 JJ(bb, cc, dd, ee, aa, X[12], 8);
425 JJ(aa, bb, cc, dd, ee, X[ 2], 13);
426 JJ(ee, aa, bb, cc, dd, X[10], 12);
427 JJ(dd, ee, aa, bb, cc, X[14], 5);
428 JJ(cc, dd, ee, aa, bb, X[ 1], 12);
429 JJ(bb, cc, dd, ee, aa, X[ 3], 13);
430 JJ(aa, bb, cc, dd, ee, X[ 8], 14);
431 JJ(ee, aa, bb, cc, dd, X[11], 11);
432 JJ(dd, ee, aa, bb, cc, X[ 6], 8);
433 JJ(cc, dd, ee, aa, bb, X[15], 5);
434 JJ(bb, cc, dd, ee, aa, X[13], 6);
435
436 /* parallel round 1 */
437 JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8);
438 JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9);
439 JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9);
440 JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
441 JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
442 JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
443 JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
444 JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5);
445 JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7);
446 JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7);
447 JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8);
448 JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
449 JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
450 JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
451 JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
452 JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6);
453
454 /* parallel round 2 */
455 III(eee, aaa, bbb, ccc, ddd, X[ 6], 9);
456 III(ddd, eee, aaa, bbb, ccc, X[11], 13);
457 III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
458 III(bbb, ccc, ddd, eee, aaa, X[ 7], 7);
459 III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
460 III(eee, aaa, bbb, ccc, ddd, X[13], 8);
461 III(ddd, eee, aaa, bbb, ccc, X[ 5], 9);
462 III(ccc, ddd, eee, aaa, bbb, X[10], 11);
463 III(bbb, ccc, ddd, eee, aaa, X[14], 7);
464 III(aaa, bbb, ccc, ddd, eee, X[15], 7);
465 III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
466 III(ddd, eee, aaa, bbb, ccc, X[12], 7);
467 III(ccc, ddd, eee, aaa, bbb, X[ 4], 6);
468 III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
469 III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
470 III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
471
472 /* parallel round 3 */
473 HHH(ddd, eee, aaa, bbb, ccc, X[15], 9);
474 HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7);
475 HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
476 HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
477 HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8);
478 HHH(ddd, eee, aaa, bbb, ccc, X[14], 6);
479 HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6);
480 HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
481 HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
482 HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
483 HHH(ddd, eee, aaa, bbb, ccc, X[12], 5);
484 HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
485 HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
486 HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
487 HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7);
488 HHH(ddd, eee, aaa, bbb, ccc, X[13], 5);
489
490 /* parallel round 4 */
491 GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
492 GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5);
493 GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8);
494 GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
495 GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
496 GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
497 GGG(bbb, ccc, ddd, eee, aaa, X[15], 6);
498 GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
499 GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6);
500 GGG(ddd, eee, aaa, bbb, ccc, X[12], 9);
501 GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
502 GGG(bbb, ccc, ddd, eee, aaa, X[13], 9);
503 GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
504 GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5);
505 GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
506 GGG(ccc, ddd, eee, aaa, bbb, X[14], 8);
507
508 /* parallel round 5 */
509 FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8);
510 FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5);
511 FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
512 FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9);
513 FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
514 FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5);
515 FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
516 FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6);
517 FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8);
518 FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
519 FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6);
520 FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5);
521 FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
522 FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
523 FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
524 FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
525
526 /* combine results */
527 ddd += cc + md->state[1]; /* final result for md->state[0] */
528 md->state[1] = md->state[2] + dd + eee;
529 md->state[2] = md->state[3] + ee + aaa;
530 md->state[3] = md->state[4] + aa + bbb;
531 md->state[4] = md->state[0] + bb + ccc;
532 md->state[0] = ddd;
533
534 return 0;
535}
536
537/**
538 Initialize the hash state
539 @param md The hash state you wish to initialize
540 @return 0 if successful
541 */
542int rmd160_vinit(struct rmd160_vstate * md)
543{
544 md->state[0] = 0x67452301UL;
545 md->state[1] = 0xefcdab89UL;
546 md->state[2] = 0x98badcfeUL;
547 md->state[3] = 0x10325476UL;
548 md->state[4] = 0xc3d2e1f0UL;
549 md->curlen = 0;
550 md->length = 0;
551 return 0;
552}
553#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \
554int func_name (struct rmd160_vstate * md, const unsigned char *in, unsigned long inlen) \
555{ \
556unsigned long n; \
557int err; \
558if (md->curlen > sizeof(md->buf)) { \
559return -1; \
560} \
561while (inlen > 0) { \
562if (md->curlen == 0 && inlen >= block_size) { \
563if ((err = compress_name (md, (unsigned char *)in)) != 0) { \
564return err; \
565} \
566md->length += block_size * 8; \
567in += block_size; \
568inlen -= block_size; \
569} else { \
570n = MIN(inlen, (block_size - md->curlen)); \
571memcpy(md->buf + md->curlen, in, (size_t)n); \
572md->curlen += n; \
573in += n; \
574inlen -= n; \
575if (md->curlen == block_size) { \
576if ((err = compress_name (md, md->buf)) != 0) { \
577return err; \
578} \
579md->length += 8*block_size; \
580md->curlen = 0; \
581} \
582} \
583} \
584return 0; \
585}
586
587/**
588 Process a block of memory though the hash
589 @param md The hash state
590 @param in The data to hash
591 @param inlen The length of the data (octets)
592 @return 0 if successful
593 */
594HASH_PROCESS(rmd160_vprocess, rmd160_vcompress, rmd160, 64)
595
596/**
597 Terminate the hash to get the digest
598 @param md The hash state
599 @param out [out] The destination of the hash (20 bytes)
600 @return 0 if successful
601 */
602int rmd160_vdone(struct rmd160_vstate * md, unsigned char *out)
603{
604 int i;
605 if (md->curlen >= sizeof(md->buf)) {
606 return -1;
607 }
608 /* increase the length of the message */
609 md->length += md->curlen * 8;
610
611 /* append the '1' bit */
612 md->buf[md->curlen++] = (unsigned char)0x80;
613
614 /* if the length is currently above 56 bytes we append zeros
615 * then compress. Then we can fall back to padding zeros and length
616 * encoding like normal.
617 */
618 if (md->curlen > 56) {
619 while (md->curlen < 64) {
620 md->buf[md->curlen++] = (unsigned char)0;
621 }
622 rmd160_vcompress(md, md->buf);
623 md->curlen = 0;
624 }
625 /* pad upto 56 bytes of zeroes */
626 while (md->curlen < 56) {
627 md->buf[md->curlen++] = (unsigned char)0;
628 }
629 /* store length */
630 STORE64L(md->length, md->buf+56);
631 rmd160_vcompress(md, md->buf);
632 /* copy output */
633 for (i = 0; i < 5; i++) {
634 STORE32L(md->state[i], out+(4*i));
635 }
636 return 0;
637}
638
639void calc_rmd160(char deprecated[41],uint8_t buf[20],uint8_t *msg,int32_t len)
640{
641 struct rmd160_vstate md;
642 rmd160_vinit(&md);
643 rmd160_vprocess(&md,msg,len);
644 rmd160_vdone(&md, buf);
645}
3eea72f2 646
1e81ccb7 647static const uint32_t crc32_tab[] = {
648 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
649 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
650 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
651 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
652 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
653 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
654 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
655 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
656 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
657 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
658 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
659 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
660 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
661 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
662 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
663 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
664 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
665 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
666 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
667 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
668 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
669 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
670 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
671 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
672 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
673 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
674 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
675 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
676 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
677 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
678 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
679 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
680 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
681 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
682 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
683 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
684 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
685 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
686 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
687 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
688 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
689 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
690 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
691};
692
693uint32_t calc_crc32(uint32_t crc,const void *buf,size_t size)
694{
695 const uint8_t *p;
696
697 p = (const uint8_t *)buf;
698 crc = crc ^ ~0U;
699
700 while (size--)
701 crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
702
703 return crc ^ ~0U;
704}
705
d019c447 706void calc_rmd160_sha256(uint8_t rmd160[20],uint8_t *data,int32_t datalen)
707{
708 bits256 hash;
709 vcalc_sha256(0,hash.bytes,data,datalen);
710 calc_rmd160(0,rmd160,hash.bytes,sizeof(hash));
711}
712
713int32_t bitcoin_addr2rmd160(uint8_t *addrtypep,uint8_t rmd160[20],char *coinaddr)
714{
715 bits256 hash; uint8_t *buf,_buf[25]; int32_t len;
716 memset(rmd160,0,20);
717 *addrtypep = 0;
718 buf = _buf;
719 if ( (len= bitcoin_base58decode(buf,coinaddr)) >= 4 )
720 {
721 // validate with trailing hash, then remove hash
722 hash = bits256_doublesha256(0,buf,21);
723 *addrtypep = *buf;
724 memcpy(rmd160,buf+1,20);
725 if ( (buf[21]&0xff) == hash.bytes[31] && (buf[22]&0xff) == hash.bytes[30] &&(buf[23]&0xff) == hash.bytes[29] && (buf[24]&0xff) == hash.bytes[28] )
726 {
727 //printf("coinaddr.(%s) valid checksum addrtype.%02x\n",coinaddr,*addrtypep);
728 return(20);
729 }
730 else
731 {
732 int32_t i;
733 if ( len > 20 )
734 {
735 hash = bits256_doublesha256(0,buf,len);
736 }
737 for (i=0; i<len; i++)
738 printf("%02x ",buf[i]);
7637aa7f 739 printf("\nhex checkhash.(%s) len.%d mismatch %02x %02x %02x %02x vs %02x %02x %02x %02x\n",coinaddr,len,buf[len-1]&0xff,buf[len-2]&0xff,buf[len-3]&0xff,buf[len-4]&0xff,hash.bytes[31],hash.bytes[30],hash.bytes[29],hash.bytes[28]);
d019c447 740 }
741 }
742 return(0);
743}
744
745char *bitcoin_address(char *coinaddr,uint8_t addrtype,uint8_t *pubkey_or_rmd160,int32_t len)
746{
747 int32_t i; uint8_t data[25]; bits256 hash;// char checkaddr[65];
748 if ( len != 20 )
749 calc_rmd160_sha256(data+1,pubkey_or_rmd160,len);
750 else memcpy(data+1,pubkey_or_rmd160,20);
751 //btc_convrmd160(checkaddr,addrtype,data+1);
752 data[0] = addrtype;
753 hash = bits256_doublesha256(0,data,21);
754 for (i=0; i<4; i++)
755 data[21+i] = hash.bytes[31-i];
756 if ( (coinaddr= bitcoin_base58encode(coinaddr,data,25)) != 0 )
757 {
758 //uint8_t checktype,rmd160[20];
759 //bitcoin_addr2rmd160(&checktype,rmd160,coinaddr);
760 //if ( strcmp(checkaddr,coinaddr) != 0 )
761 // printf("checkaddr.(%s) vs coinaddr.(%s) %02x vs [%02x] memcmp.%d\n",checkaddr,coinaddr,addrtype,checktype,memcmp(rmd160,data+1,20));
762 }
763 return(coinaddr);
764}
765
1e81ccb7 766int32_t _unhex(char c)
767{
768 if ( c >= '0' && c <= '9' )
769 return(c - '0');
770 else if ( c >= 'a' && c <= 'f' )
771 return(c - 'a' + 10);
772 else if ( c >= 'A' && c <= 'F' )
773 return(c - 'A' + 10);
774 return(-1);
775}
776
777int32_t is_hexstr(char *str,int32_t n)
778{
779 int32_t i;
780 if ( str == 0 || str[0] == 0 )
781 return(0);
782 for (i=0; str[i]!=0; i++)
783 {
784 if ( n > 0 && i >= n )
785 break;
786 if ( _unhex(str[i]) < 0 )
787 break;
788 }
789 if ( n == 0 )
790 return(i);
791 return(i == n);
792}
793
794int32_t unhex(char c)
795{
796 int32_t hex;
797 if ( (hex= _unhex(c)) < 0 )
798 {
799 //printf("unhex: illegal hexchar.(%c)\n",c);
800 }
801 return(hex);
802}
803
804unsigned char _decode_hex(char *hex) { return((unhex(hex[0])<<4) | unhex(hex[1])); }
805
806int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex)
807{
808 int32_t adjust,i = 0;
809 //printf("decode.(%s)\n",hex);
810 if ( is_hexstr(hex,n) == 0 )
811 {
812 memset(bytes,0,n);
813 return(n);
814 }
815 if ( n == 0 || (hex[n*2+1] == 0 && hex[n*2] != 0) )
816 {
817 if ( n > 0 )
818 {
819 bytes[0] = unhex(hex[0]);
820 printf("decode_hex n.%d hex[0] (%c) -> %d hex.(%s) [n*2+1: %d] [n*2: %d %c] len.%ld\n",n,hex[0],bytes[0],hex,hex[n*2+1],hex[n*2],hex[n*2],(long)strlen(hex));
821 }
822 bytes++;
823 hex++;
824 adjust = 1;
825 } else adjust = 0;
826 if ( n > 0 )
827 {
828 for (i=0; i<n; i++)
829 bytes[i] = _decode_hex(&hex[i*2]);
830 }
831 //bytes[i] = 0;
832 return(n + adjust);
833}
834
835int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp)
836{
837 int32_t i; uint64_t x;
838 if ( rwflag == 0 )
839 {
840 x = 0;
841 for (i=len-1; i>=0; i--)
842 {
843 x <<= 8;
844 x |= serialized[i];
845 }
846 switch ( len )
847 {
848 case 1: *(uint8_t *)endianedp = (uint8_t)x; break;
849 case 2: *(uint16_t *)endianedp = (uint16_t)x; break;
850 case 4: *(uint32_t *)endianedp = (uint32_t)x; break;
851 case 8: *(uint64_t *)endianedp = (uint64_t)x; break;
852 }
853 }
854 else
855 {
856 x = 0;
857 switch ( len )
858 {
859 case 1: x = *(uint8_t *)endianedp; break;
860 case 2: x = *(uint16_t *)endianedp; break;
861 case 4: x = *(uint32_t *)endianedp; break;
862 case 8: x = *(uint64_t *)endianedp; break;
863 }
864 for (i=0; i<len; i++,x >>= 8)
865 serialized[i] = (uint8_t)(x & 0xff);
866 }
867 return(len);
868}
869
870int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp)
871{
872 int32_t i;
873 if ( rwflag == 0 )
874 {
875 for (i=0; i<len; i++)
876 endianedp[i] = serialized[i];
877 }
878 else
879 {
880 for (i=0; i<len; i++)
881 serialized[i] = endianedp[i];
882 }
883 return(len);
884}
885
886int32_t komodo_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t opretlen)
887{
888 int32_t offset = 0;
889 script[offset++] = 0x6a;
890 opretlen++;
891 if ( opretlen >= 0x4c )
892 {
893 if ( opretlen > 0xff )
894 {
895 script[offset++] = 0x4d;
896 script[offset++] = opretlen & 0xff;
897 script[offset++] = (opretlen >> 8) & 0xff;
898 }
899 else
900 {
901 script[offset++] = 0x4c;
902 script[offset++] = opretlen;
903 }
904 } else script[offset++] = opretlen;
4aa2c64e 905 script[offset] = type; // covered by opretlen
1e81ccb7 906 memcpy(&script[offset],opret,opretlen);
907 return(opretlen + offset);
908}
438d3f35 909
fd1799a6 910long _stripwhite(char *buf,int accept)
911{
912 int32_t i,j,c;
913 if ( buf == 0 || buf[0] == 0 )
914 return(0);
915 for (i=j=0; buf[i]!=0; i++)
916 {
917 buf[j] = c = buf[i];
918 if ( c == accept || (c != ' ' && c != '\n' && c != '\r' && c != '\t' && c != '\b') )
919 j++;
920 }
921 buf[j] = 0;
922 return(j);
923}
924
2c36c760 925char *clonestr(char *str)
926{
927 char *clone;
928 if ( str == 0 || str[0] == 0 )
929 {
930 printf("warning cloning nullstr.%p\n",str);
931#ifdef __APPLE__
932 while ( 1 ) sleep(1);
933#endif
934 str = (char *)"<nullstr>";
935 }
936 clone = (char *)malloc(strlen(str)+16);
937 strcpy(clone,str);
938 return(clone);
939}
940
fd1799a6 941char *parse_conf_line(char *line,char *field)
942{
943 line += strlen(field);
944 for (; *line!='='&&*line!=0; line++)
945 break;
946 if ( *line == 0 )
947 return(0);
948 if ( *line == '=' )
949 line++;
950 _stripwhite(line,0);
951 return(clonestr(line));
952}
953
438d3f35 954void komodo_configfile(char *symbol,uint16_t port)
955{
d84012ad 956 extern uint16_t BITCOIND_PORT;
957 FILE *fp; char fname[512],buf[128],line[4096],*str,*rpcuser,*rpcpassword,*rpcport,*retstr;
1e2b1c77 958 srand((uint32_t)time(NULL));
438d3f35 959 sprintf(buf,"%s.conf",symbol);
fd1799a6 960 BITCOIND_PORT = port;
438d3f35 961#ifdef WIN32
962 sprintf(fname,"%s\\%s",GetDataDir(false).string().c_str(),buf);
963#else
964 sprintf(fname,"%s/%s",GetDataDir(false).string().c_str(),buf);
965#endif
966 if ( (fp= fopen(fname,"rb")) == 0 )
967 {
968 if ( (fp= fopen(fname,"wb")) != 0 )
969 {
970 fprintf(fp,"rpcuser=user%u\nrpcpassword=pass%u\nrpcport=%u\nserver=1\n",rand(),rand(),port);
971 fclose(fp);
972 printf("Created (%s)\n",fname);
973 }
974 }
fd1799a6 975 else
976 {
977 rpcuser = rpcpassword = rpcport = 0;
978 while ( fgets(line,sizeof(line),fp) != 0 )
979 {
980 if ( line[0] == '#' )
981 continue;
a7798b0d 982 printf("line.(%s) %p %p\n",line,strstr(line,"rpcuser"),strstr(line,"rpcpassword"));
46beb55e 983 if ( (str= strstr(line,(char *)"rpcuser")) != 0 )
984 rpcuser = parse_conf_line(str,(char *)"rpcuser");
985 else if ( (str= strstr(line,(char *)"rpcpassword")) != 0 )
986 rpcpassword = parse_conf_line(str,(char *)"rpcpassword");
987 else if ( (str= strstr(line,(char *)"rpcport")) != 0 )
988 rpcport = parse_conf_line(str,(char *)"rpcport");
fd1799a6 989 }
990 if ( rpcuser != 0 && rpcpassword != 0 )
991 {
992 sprintf(USERPASS,"%s:%s",rpcuser,rpcpassword);
993 }
994 if ( rpcport != 0 )
995 {
996 if ( port != atoi(rpcport) )
997 printf("port.%u mismatch (%s)\n",port,rpcport);
998 //if ( serverport[0] == 0 )
999 // sprintf(serverport,"127.0.0.1:%s",rpcport);
1000 free(rpcport);
1001 }
1002 if ( rpcuser != 0 )
1003 free(rpcuser);
1004 if ( rpcpassword != 0 )
1005 free(rpcpassword);
1006 fclose(fp);
1007 }
978a3924 1008 if ( (retstr= komodo_issuemethod((char *)"getinfo",0)) != 0 )
fd1799a6 1009 {
a7798b0d 1010 printf("GETINFO.%s (%s) USERPASS.%s\n",symbol,retstr,USERPASS);
fd1799a6 1011 free(retstr);
1012 }
438d3f35 1013}
Empty description
This page took 0.135337 seconds and 4 git commands to generate.