mirror of https://github.com/GOSTSec/sgminer
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
224 lines
6.2 KiB
224 lines
6.2 KiB
/*- |
|
* Copyright 2014 phm |
|
* All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions |
|
* are met: |
|
* 1. Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* 2. Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
* SUCH DAMAGE. |
|
*/ |
|
|
|
#include "config.h" |
|
#include "miner.h" |
|
|
|
#include <stdlib.h> |
|
#include <stdint.h> |
|
#include <string.h> |
|
|
|
#include "sph/sph_blake.h" |
|
#include "sph/sph_bmw.h" |
|
#include "sph/sph_groestl.h" |
|
#include "sph/sph_skein.h" |
|
#include "sph/sph_jh.h" |
|
#include "sph/sph_keccak.h" |
|
|
|
/* |
|
* Encode a length len/4 vector of (uint32_t) into a length len vector of |
|
* (unsigned char) in big-endian form. Assumes len is a multiple of 4. |
|
*/ |
|
static inline void |
|
be32enc_vect(uint32_t *dst, const uint32_t *src, uint32_t len) |
|
{ |
|
uint32_t i; |
|
|
|
for (i = 0; i < len; i++) |
|
dst[i] = htobe32(src[i]); |
|
} |
|
|
|
|
|
#ifdef __APPLE_CC__ |
|
static |
|
#endif |
|
void animehash(void *state, const void *input) |
|
{ |
|
sph_blake512_context ctx_blake; |
|
sph_bmw512_context ctx_bmw; |
|
sph_groestl512_context ctx_groestl; |
|
sph_jh512_context ctx_jh; |
|
sph_keccak512_context ctx_keccak; |
|
sph_skein512_context ctx_skein; |
|
|
|
unsigned char hash[64]; |
|
|
|
sph_bmw512_init(&ctx_bmw); |
|
// ZBMW; |
|
sph_bmw512 (&ctx_bmw, input, 80); |
|
sph_bmw512_close(&ctx_bmw, (void*) hash); |
|
|
|
sph_blake512_init(&ctx_blake); |
|
// ZBLAKE; |
|
sph_blake512 (&ctx_blake, (const void*) hash, 64); |
|
sph_blake512_close(&ctx_blake, (void*) hash); |
|
|
|
if (hash[0] & 0x8) |
|
{ |
|
sph_groestl512_init(&ctx_groestl); |
|
// ZGROESTL; |
|
sph_groestl512 (&ctx_groestl, (const void*) hash, 64); |
|
sph_groestl512_close(&ctx_groestl, (void*) hash); |
|
} |
|
else |
|
{ |
|
sph_skein512_init(&ctx_skein); |
|
// ZSKEIN; |
|
sph_skein512 (&ctx_skein, (const void*) hash, 64); |
|
sph_skein512_close(&ctx_skein, (void*) hash); |
|
} |
|
|
|
sph_groestl512_init(&ctx_groestl); |
|
// ZGROESTL; |
|
sph_groestl512 (&ctx_groestl, (const void*) hash, 64); |
|
sph_groestl512_close(&ctx_groestl, (void*) hash); |
|
|
|
sph_jh512_init(&ctx_jh); |
|
// ZJH; |
|
sph_jh512 (&ctx_jh, (const void*) hash, 64); |
|
sph_jh512_close(&ctx_jh, (void*) hash); |
|
|
|
if (hash[0] & 0x8) |
|
{ |
|
sph_blake512_init(&ctx_blake); |
|
// ZBLAKE; |
|
sph_blake512 (&ctx_blake, (const void*) hash, 64); |
|
sph_blake512_close(&ctx_blake, (void*) hash); |
|
} |
|
else |
|
{ |
|
sph_bmw512_init(&ctx_bmw); |
|
// ZBMW; |
|
sph_bmw512 (&ctx_bmw, (const void*) hash, 64); |
|
sph_bmw512_close(&ctx_bmw, (void*) hash); |
|
} |
|
|
|
sph_keccak512_init(&ctx_keccak); |
|
// ZKECCAK; |
|
sph_keccak512 (&ctx_keccak, (const void*) hash, 64); |
|
sph_keccak512_close(&ctx_keccak, (void*) hash); |
|
|
|
sph_skein512_init(&ctx_skein); |
|
// SKEIN; |
|
sph_skein512 (&ctx_skein, (const void*) hash, 64); |
|
sph_skein512_close(&ctx_skein, (void*) hash); |
|
|
|
if (hash[0] & 0x8) |
|
{ |
|
sph_keccak512_init(&ctx_keccak); |
|
// ZKECCAK; |
|
sph_keccak512 (&ctx_keccak, (const void*) hash, 64); |
|
sph_keccak512_close(&ctx_keccak, (void*) hash); |
|
} |
|
else |
|
{ |
|
sph_jh512_init(&ctx_jh); |
|
// ZJH; |
|
sph_jh512 (&ctx_jh, (const void*) hash, 64); |
|
sph_jh512_close(&ctx_jh, (void*) hash); |
|
} |
|
|
|
memcpy(state, hash, 32); |
|
} |
|
|
|
static const uint32_t diff1targ = 0x0000ffff; |
|
|
|
|
|
/* Used externally as confirmation of correct OCL code */ |
|
int animecoin_test(unsigned char *pdata, const unsigned char *ptarget, uint32_t nonce) |
|
{ |
|
uint32_t tmp_hash7, Htarg = le32toh(((const uint32_t *)ptarget)[7]); |
|
uint32_t data[20], ohash[8]; |
|
|
|
be32enc_vect(data, (const uint32_t *)pdata, 19); |
|
data[19] = htobe32(nonce); |
|
animehash(ohash, data); |
|
tmp_hash7 = be32toh(ohash[7]); |
|
|
|
applog(LOG_DEBUG, "htarget %08lx diff1 %08lx hash %08lx", |
|
(long unsigned int)Htarg, |
|
(long unsigned int)diff1targ, |
|
(long unsigned int)tmp_hash7); |
|
if (tmp_hash7 > diff1targ) |
|
return -1; |
|
if (tmp_hash7 > Htarg) |
|
return 0; |
|
return 1; |
|
} |
|
|
|
void animecoin_regenhash(struct work *work) |
|
{ |
|
uint32_t data[20]; |
|
uint32_t *nonce = (uint32_t *)(work->data + 76); |
|
uint32_t *ohash = (uint32_t *)(work->hash); |
|
|
|
be32enc_vect(data, (const uint32_t *)work->data, 19); |
|
data[19] = htobe32(*nonce); |
|
animehash(ohash, data); |
|
} |
|
|
|
bool scanhash_animecoin(struct thr_info *thr, const unsigned char __maybe_unused *pmidstate, |
|
unsigned char *pdata, unsigned char __maybe_unused *phash1, |
|
unsigned char __maybe_unused *phash, const unsigned char *ptarget, |
|
uint32_t max_nonce, uint32_t *last_nonce, uint32_t n) |
|
{ |
|
uint32_t *nonce = (uint32_t *)(pdata + 76); |
|
uint32_t data[20]; |
|
uint32_t tmp_hash7; |
|
uint32_t Htarg = le32toh(((const uint32_t *)ptarget)[7]); |
|
bool ret = false; |
|
|
|
be32enc_vect(data, (const uint32_t *)pdata, 19); |
|
|
|
while(1) { |
|
uint32_t ostate[8]; |
|
|
|
*nonce = ++n; |
|
data[19] = (n); |
|
animehash(ostate, data); |
|
tmp_hash7 = (ostate[7]); |
|
|
|
applog(LOG_INFO, "data7 %08lx", |
|
(long unsigned int)data[7]); |
|
|
|
if (unlikely(tmp_hash7 <= Htarg)) { |
|
((uint32_t *)pdata)[19] = htobe32(n); |
|
*last_nonce = n; |
|
ret = true; |
|
break; |
|
} |
|
|
|
if (unlikely((n >= max_nonce) || thr->work_restart)) { |
|
*last_nonce = n; |
|
break; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
|
|
|
|
|