/**
* proto_kvlds_response_params(Q, ID, kmax, vmax):
* Send a PARAMS response with ID ${ID} specifying that the maximum key
* length is ${kmax} bytes and the maximum value length is ${vmax} bytes
* to the write queue ${Q}.
*/
int
proto_kvlds_response_params(struct netbuf_write * Q, uint64_t ID,
uint32_t kmax, uint32_t vmax)
{
uint8_t * wbuf;
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, 8)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], kmax);
be32enc(&wbuf[4], vmax);
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, 8))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
/**
* proto_dynamodb_kv_response_data(Q, ID, status, len, buf):
* Send a response with ID ${ID} to the write queue ${Q} indicating that
* the DynamoDB request completed successfully (${status} = 0) with the
* provided data, failed (${status} = 1), or returned no data (${status} = 2).
*/
int
proto_dynamodb_kv_response_data(struct netbuf_write * Q, uint64_t ID,
int status, uint32_t len, const uint8_t * buf)
{
uint8_t * wbuf;
size_t rlen;
/* Compute the response length. */
rlen = 4 + ((status == 0) ? len + 4 : 0);
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, rlen)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], status);
if (status == 0) {
be32enc(&wbuf[4], len);
memcpy(&wbuf[8], buf, len);
}
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, rlen))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
int scanhash_luffa(int thr_id, struct work *work,
uint32_t max_nonce, uint64_t *hashes_done)
{
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t _ALIGN(64) hash64[8];
uint32_t _ALIGN(64) endiandata[20];
const uint32_t Htarg = ptarget[7];
const uint32_t first_nonce = pdata[19];
uint32_t n = first_nonce;
for (int i=0; i < 19; i++)
be32enc(&endiandata[i], pdata[i]);
do {
be32enc(&endiandata[19], n);
luffahash(hash64, endiandata);
if (hash64[7] < Htarg && fulltest(hash64, ptarget)) {
*hashes_done = n - first_nonce + 1;
pdata[19] = n;
return true;
}
n++;
} while (n < max_nonce && !work_restart[thr_id].restart);
*hashes_done = n - first_nonce + 1;
pdata[19] = n;
return 0;
}
void write_kdfp(uint8_t *addr, kdfp *kdfp) {
uint64_t *N = (uint64_t *) (addr + SALT_LEN);
uint32_t *r = (uint32_t *) (N + 1);
uint32_t *p = (uint32_t *) (r + 1);
memcpy(addr, kdfp->salt, SALT_LEN);
be64enc(N, kdfp->N);
be32enc(r, kdfp->r);
be32enc(p, kdfp->p);
}
int scanhash_x12_4way( int thr_id, struct work *work, uint32_t max_nonce,
uint64_t *hashes_done )
{
uint32_t hash[4*8] __attribute__ ((aligned (64)));
uint32_t vdata[24*4] __attribute__ ((aligned (64)));
uint32_t endiandata[20] __attribute__((aligned(64)));
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t n = pdata[19];
const uint32_t first_nonce = pdata[19];
uint32_t *nonces = work->nonces;
int num_found = 0;
uint32_t *noncep = vdata + 73; // 9*8 + 1
const uint32_t Htarg = ptarget[7];
uint64_t htmax[] = { 0, 0xF, 0xFF,
0xFFF, 0xFFFF, 0x10000000 };
uint32_t masks[] = { 0xFFFFFFFF, 0xFFFFFFF0, 0xFFFFFF00,
0xFFFFF000, 0xFFFF0000, 0 };
// big endian encode 0..18 uint32_t, 64 bits at a time
swab32_array( endiandata, pdata, 20 );
uint64_t *edata = (uint64_t*)endiandata;
mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
for ( int m=0; m < 6; m++ )
if ( Htarg <= htmax[m] )
{
uint32_t mask = masks[m];
do
{
be32enc( noncep, n );
be32enc( noncep+2, n+1 );
be32enc( noncep+4, n+2 );
be32enc( noncep+6, n+3 );
x12_4way_hash( hash, vdata );
pdata[19] = n;
for ( int i = 0; i < 4; i++ )
if ( ( ( (hash+(i<<3))[7] & mask ) == 0 )
&& fulltest( hash+(i<<3), ptarget ) )
{
pdata[19] = n+i;
nonces[ num_found++ ] = n+i;
work_set_target_ratio( work, hash+(i<<3) );
}
n += 4;
} while ( ( num_found == 0 ) && ( n < max_nonce )
&& !work_restart[thr_id].restart );
break;
}
*hashes_done = n - first_nonce + 1;
return num_found;
}
int
fifolog_write_record(struct fifolog_writer *f, uint32_t id, time_t now,
const void *ptr, ssize_t len)
{
const unsigned char *p;
uint8_t buf[9];
ssize_t bufl;
fifolog_write_assert(f);
assert(!(id & (FIFOLOG_TIMESTAMP|FIFOLOG_LENGTH)));
assert(ptr != NULL);
p = ptr;
if (len == 0) {
len = strlen(ptr);
len++;
} else {
assert(len <= 255);
id |= FIFOLOG_LENGTH;
}
assert (len > 0);
/* Do a timestamp, if needed */
if (now == 0)
time(&now);
if (now != f->last)
id |= FIFOLOG_TIMESTAMP;
/* Emit instance+flag */
be32enc(buf, id);
bufl = 4;
if (id & FIFOLOG_TIMESTAMP) {
be32enc(buf + bufl, (uint32_t)now);
bufl += 4;
}
if (id & FIFOLOG_LENGTH)
buf[bufl++] = (u_char)len;
if (bufl + len + f->ibufptr > f->ibufsize)
return (0);
memcpy(f->ibuf + f->ibufptr, buf, bufl);
f->ibufptr += bufl;
memcpy(f->ibuf + f->ibufptr, p, len);
f->ibufptr += len;
f->cnt[FIFOLOG_PT_BYTES_PRE] += bufl + len;
if (id & FIFOLOG_TIMESTAMP)
f->last = now;
return (1);
}
int scanhash_blakecoin(int thr_id, struct work *work, uint32_t max_nonce,
uint64_t *hashes_done)
{
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19];
uint32_t HTarget = ptarget[7];
uint32_t _ALIGN(32) hash64[8];
uint32_t _ALIGN(32) endiandata[20];
uint32_t n = first_nonce;
ctx_midstate_done = false;
if (opt_benchmark)
HTarget = 0x7f;
// we need big endian data...
for (int kk=0; kk < 19; kk++) {
be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]);
};
#ifdef DEBUG_ALGO
applog(LOG_DEBUG,"[%d] Target=%08x %08x", thr_id, ptarget[6], ptarget[7]);
#endif
do {
be32enc(&endiandata[19], n);
blakecoinhash(hash64, endiandata);
#ifndef DEBUG_ALGO
if (hash64[7] <= HTarget && fulltest(hash64, ptarget)) {
*hashes_done = n - first_nonce + 1;
return true;
}
#else
if (!(n % 0x1000) && !thr_id) printf(".");
if (hash64[7] == 0) {
printf("[%d]",thr_id);
if (fulltest(hash64, ptarget)) {
*hashes_done = n - first_nonce + 1;
return true;
}
}
#endif
n++; pdata[19] = n;
} while (n < max_nonce && !work_restart[thr_id].restart);
*hashes_done = n - first_nonce + 1;
pdata[19] = n;
return 0;
}
static int
scryptenc_setup(uint8_t header[96], uint8_t dk[64],
const uint8_t * passwd, size_t passwdlen,
size_t maxmem, double maxmemfrac, double maxtime)
{
uint8_t salt[32];
uint8_t hbuf[32];
int logN;
uint64_t N;
uint32_t r;
uint32_t p;
SHA256_CTX ctx;
uint8_t * key_hmac = &dk[32];
HMAC_SHA256_CTX hctx;
int rc;
/* Pick values for N, r, p. */
if ((rc = pickparams(maxmem, maxmemfrac, maxtime,
&logN, &r, &p)) != 0)
return (rc);
N = (uint64_t)(1) << logN;
/* Get some salt. */
if (crypto_entropy_read(salt, 32))
return (4);
/* Generate the derived keys. */
if (crypto_scrypt(passwd, passwdlen, salt, 32, N, r, p, dk, 64))
return (3);
/* Construct the file header. */
memcpy(header, "scrypt", 6);
header[6] = 0;
header[7] = logN;
be32enc(&header[8], r);
be32enc(&header[12], p);
memcpy(&header[16], salt, 32);
/* Add header checksum. */
SHA256_Init(&ctx);
SHA256_Update(&ctx, header, 48);
SHA256_Final(hbuf, &ctx);
memcpy(&header[48], hbuf, 16);
/* Add header signature (used for verifying password). */
HMAC_SHA256_Init(&hctx, key_hmac, 32);
HMAC_SHA256_Update(&hctx, header, 64);
HMAC_SHA256_Final(hbuf, &hctx);
memcpy(&header[64], hbuf, 32);
/* Success! */
return (0);
}
static int test_be32enc() {
uint8_t buf[4];
be32enc(buf, 0x01020304U);
if(buf[0] != 1 || buf[1] != 2 || buf[2] != 3 || buf[3] != 4)
return -1;
be32enc(buf, 0xffefdfcfU);
if(buf[0] != 0xff || buf[1] != 0xef || buf[2] != 0xdf || buf[3] != 0xcf)
return -1;
return 0;
}
/**
* proto_kvlds_response_range(Q, ID, nkeys, next, keys, values):
* Send a RANGE response with ID ${ID}, next key ${next} and ${nkeys}
* key-value pairs with the keys in ${keys} and values in ${values} to the
* write queue ${Q}.
*/
int
proto_kvlds_response_range(struct netbuf_write * Q, uint64_t ID,
size_t nkeys, const struct kvldskey * next,
struct kvldskey ** keys, struct kvldskey ** values)
{
uint8_t * wbuf;
size_t len;
size_t i;
size_t bufpos;
/* Sanity check: We can't return more than 2^32-1 keys. */
assert(nkeys <= UINT32_MAX);
/* Figure out how long the packet will be. */
len = 8;
len += kvldskey_serial_size(next);
for (i = 0; i < nkeys; i++) {
len += kvldskey_serial_size(keys[i]);
len += kvldskey_serial_size(values[i]);
}
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, len)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], 0);
be32enc(&wbuf[4], nkeys);
bufpos = 8;
kvldskey_serialize(next, &wbuf[bufpos]);
bufpos += kvldskey_serial_size(next);
for (i = 0; i < nkeys; i++) {
kvldskey_serialize(keys[i], &wbuf[bufpos]);
bufpos += kvldskey_serial_size(keys[i]);
kvldskey_serialize(values[i], &wbuf[bufpos]);
bufpos += kvldskey_serial_size(values[i]);
}
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, len))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
/*
* Encode the relevant fields into a sun disklabel, compute new checksum.
*/
void
sunlabel_enc(void *pp, struct sun_disklabel *sl)
{
uint8_t *p;
size_t i;
u_int u;
p = pp;
for (i = 0; i < SL_TEXT_SIZEOF; i++)
p[SL_TEXT + i] = sl->sl_text[i];
be16enc(p + SL_RPM, sl->sl_rpm);
be16enc(p + SL_PCYLINDERS, sl->sl_pcylinders);
be16enc(p + SL_SPARESPERCYL, sl->sl_sparespercyl);
be16enc(p + SL_INTERLEAVE, sl->sl_interleave);
be16enc(p + SL_NCYLINDERS, sl->sl_ncylinders);
be16enc(p + SL_ACYLINDERS, sl->sl_acylinders);
be16enc(p + SL_NTRACKS, sl->sl_ntracks);
be16enc(p + SL_NSECTORS, sl->sl_nsectors);
for (i = 0; i < SUN_NPART; i++) {
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_CYLOFFSET,
sl->sl_part[i].sdkp_cyloffset);
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_NSECTORS,
sl->sl_part[i].sdkp_nsectors);
}
be16enc(p + SL_MAGIC, sl->sl_magic);
if (sl->sl_vtoc_sane == SUN_VTOC_SANE
&& sl->sl_vtoc_nparts == SUN_NPART) {
/*
* Write SVR4-compatible VTOC elements.
*/
be32enc(p + SL_VTOC_VERS, sl->sl_vtoc_vers);
be32enc(p + SL_VTOC_SANITY, SUN_VTOC_SANE);
memcpy(p + SL_VTOC_VOLNAME, sl->sl_vtoc_volname,
SUN_VOLNAME_LEN);
be16enc(p + SL_VTOC_NPART, SUN_NPART);
for (i = 0; i < SUN_NPART; i++) {
be16enc(p + SL_VTOC_MAP + (i * SVTOC_SIZEOF)
+ SVTOC_TAG,
sl->sl_vtoc_map[i].svtoc_tag);
be16enc(p + SL_VTOC_MAP + (i * SVTOC_SIZEOF)
+ SVTOC_FLAG,
sl->sl_vtoc_map[i].svtoc_flag);
}
}
for (i = u = 0; i < SUN_SIZE; i += 2)
u ^= be16dec(p + i);
be16enc(p + SL_CKSUM, u);
}
static void
prf_iterate(u_int8_t *r, const u_int8_t *P, size_t Plen,
const u_int8_t *S, size_t Slen, size_t c, size_t ind)
{
int first_time = 1;
size_t i;
size_t datalen;
ssize_t tmplen;
u_int8_t *data;
u_int8_t tmp[128];
data = emalloc(Slen + 4);
(void)memcpy(data, S, Slen);
be32enc(data + Slen, ind);
datalen = Slen + 4;
for (i=0; i < c; i++) {
tmplen = hmac("sha1", P, Plen, data, datalen, tmp, sizeof(tmp));
assert(tmplen == PRF_BLOCKLEN);
if (first_time) {
(void)memcpy(r, tmp, PRF_BLOCKLEN);
first_time = 0;
} else
memxor(r, tmp, PRF_BLOCKLEN);
(void)memcpy(data, tmp, PRF_BLOCKLEN);
datalen = PRF_BLOCKLEN;
}
free(data);
}
/**
* proto_kvlds_response_get(Q, ID, status, value):
* Send a GET response with ID ${ID}, status ${status}, and value ${value}
* (if ${status} == 0) to the write queue ${Q} indicating that the provided
* key is associated with the specified data (or not).
*/
int
proto_kvlds_response_get(struct netbuf_write * Q, uint64_t ID,
uint32_t status, const struct kvldskey * value)
{
uint8_t * wbuf;
size_t len;
/* Compute the response length. */
len = 4;
if (status == 0)
len += kvldskey_serial_size(value);
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, len)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], status);
if (status == 0)
kvldskey_serialize(value, &wbuf[4]);
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, len))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
/**
* proto_lbs_response_append(Q, ID, status, blkno):
* Send an APPEND response with ID ${ID} to the write queue ${Q} with status
* code ${status} and next block number ${blkno} if ${status} is zero.
*/
int
proto_lbs_response_append(struct netbuf_write * Q, uint64_t ID,
uint32_t status, uint64_t blkno)
{
uint8_t * wbuf;
size_t len;
/* Compute the response length. */
len = (status == 0) ? 12 : 4;
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, len)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], status);
if (status == 0)
be64enc(&wbuf[4], blkno);
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, len))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
/**
* proto_lbs_response_params2(Q, ID, blklen, blkno, lastblk):
* Send a PARAMS2 response with ID ${ID} to the write queue ${Q} indicating
* that the block size is ${blklen} bytes, the next available block # is
* ${blkno}, and the last block written was ${lastblk}.
*/
int
proto_lbs_response_params2(struct netbuf_write * Q, uint64_t ID,
uint32_t blklen, uint64_t blkno, uint64_t lastblk)
{
uint8_t * wbuf;
/* Get a packet data buffer. */
if ((wbuf = wire_writepacket_getbuf(Q, ID, 20)) == NULL)
goto err0;
/* Write the packet data. */
be32enc(&wbuf[0], blklen);
be64enc(&wbuf[4], blkno);
be64enc(&wbuf[12], lastblk);
/* Finish the packet. */
if (wire_writepacket_done(Q, wbuf, 20))
goto err0;
/* Success! */
return (0);
err0:
/* Failure! */
return (-1);
}
/**
* proto_crypt_enc(ibuf, len, obuf, k):
* Encrypt ${len} bytes from ${ibuf} into PCRYPT_ESZ bytes using the keys in
* ${k}, and write the result into ${obuf}.
*/
void
proto_crypt_enc(uint8_t * ibuf, size_t len, uint8_t obuf[PCRYPT_ESZ],
struct proto_keys * k)
{
HMAC_SHA256_CTX ctx;
uint8_t pnum_exp[8];
/* Sanity-check the length. */
assert(len <= PCRYPT_MAXDSZ);
/* Copy the decrypted data into the encrypted buffer. */
memcpy(obuf, ibuf, len);
/* Pad up to PCRYPT_MAXDSZ with zeroes. */
memset(&obuf[len], 0, PCRYPT_MAXDSZ - len);
/* Add the length. */
be32enc(&obuf[PCRYPT_MAXDSZ], len);
/* Encrypt the buffer in-place. */
crypto_aesctr_buf(k->k_aes, k->pnum, obuf, obuf, PCRYPT_MAXDSZ + 4);
/* Append an HMAC. */
be64enc(pnum_exp, k->pnum);
HMAC_SHA256_Init(&ctx, k->k_hmac, 32);
HMAC_SHA256_Update(&ctx, obuf, PCRYPT_MAXDSZ + 4);
HMAC_SHA256_Update(&ctx, pnum_exp, 8);
HMAC_SHA256_Final(&obuf[PCRYPT_MAXDSZ + 4], &ctx);
/* Increment packet number. */
k->pnum += 1;
}
/**
* crypto_MGF1(seed, seedlen, buf, buflen):
* The MGF1 mask generation function, as specified in RFC 3447.
*/
void
crypto_MGF1(uint8_t * seed, size_t seedlen, uint8_t * buf, size_t buflen)
{
uint8_t hbuf[32];
size_t pos;
uint32_t i;
uint8_t C[4];
/* Sanity check for I2OSP function. */
assert(((buflen - 1) / 32) <= UINT32_MAX);
/* Iterate through the buffer. */
for (pos = 0; pos < buflen; pos += 32) {
/* The ith block starts at position i * 32. */
i = (uint32_t)(pos / 32);
/* Convert counter to big-endian format. */
be32enc(C, i);
/* Compute the hash of (seed || C). */
if (crypto_hash_data_2(CRYPTO_KEY_HMAC_SHA256, seed, seedlen,
C, 4, hbuf)) {
warn0("Programmer error: "
"SHA256 should never fail");
abort();
}
/* Copy as much data as needed. */
if (buflen - pos > 32)
memcpy(buf + pos, hbuf, 32);
else
memcpy(buf + pos, hbuf, buflen - pos);
}
}
static void
prf_iterate(u_int8_t *r, const u_int8_t *P, size_t Plen,
const u_int8_t *S, size_t Slen, size_t c, size_t ind)
{
int first_time = 1;
size_t i;
size_t datalen;
unsigned int tmplen;
u_int8_t *data;
u_int8_t tmp[EVP_MAX_MD_SIZE];
data = emalloc(Slen + 4);
(void)memcpy(data, S, Slen);
be32enc(data + Slen, ind);
datalen = Slen + 4;
for (i=0; i < c; i++) {
(void)HMAC(EVP_sha1(), P, Plen, data, datalen, tmp, &tmplen);
assert(tmplen == PRF_BLOCKLEN);
if (first_time) {
(void)memcpy(r, tmp, PRF_BLOCKLEN);
first_time = 0;
} else
memxor(r, tmp, PRF_BLOCKLEN);
(void)memcpy(data, tmp, PRF_BLOCKLEN);
datalen = PRF_BLOCKLEN;
}
free(data);
}
int scanhash_lyra2re(int thr_id, struct work *work,
uint32_t max_nonce, uint64_t *hashes_done)
{
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t _ALIGN(64) endiandata[20];
uint32_t hash[8] __attribute__((aligned(32)));
const uint32_t first_nonce = pdata[19];
uint32_t nonce = first_nonce;
const uint32_t Htarg = ptarget[7];
swab32_array( endiandata, pdata, 20 );
do {
be32enc(&endiandata[19], nonce);
lyra2re_hash(hash, endiandata);
if (hash[7] <= Htarg )
{
if ( fulltest(hash, ptarget) )
{
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce;
return 1;
}
}
nonce++;
} while (nonce < max_nonce && !work_restart[thr_id].restart);
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce + 1;
return 0;
}
void sha256func(unsigned char *hash, const unsigned char *data, int len)
{
uint32_t S[16], T[16];
int i, r;
sha256_init(S);
for (r = len; r > -9; r -= 64) {
if (r < 64)
memset(T, 0, 64);
memcpy(T, data + len - r, r > 64 ? 64 : (r < 0 ? 0 : r));
if (r >= 0 && r < 64)
((unsigned char *)T)[r] = 0x80;
for (i = 0; i < 16; i++)
T[i] = be32dec(T + i);
if (r < 56)
T[15] = 8 * len;
sha256_transform(S, T, 0);
}
/*
memcpy(S + 8, sha256d_hash1 + 8, 32);
sha256_init(T);
sha256_transform(T, S, 0);
*/
for (i = 0; i < 8; i++)
be32enc((uint32_t *)hash + i, T[i]);
}
char* hodl_malloc_txs_request( struct work *work )
{
char* req;
json_t *val;
char data_str[2 * sizeof(work->data) + 1];
int i;
for ( i = 0; i < ARRAY_SIZE(work->data); i++ )
be32enc( work->data + i, work->data[i] );
bin2hex( data_str, (unsigned char *)work->data, 88 );
if ( work->workid )
{
char *params;
val = json_object();
json_object_set_new( val, "workid", json_string( work->workid ) );
params = json_dumps( val, 0 );
json_decref( val );
req = malloc( 128 + 2*88 + strlen( work->txs ) + strlen( params ) );
sprintf( req,
"{\"method\": \"submitblock\", \"params\": [\"%s%s\", %s], \"id\":1}\r\n",
data_str, work->txs, params);
free( params );
}
else
{
req = malloc( 128 + 2*88 + strlen(work->txs));
sprintf( req,
"{\"method\": \"submitblock\", \"params\": [\"%s%s\"], \"id\":1}\r\n",
data_str, work->txs);
}
return req;
}
static const char *tencode(int t, uint64_t val)
{
static char res[64];
uint8_t buf[16];
bool be = t > 0;
int i;
if (t < 0) t = -t;
memset(buf, 0xFC, sizeof(buf));
if (be) {
switch (t) {
case 2: be16enc(buf, val); break;
case 4: be32enc(buf, val); break;
case 8: be64enc(buf, val); break;
}
} else {
switch (t) {
case 2: le16enc(buf, val); break;
case 4: le32enc(buf, val); break;
case 8: le64enc(buf, val); break;
}
}
for (i = t; i < (int)sizeof(buf); i++) {
if (buf[i] != 0xFC)
return "OVER";
}
snprintf(res, sizeof(res), "%02X %02X %02X %02X %02X %02X %02X %02X ",
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
res[t*3 - 1] = 0;
return res;
}
int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
uint64_t *hashes_done )
{
uint32_t hash[4*8] __attribute__ ((aligned (64)));
uint32_t vdata[24*4] __attribute__ ((aligned (64)));
uint32_t endiandata[20] __attribute__((aligned(64)));
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t Htarg = ptarget[7];
const uint32_t first_nonce = pdata[19];
uint32_t n = first_nonce;
uint32_t *nonces = work->nonces;
int num_found = 0;
uint32_t *noncep = vdata + 73; // 9*8 + 1
volatile uint8_t *restart = &(work_restart[thr_id].restart);
if ( opt_benchmark )
ptarget[7] = 0x0cff;
for ( int i=0; i < 19; i++ )
{
be32enc( &endiandata[i], pdata[i] );
}
uint64_t *edata = (uint64_t*)endiandata;
mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
do
{
be32enc( noncep, n );
be32enc( noncep+2, n+1 );
be32enc( noncep+4, n+2 );
be32enc( noncep+6, n+3 );
veltor_4way_hash( hash, vdata );
pdata[19] = n;
for ( int i = 0; i < 4; i++ )
if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
{
pdata[19] = n+i;
nonces[ num_found++ ] = n+i;
work_set_target_ratio( work, hash+(i<<3) );
}
n += 4;
} while ( ( num_found == 0 ) && ( n < max_nonce ) && !(*restart) );
*hashes_done = n - first_nonce + 1;
return num_found;
}
extern "C" int scanhash_groestlcoin(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
uint32_t max_nonce, unsigned long *hashes_done)
{
uint32_t start_nonce = pdata[19]++;
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8
throughput = min(throughput, max_nonce - start_nonce);
uint32_t *outputHash = (uint32_t*)malloc(throughput * 16 * sizeof(uint32_t));
if (opt_benchmark)
((uint32_t*)ptarget)[7] = 0x000000ff;
// init
if(!init[thr_id])
{
groestlcoin_cpu_init(thr_id, throughput);
init[thr_id] = true;
}
// Endian Drehung ist notwendig
uint32_t endiandata[32];
for (int kk=0; kk < 32; kk++)
be32enc(&endiandata[kk], pdata[kk]);
// Context mit dem Endian gedrehten Blockheader vorbereiten (Nonce wird später ersetzt)
groestlcoin_cpu_setBlock(thr_id, endiandata, (void*)ptarget);
do {
// GPU
uint32_t foundNounce = 0xFFFFFFFF;
const uint32_t Htarg = ptarget[7];
groestlcoin_cpu_hash(thr_id, throughput, pdata[19], outputHash, &foundNounce);
if(foundNounce < 0xffffffff)
{
uint32_t tmpHash[8];
endiandata[19] = SWAP32(foundNounce);
groestlhash(tmpHash, endiandata);
if (tmpHash[7] <= Htarg && fulltest(tmpHash, ptarget)) {
pdata[19] = foundNounce;
*hashes_done = foundNounce - start_nonce + 1;
free(outputHash);
return true;
} else {
applog(LOG_INFO, "GPU #%d: result for nonce $%08X does not validate on CPU!", thr_id, foundNounce);
}
foundNounce = 0xffffffff;
}
pdata[19] += throughput;
} while (!work_restart[thr_id].restart && ((uint64_t)max_nonce > ((uint64_t)(pdata[19]) + (uint64_t)throughput)));
*hashes_done = pdata[19] - start_nonce + 1;
free(outputHash);
return 0;
}
void
isns_req_add_32(struct isns_req *req, uint32_t tag, uint32_t value)
{
uint32_t beval;
be32enc(&beval, value);
isns_req_add(req, tag, sizeof(value), &beval);
}
void
isns_req_add(struct isns_req *req, uint32_t tag, uint32_t len,
const void *value)
{
struct isns_tlv *tlv;
uint32_t vlen;
vlen = len + ((len & 3) ? (4 - (len & 3)) : 0);
isns_req_getspace(req, sizeof(*tlv) + vlen);
tlv = (struct isns_tlv *)&req->ir_buf[req->ir_usedlen];
be32enc(tlv->it_tag, tag);
be32enc(tlv->it_length, vlen);
memcpy(tlv->it_value, value, len);
if (vlen != len)
memset(&tlv->it_value[len], 0, vlen - len);
req->ir_usedlen += sizeof(*tlv) + vlen;
}
extern "C" int scanhash_fugue256(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
uint32_t max_nonce, unsigned long *hashes_done)
{
uint32_t start_nonce = pdata[19]++;
unsigned int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 19;
uint32_t throughput = device_intensity(device_map[thr_id], __func__, 1 << intensity); // 256*256*8
throughput = min(throughput, max_nonce - start_nonce);
if (opt_benchmark)
((uint32_t*)ptarget)[7] = 0xf;
// init
if(!init[thr_id])
{
fugue256_cpu_init(thr_id, throughput);
init[thr_id] = true;
}
// Endian Drehung ist notwendig
uint32_t endiandata[20];
for (int kk=0; kk < 20; kk++)
be32enc(&endiandata[kk], pdata[kk]);
// Context mit dem Endian gedrehten Blockheader vorbereiten (Nonce wird später ersetzt)
fugue256_cpu_setBlock(thr_id, endiandata, (void*)ptarget);
do {
// GPU
uint32_t foundNounce = 0xFFFFFFFF;
fugue256_cpu_hash(thr_id, throughput, pdata[19], NULL, &foundNounce);
if(foundNounce < 0xffffffff)
{
uint32_t hash[8];
const uint32_t Htarg = ptarget[7];
endiandata[19] = SWAP32(foundNounce);
sph_fugue256_context ctx_fugue;
sph_fugue256_init(&ctx_fugue);
sph_fugue256 (&ctx_fugue, endiandata, 80);
sph_fugue256_close(&ctx_fugue, &hash);
if (hash[7] <= Htarg && fulltest(hash, ptarget))
{
pdata[19] = foundNounce;
*hashes_done = foundNounce - start_nonce + 1;
return 1;
} else {
applog(LOG_INFO, "GPU #%d: result for nonce $%08X does not validate on CPU!", thr_id, foundNounce);
}
}
pdata[19] += throughput;
} while (!work_restart[thr_id].restart && ((uint64_t)max_nonce > ((uint64_t)(pdata[19]) + (uint64_t)throughput)));
*hashes_done = pdata[19] - start_nonce + 1;
return 0;
}
void decred_be_build_stratum_request( char *req, struct work *work,
struct stratum_ctx *sctx )
{
unsigned char *xnonce2str;
uint32_t ntime, nonce;
char ntimestr[9], noncestr[9];
be32enc( &ntime, work->data[ DECRED_NTIME_INDEX ] );
be32enc( &nonce, work->data[ DECRED_NONCE_INDEX ] );
bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
xnonce2str = abin2hex( (char*)( &work->data[ DECRED_XNONCE_INDEX ] ),
sctx->xnonce1_size );
snprintf( req, JSON_BUF_LEN,
"{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
free(xnonce2str);
}
int scanhash_lyra2z(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
{
size_t size = (int64_t) ((int64_t) 16 * 16 * 96);
uint64_t *wholeMatrix = _mm_malloc(size, 64);
uint32_t _ALIGN(128) hash[8];
uint32_t _ALIGN(128) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t Htarg = ptarget[7];
const uint32_t first_nonce = pdata[19];
uint32_t nonce = first_nonce;
if (opt_benchmark)
ptarget[7] = 0x0000ff;
for (int i=0; i < 19; i++) {
be32enc(&endiandata[i], pdata[i]);
}
do {
be32enc(&endiandata[19], nonce);
lyra2z_hash(wholeMatrix, hash, endiandata);
// lyra2z_hash(0, hash, endiandata);
if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
work_set_target_ratio(work, hash);
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce;
_mm_free(wholeMatrix);
return 1;
}
nonce++;
} while (nonce < max_nonce && !work_restart[thr_id].restart);
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce + 1;
_mm_free(wholeMatrix);
return 0;
}
int scanhash_x16r(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
{
uint32_t _ALIGN(128) hash32[8];
uint32_t _ALIGN(128) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t Htarg = ptarget[7];
const uint32_t first_nonce = pdata[19];
uint32_t nonce = first_nonce;
volatile uint8_t *restart = &(work_restart[thr_id].restart);
for (int k=0; k < 19; k++)
be32enc(&endiandata[k], pdata[k]);
if (s_ntime != pdata[17]) {
uint32_t ntime = swab32(pdata[17]);
getAlgoString((const char*) (&endiandata[1]), hashOrder);
s_ntime = ntime;
if (opt_debug && !thr_id) applog(LOG_DEBUG, "hash order %s (%08x)", hashOrder, ntime);
}
if (opt_benchmark)
ptarget[7] = 0x0cff;
do {
be32enc(&endiandata[19], nonce);
x16r_hash(hash32, endiandata);
if (hash32[7] <= Htarg && fulltest(hash32, ptarget)) {
work_set_target_ratio(work, hash32);
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce;
return 1;
}
nonce++;
} while (nonce < max_nonce && !(*restart));
pdata[19] = nonce;
*hashes_done = pdata[19] - first_nonce + 1;
return 0;
}
