Giter VIP home page Giter VIP logo

bip39-solver-gpu's People

Contributors

johncantrell97 avatar

Stargazers

 avatar  avatar  avatar

Watchers

 avatar

bip39-solver-gpu's Issues

Output of normal_private_child_from_private() doesn't match expected value

The output of the said function differs from the value I'm getting from the Coincurve library in python.

Inputs:
key: 20a9ec6b6e2001b50b5a24212e3541b628e946d233ad81dc969c3903c32738e2
chaincode: 1bb0eeef41bee23c8f03f4786b8fdd2c8d8e33947617f0bdd0ed11da1e71a390
child number: 0

Expected outputs:
pubkey: 02f444ed97ad3ebb1a9eda41be4bf475888ea0c15ddbab9aaf109051384073a0f5
key: 9cf2f303a39715e78b727cb8b14343f9ded027e56cb04dfe5ebd1d73a300c343
chaincode: fd243eb849705c56b27f4009518bb9067564fe7b6c37fc50c62b98e9cc860af2

Actual outputs:
pubkey: 02bfe1d2198546390f8bd24731ccae1bd98699007ce08089ec93046501cae82f0e
key: 12fbb9354143413f1cc74d8d7c6af2c246c16e84094f70dff4914f5142a1a08d
chaincode: 60948ea822c2fad6506a96c4c0dc36cce82746d3ea7901e211d841a556c2ebfa

It seemed as though the problem originates from int secp256k1_ec_pubkey_create(). I've spent days looking through the code but can't figure out what the issue was as I'm still quite new to secp256k1 and opencl. I'd really appreciate any assistance. Thank you.

if using 24 seed lenght, is it going to be a problem

first of all thanks for this amazing job you have done.

i want to use your code to recover a 24 seed wallet, after reading your post on medium I was wondering if 64KB local memory of graphic cards has enough space to work or not?

OPENCL ERROR

cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.36s
Running target\debug\bip39-solver-gpu.exe
thread 'main' panicked at 'called Result::unwrap() on an Err value:

################################ OPENCL ERROR ###############################

Error executing function: clEnqueueReadBuffer

Status error code: CL_OUT_OF_RESOURCES (-5)

Please visit the following url for more information:

https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clEnqueueReadBuffer.html#errors

#############################################################################
', src\main.rs:218:128
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace
error: process didn't exit successfully: target\debug\bip39-solver-gpu.exe (exit code: 101)

can this resurect an old wallet?

besides having a really hard time getting this to work, probably from my complete lack of knowledge of using rust or py, or coding in general. I was wondering I could get help finding and getting access to my very old wallet.
I was trying out BTCrecover and see who that program can use a address.db file while trying to reconstruct a mnemonic from a given set of words. I find it limiting as it doesn't try reconstructing my mnemonic with n! and only allows for 1 missing word and only 2 switched words at the very most; I'm shooting in the dark and know I can remember at least 6 of my words but not in order, and another 4 words that are good possibilities that were in the seed phrase. is there any way of making this do such a thing? prioritize my know 6 or? words, while giving another couple words a step above the rest of bip39 words while searching an address.db I create for the time period i originally made and funded my wallet? Time is not an issue, as i'm sure even with a program that could do all this, it would take many years running to crack it, but It is a 9 year old wallet and worth that kind of trouble. any help?

ubuntu ver

pls advice it for win ver, could you update ubuntu ver ?

help me ! compiler problem

I did all things to compile in windows 10 either linux kali but i got error when i run it
bip39

C:\Users\Administrator\Desktop\bip39-solver-gpu>bip39-solver-gpu.exe
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value:

###################### OPENCL PROGRAM BUILD DEBUG OUTPUT ######################

<kernel>:307:48: warning: passing 'const uchar *__attribute__((address_space(16776963)))' (aka 'const unsigned char *__attribute__((address_space(16776963)))') to parameter of type 'uchar *' (aka 'unsigned char *') discards qualifiers
        memcpy( (void *) (ctx->buffer + left), input, fill );
                                               ^~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:323:48: warning: passing 'const uchar *__attribute__((address_space(16776963)))' (aka 'const unsigned char *__attribute__((address_space(16776963)))') to parameter of type 'uchar *' (aka 'unsigned char *') discards qualifiers
        memcpy( (void *) (ctx->buffer + left), input, ilen );
                                               ^~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:369:9: warning: 'F1' macro redefined
#define F1(x,y,z) (bitselect(z,y,x))
        ^
<kernel>:143:9: note: previous definition is here
#define F1( x, y, z )   ( x ^ y ^ z )
        ^
<kernel>:2915:12: warning: incompatible pointer types passing '__attribute__((address_space(16776963))) secp256k1_ge_storage *' to parameter of type 'uchar *' (aka 'unsigned char *')
    memset(&adds, 0, sizeof(adds));
           ^~~~~
<kernel>:6:27: note: passing argument to parameter 'str' here
static void memset(uchar *str, int c, size_t n){
                          ^
<kernel>:2965:12: warning: incompatible pointer types passing 'secp256k1_pubkey *__attribute__((address_space(16776963)))' to parameter of type 'uchar *' (aka 'unsigned char *')
    memset(pubkey, 0, sizeof(*pubkey));
           ^~~~~~
<kernel>:6:27: note: passing argument to parameter 'str' here
static void memset(uchar *str, int c, size_t n){
                          ^
<kernel>:3094:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
  sha512(&inner_concat, 128+message_length_bytes, output);
         ^~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3094:51: warning: incompatible pointer types passing 'uchar *__attribute__((address_space(16776963)))' (aka 'unsigned char *__attribute__((address_space(16776963)))') to parameter of type 'ulong *' (aka 'unsigned long *')
  sha512(&inner_concat, 128+message_length_bytes, output);
                                                  ^~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3103:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
  sha512(&inner_concat, 192, output);
         ^~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3103:30: warning: incompatible pointer types passing 'uchar *__attribute__((address_space(16776963)))' (aka 'unsigned char *__attribute__((address_space(16776963)))') to parameter of type 'ulong *' (aka 'unsigned long *')
  sha512(&inner_concat, 192, output);
                             ^~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3109:15: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[12]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&key, 12, seed, 64, &hmacsha512_result);
              ^~~~
<kernel>:3072:25: note: passing argument to parameter 'key' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                        ^
<kernel>:3109:35: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&key, 12, seed, 64, &hmacsha512_result);
                                  ^~~~~~~~~~~~~~~~~~
<kernel>:3072:101: note: passing argument to parameter 'output' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                                                                                                    ^
<kernel>:3113:17: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&pkey.key, &hmacsha512_result, 0, 32);
                ^~~~~~~~~
<kernel>:18:34: note: passing argument to parameter 'dest' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                 ^
<kernel>:3113:28: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&pkey.key, &hmacsha512_result, 0, 32);
                           ^~~~~~~~~~~~~~~~~~
<kernel>:18:47: note: passing argument to parameter 'src' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                              ^
<kernel>:3122:17: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&master->chain_code, &hmacsha512_result, 32, 32);
                ^~~~~~~~~~~~~~~~~~~
<kernel>:18:34: note: passing argument to parameter 'dest' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                 ^
<kernel>:3122:38: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&master->chain_code, &hmacsha512_result, 32, 32);
                                     ^~~~~~~~~~~~~~~~~~
<kernel>:18:47: note: passing argument to parameter 'src' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                              ^
<kernel>:3129:10: warning: incompatible pointer types passing 'uchar (*)[4]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&pub->parent_fingerprint,&priv->parent_fingerprint, 4);
         ^~~~~~~~~~~~~~~~~~~~~~~~
<kernel>:12:27: note: passing argument to parameter 'dest' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                          ^
<kernel>:3129:35: warning: incompatible pointer types passing 'uchar (*)[4]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&pub->parent_fingerprint,&priv->parent_fingerprint, 4);
                                  ^~~~~~~~~~~~~~~~~~~~~~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:3130:10: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&pub->chain_code, &priv->chain_code, 32);
         ^~~~~~~~~~~~~~~~
<kernel>:12:27: note: passing argument to parameter 'dest' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                          ^
<kernel>:3130:28: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&pub->chain_code, &priv->chain_code, 32);
                           ^~~~~~~~~~~~~~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:3131:52: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'const unsigned char *'
  secp256k1_ec_pubkey_create(&pub->public_key.key, &priv->private_key.key);
                                                   ^~~~~~~~~~~~~~~~~~~~~~
<kernel>:2958:79: note: passing argument to parameter 'seckey' here
int secp256k1_ec_pubkey_create(secp256k1_pubkey *pubkey, const unsigned char *seckey) {
                                                                              ^
<kernel>:3143:10: error: implicit conversion from address space "generic" to address space "private" is not supported when passing to parameter of destination type
  sha256(input, input_len, output);
         ^~~~~
<kernel>:649:50: note: passing argument to parameter 'pass' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                 ^
<kernel>:3143:28: error: implicit conversion from address space "generic" to address space "private" is not supported when passing to parameter of destination type
  sha256(input, input_len, output);
                           ^~~~~~
<kernel>:649:94: note: passing argument to parameter 'hash' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                                                             ^
<kernel>:3144:10: error: implicit conversion from address space "generic" to address space "private" is not supported when passing to parameter of destination type
  sha256(output, 32, output);
         ^~~~~~
<kernel>:649:50: note: passing argument to parameter 'pass' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                 ^
<kernel>:3144:22: error: implicit conversion from address space "generic" to address space "private" is not supported when passing to parameter of destination type
  sha256(output, 32, output);
                     ^~~~~~
<kernel>:649:94: note: passing argument to parameter 'hash' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                                                             ^
<kernel>:3149:10: error: implicit conversion from address space "generic" to address space "private" is not supported when passing to parameter of destination type
  sha256(input, input_len, &sha256_result);
         ^~~~~
<kernel>:649:50: note: passing argument to parameter 'pass' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                 ^
<kernel>:3149:28: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type '__attribute__((address_space(16776963))) unsigned int *'
  sha256(input, input_len, &sha256_result);
                           ^~~~~~~~~~~~~~
<kernel>:649:94: note: passing argument to parameter 'hash' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                                                             ^
<kernel>:3150:13: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'const uchar *' (aka 'const unsigned char *')
  ripemd160(&sha256_result, 32, output);
            ^~~~~~~~~~~~~~
<kernel>:362:31: note: passing argument to parameter 'msg' here
void ripemd160(const uint8_t *msg, uint32_t msg_len, uint8_t hash[20])
                              ^
<kernel>:3150:33: warning: passing 'char *__attribute__((address_space(16776963)))' to parameter of type 'uchar *' (aka 'unsigned char *') converts between pointers to integer types with different sign
  ripemd160(&sha256_result, 32, output);
                                ^~~~~~
<kernel>:362:62: note: passing argument to parameter 'hash' here
void ripemd160(const uint8_t *msg, uint32_t msg_len, uint8_t hash[20])
                                                             ^
<kernel>:3155:30: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[33]' to parameter of type 'uchar *' (aka 'unsigned char *')
  serialized_public_key(pub, &serialized_key);
                             ^~~~~~~~~~~~~~~
<kernel>:3134:63: note: passing argument to parameter 'serialized_key' here
void serialized_public_key(extended_public_key_t *pub, uchar *serialized_key) {
                                                              ^
<kernel>:3156:11: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[33]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hash160(&serialized_key, 33, identifier);
          ^~~~~~~~~~~~~~~
<kernel>:3147:21: note: passing argument to parameter 'input' here
void hash160(uchar *input, int input_len, char * output) {
                    ^
<kernel>:3156:32: warning: passing 'uchar *__attribute__((address_space(16776963)))' (aka 'unsigned char *__attribute__((address_space(16776963)))') to parameter of type 'char *' converts between pointers to integer types with different sign
  hash160(&serialized_key, 33, identifier);
                               ^~~~~~~~~~
<kernel>:3147:50: note: passing argument to parameter 'output' here
void hash160(uchar *input, int input_len, char * output) {
                                                 ^
<kernel>:3161:34: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[20]' to parameter of type 'uchar *' (aka 'unsigned char *')
  identifier_for_public_key(pub, &identifier);
                                 ^~~~~~~~~~~
<kernel>:3153:67: note: passing argument to parameter 'identifier' here
void identifier_for_public_key(extended_public_key_t *pub, uchar *identifier) {
                                                                  ^
<kernel>:3170:34: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[20]' to parameter of type 'uchar *' (aka 'unsigned char *')
  identifier_for_public_key(pub, &pubkey_hash);
                                 ^~~~~~~~~~~~
<kernel>:3153:67: note: passing argument to parameter 'identifier' here
void identifier_for_public_key(extended_public_key_t *pub, uchar *identifier) {
                                                                  ^
<kernel>:3180:11: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[22]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hash160(&wpkh_script_bytes, 22, &wpkh_script_hash);
          ^~~~~~~~~~~~~~~~~~
<kernel>:3147:21: note: passing argument to parameter 'input' here
void hash160(uchar *input, int input_len, char * output) {
                    ^
<kernel>:3180:35: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[20]' to parameter of type 'char *'
  hash160(&wpkh_script_bytes, 22, &wpkh_script_hash);
                                  ^~~~~~~~~~~~~~~~~
<kernel>:3147:50: note: passing argument to parameter 'output' here
void hash160(uchar *input, int input_len, char * output) {
                                                 ^
<kernel>:3189:30: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'char *'
  sha256d(address_bytes, 21, &sha256d_result);
                             ^~~~~~~~~~~~~~~
<kernel>:3142:50: note: passing argument to parameter 'output' here
void sha256d(uchar *input, int input_len, char * output) {
                                                 ^
<kernel>:3203:31: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[37]' to parameter of type 'uchar *' (aka 'unsigned char *')
  serialized_public_key(&pub, &hmac_input);
                              ^~~~~~~~~~~
<kernel>:3134:63: note: passing argument to parameter 'serialized_key' here
void serialized_public_key(extended_public_key_t *pub, uchar *serialized_key) {
                                                              ^
<kernel>:3208:15: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
              ^~~~~~~~~~~~~~~~~~~
<kernel>:3072:25: note: passing argument to parameter 'key' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                        ^
<kernel>:3208:40: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[37]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
                                       ^~~~~~~~~~~
<kernel>:3072:59: note: passing argument to parameter 'message' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                                                          ^
<kernel>:3208:57: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
                                                        ^~~~~~~~~~~~~~~~~~
<kernel>:3072:101: note: passing argument to parameter 'output' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                                                                                                    ^
<kernel>:3213:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&sk.key, &hmacsha512_result, 32);
         ^~~~~~~
<kernel>:12:27: note: passing argument to parameter 'dest' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                          ^
<kernel>:3213:19: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&sk.key, &hmacsha512_result, 32);
                  ^~~~~~~~~~~~~~~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:3214:33: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'unsigned char *'
  secp256k1_ec_seckey_tweak_add(&sk.key, &parent->private_key.key);
                                ^~~~~~~
<kernel>:2986:50: note: passing argument to parameter 'seckey' here
int secp256k1_ec_seckey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {
                                                 ^
<kernel>:3214:42: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'const unsigned char *'
  secp256k1_ec_seckey_tweak_add(&sk.key, &parent->private_key.key);
                                         ^~~~~~~~~~~~~~~~~~~~~~~~
<kernel>:2986:79: note: passing argument to parameter 'tweak' here
int secp256k1_ec_seckey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {
                                                                              ^
<kernel>:3219:17: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&child->chain_code, &hmacsha512_result, 32, 32);
                ^~~~~~~~~~~~~~~~~~
<kernel>:18:34: note: passing argument to parameter 'dest' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                 ^
<kernel>:3219:37: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&child->chain_code, &hmacsha512_result, 32, 32);
                                    ^~~~~~~~~~~~~~~~~~
<kernel>:18:47: note: passing argument to parameter 'src' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                              ^
<kernel>:3235:15: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
              ^~~~~~~~~~~~~~~~~~~
<kernel>:3072:25: note: passing argument to parameter 'key' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                        ^
<kernel>:3235:40: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[37]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
                                       ^~~~~~~~~~~
<kernel>:3072:59: note: passing argument to parameter 'message' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                                                          ^
<kernel>:3235:57: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  hmac_sha512(&parent->chain_code, 32, &hmac_input, 37, &hmacsha512_result);
                                                        ^~~~~~~~~~~~~~~~~~
<kernel>:3072:101: note: passing argument to parameter 'output' here
void hmac_sha512(uchar *key, int key_length_bytes, uchar *message, int message_length_bytes, uchar *output) {
                                                                                                    ^
<kernel>:3240:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&sk.key, &hmacsha512_result, 32);
         ^~~~~~~
<kernel>:12:27: note: passing argument to parameter 'dest' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                          ^
<kernel>:3240:19: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy(&sk.key, &hmacsha512_result, 32);
                  ^~~~~~~~~~~~~~~~~~
<kernel>:12:40: note: passing argument to parameter 'src' here
static void memcpy(uchar *dest, uchar *src, size_t n){
                                       ^
<kernel>:3241:33: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type 'unsigned char *'
  secp256k1_ec_seckey_tweak_add(&sk.key, &parent->private_key.key);
                                ^~~~~~~
<kernel>:2986:50: note: passing argument to parameter 'seckey' here
int secp256k1_ec_seckey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {
                                                 ^
<kernel>:3241:42: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'const unsigned char *'
  secp256k1_ec_seckey_tweak_add(&sk.key, &parent->private_key.key);
                                         ^~~~~~~~~~~~~~~~~~~~~~~~
<kernel>:2986:79: note: passing argument to parameter 'tweak' here
int secp256k1_ec_seckey_tweak_add(unsigned char *seckey, const unsigned char *tweak) {
                                                                              ^
<kernel>:3246:17: warning: incompatible pointer types passing 'uchar (*)[32]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&child->chain_code, &hmacsha512_result, 32, 32);
                ^~~~~~~~~~~~~~~~~~
<kernel>:18:34: note: passing argument to parameter 'dest' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                 ^
<kernel>:3246:37: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  memcpy_offset(&child->chain_code, &hmacsha512_result, 32, 32);
                                    ^~~~~~~~~~~~~~~~~~
<kernel>:18:47: note: passing argument to parameter 'src' here
static void memcpy_offset(uchar *dest, uchar *src, int offset, uchar bytes_to_copy){
                                              ^
<kernel>:3281:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[16]' to parameter of type 'const __attribute__((address_space(16776963))) unsigned int *'
  sha256(&bytes, 16, &mnemonic_hash);
         ^~~~~~
<kernel>:649:50: note: passing argument to parameter 'pass' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                 ^
<kernel>:3281:22: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[32]' to parameter of type '__attribute__((address_space(16776963))) unsigned int *'
  sha256(&bytes, 16, &mnemonic_hash);
                     ^~~~~~~~~~~~~~
<kernel>:649:94: note: passing argument to parameter 'hash' here
static void sha256(__private const unsigned int *pass, int pass_len, __private unsigned int* hash) {
                                                                                             ^
<kernel>:3338:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
  sha512(&key_previous_concat, 140, &sha512_result);
         ^~~~~~~~~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3338:37: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'ulong *' (aka 'unsigned long *')
  sha512(&key_previous_concat, 140, &sha512_result);
                                    ^~~~~~~~~~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3339:21: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[128]' to parameter of type 'uchar *' (aka 'unsigned char *')
  copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                    ^~~~~~~~~
<kernel>:44:31: note: passing argument to parameter 'pad' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                              ^
<kernel>:3339:32: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                               ^~~~~~~~~~~~~~
<kernel>:44:43: note: passing argument to parameter 'previous' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                          ^
<kernel>:3339:48: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'uchar *' (aka 'unsigned char *')
  copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                                               ^~~~~~~~~~~~~~~~~~~~
<kernel>:44:60: note: passing argument to parameter 'joined' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                                           ^
<kernel>:3340:10: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
  sha512(&key_previous_concat, 192, &sha512_result);
         ^~~~~~~~~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3340:37: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'ulong *' (aka 'unsigned long *')
  sha512(&key_previous_concat, 192, &sha512_result);
                                    ^~~~~~~~~~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3341:23: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'char *'
  xor_seed_with_round(&seed, &sha512_result);
                      ^~~~~
<kernel>:60:32: note: passing argument to parameter 'seed' here
void xor_seed_with_round(char *seed, char *round) {
                               ^
<kernel>:3341:30: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'char *'
  xor_seed_with_round(&seed, &sha512_result);
                             ^~~~~~~~~~~~~~
<kernel>:60:44: note: passing argument to parameter 'round' here
void xor_seed_with_round(char *seed, char *round) {
                                           ^
<kernel>:3344:23: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[128]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&ipad_key, &sha512_result, &key_previous_concat);
                      ^~~~~~~~~
<kernel>:44:31: note: passing argument to parameter 'pad' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                              ^
<kernel>:3344:34: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&ipad_key, &sha512_result, &key_previous_concat);
                                 ^~~~~~~~~~~~~~
<kernel>:44:43: note: passing argument to parameter 'previous' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                          ^
<kernel>:3344:50: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&ipad_key, &sha512_result, &key_previous_concat);
                                                 ^~~~~~~~~~~~~~~~~~~~
<kernel>:44:60: note: passing argument to parameter 'joined' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                                           ^
<kernel>:3345:12: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
    sha512(&key_previous_concat, 192, &sha512_result);
           ^~~~~~~~~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3345:39: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'ulong *' (aka 'unsigned long *')
    sha512(&key_previous_concat, 192, &sha512_result);
                                      ^~~~~~~~~~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3346:23: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[128]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                      ^~~~~~~~~
<kernel>:44:31: note: passing argument to parameter 'pad' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                              ^
<kernel>:3346:34: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                                 ^~~~~~~~~~~~~~
<kernel>:44:43: note: passing argument to parameter 'previous' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                          ^
<kernel>:3346:50: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'uchar *' (aka 'unsigned char *')
    copy_pad_previous(&opad_key, &sha512_result, &key_previous_concat);
                                                 ^~~~~~~~~~~~~~~~~~~~
<kernel>:44:60: note: passing argument to parameter 'joined' here
void copy_pad_previous(uchar *pad, uchar *previous, uchar *joined) {
                                                           ^
<kernel>:3347:12: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[256]' to parameter of type 'unsigned long *'
    sha512(&key_previous_concat, 192, &sha512_result);
           ^~~~~~~~~~~~~~~~~~~~
<kernel>:584:35: note: passing argument to parameter 'input' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                  ^
<kernel>:3347:39: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'ulong *' (aka 'unsigned long *')
    sha512(&key_previous_concat, 192, &sha512_result);
                                      ^~~~~~~~~~~~~~
<kernel>:584:76: note: passing argument to parameter 'hash' here
static void sha512(unsigned long *input, const unsigned int length, ulong *hash) {
                                                                           ^
<kernel>:3348:25: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'char *'
    xor_seed_with_round(&seed, &sha512_result);
                        ^~~~~
<kernel>:60:32: note: passing argument to parameter 'seed' here
void xor_seed_with_round(char *seed, char *round) {
                               ^
<kernel>:3348:32: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'char *'
    xor_seed_with_round(&seed, &sha512_result);
                               ^~~~~~~~~~~~~~
<kernel>:60:44: note: passing argument to parameter 'round' here
void xor_seed_with_round(char *seed, char *round) {
                                           ^
<kernel>:3355:33: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[64]' to parameter of type 'uchar *' (aka 'unsigned char *')
  new_master_from_seed(network, &seed, &master_private);
                                ^~~~~
<kernel>:3106:49: note: passing argument to parameter 'seed' here
void new_master_from_seed(uchar network, uchar *seed, extended_private_key_t * master) {
                                                ^
<kernel>:3359:41: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[33]' to parameter of type 'uchar *' (aka 'unsigned char *')
  serialized_public_key(&master_public, &serialized_master_public);
                                        ^~~~~~~~~~~~~~~~~~~~~~~~~
<kernel>:3134:63: note: passing argument to parameter 'serialized_key' here
void serialized_public_key(extended_public_key_t *pub, uchar *serialized_key) {
                                                              ^
<kernel>:3370:55: warning: incompatible pointer types passing 'uchar __attribute__((address_space(16776963))) (*)[25]' to parameter of type 'uchar *' (aka 'unsigned char *')
  p2shwpkh_address_for_public_key(&target_public_key, &raw_address);
                                                      ^~~~~~~~~~~~
<kernel>:3168:73: note: passing argument to parameter 'address_bytes' here
void p2shwpkh_address_for_public_key(extended_public_key_t *pub, uchar *address_bytes) {
                                                                        ^

###############################################################################

', src\main.rs:139:93
stack backtrace:
   0:     0x7ff7d6baa10e - std::backtrace_rs::backtrace::dbghelp::trace
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\..\..\backtrace\src\backtrace\dbghelp.rs:98
   1:     0x7ff7d6baa10e - std::backtrace_rs::backtrace::trace_unsynchronized
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\..\..\backtrace\src\backtrace\mod.rs:66
   2:     0x7ff7d6baa10e - std::sys_common::backtrace::_print_fmt
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\sys_common\backtrace.rs:67
   3:     0x7ff7d6baa10e - std::sys_common::backtrace::_print::impl$0::fmt
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\sys_common\backtrace.rs:46
   4:     0x7ff7d6bbf86a - core::fmt::write
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\core\src\fmt\mod.rs:1150
   5:     0x7ff7d6ba47c8 - std::io::Write::write_fmt<std::sys::windows::stdio::Stderr>
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\io\mod.rs:1667
   6:     0x7ff7d6bac546 - std::sys_common::backtrace::_print
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\sys_common\backtrace.rs:49
   7:     0x7ff7d6bac546 - std::sys_common::backtrace::print
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\sys_common\backtrace.rs:36
   8:     0x7ff7d6bac546 - std::panicking::default_hook::closure$1
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:210
   9:     0x7ff7d6bac034 - std::panicking::default_hook
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:227
  10:     0x7ff7d6bacba5 - std::panicking::rust_panic_with_hook
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:624
  11:     0x7ff7d6bac78b - std::panicking::begin_panic_handler::closure$0
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:521
  12:     0x7ff7d6baaa57 - std::sys_common::backtrace::__rust_end_short_backtrace<std::panicking::begin_panic_handler::closure$0,never$>
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\sys_common\backtrace.rs:141
  13:     0x7ff7d6bac6e9 - std::panicking::begin_panic_handler
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:517
  14:     0x7ff7d6be22c0 - core::panicking::panic_fmt
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\core\src\panicking.rs:101
  15:     0x7ff7d6be23d3 - core::result::unwrap_failed
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\core\src\result.rs:1617
  16:     0x7ff7d69ea77f - bip39_solver_gpu::mnemonic_gpu::h003fd7a987642f67
  17:     0x7ff7d69e6d21 - core::ops::function::impls::<impl core::ops::function::FnMut<A> for &F>::call_mut::he8814e22cd04bebe
  18:     0x7ff7d69f013c - <rayon::iter::for_each::ForEachConsumer<F> as rayon::iter::plumbing::Folder<T>>::consume_iter::h2f91a5e0a79a1960
  19:     0x7ff7d69dcdd6 - rayon::iter::plumbing::bridge_producer_consumer::helper::he18c612aadbad4cf
  20:     0x7ff7d69dcfae - rayon::iter::plumbing::bridge::hc0bfc0965373b9d3
  21:     0x7ff7d69de39f - rayon::iter::ParallelIterator::for_each::hd515bf16465942ed
  22:     0x7ff7d69ed9bf - bip39_solver_gpu::mnemonic_gpu::h003fd7a987642f67
  23:     0x7ff7d69debd6 - std::sys_common::backtrace::__rust_begin_short_backtrace::h7db5c631b83f1864
  24:     0x7ff7d69f1e9c - std::rt::lang_start::{{closure}}::h3b913290921afb26
  25:     0x7ff7d6bad136 - core::ops::function::impls::impl$2::call_once
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\library\core\src\ops\function.rs:259
  26:     0x7ff7d6bad136 - std::panicking::try::do_call
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:403
  27:     0x7ff7d6bad136 - std::panicking::try
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:367
  28:     0x7ff7d6bad136 - std::panic::catch_unwind
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panic.rs:129
  29:     0x7ff7d6bad136 - std::rt::lang_start_internal::closure$2
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\rt.rs:45
  30:     0x7ff7d6bad136 - std::panicking::try::do_call
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:403
  31:     0x7ff7d6bad136 - std::panicking::try
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panicking.rs:367
  32:     0x7ff7d6bad136 - std::panic::catch_unwind
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\panic.rs:129
  33:     0x7ff7d6bad136 - std::rt::lang_start_internal
                               at /rustc/59eed8a2aac0230a8b53e89d4e99d55912ba6b35\/library\std\src\rt.rs:45
  34:     0x7ff7d69edeb7 - main
  35:     0x7ff7d6bd7028 - invoke_main
                               at d:\a01\_work\6\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:78
  36:     0x7ff7d6bd7028 - __scrt_common_main_seh
                               at d:\a01\_work\6\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288
  37:     0x7fff32567034 - BaseThreadInitThunk
  38:     0x7fff32c22651 - RtlUserThreadStart
```

how to run bip39-solver-gpu on my windows and also in vastai

hello
can any one help me to run this bip39-solver-gpu on my windows and also in vastai
i am very and dont know how to install and run this program
every help is welcomed please
if the Author johncantrell97 also checks this page please help me

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.