From 1685904219ad1453730caa5e2d43b923690ddc5b Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:20:51 +0200 Subject: [PATCH 1/8] Create Module_29800.hctune --- tunings/Module_29800.hctune | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 tunings/Module_29800.hctune diff --git a/tunings/Module_29800.hctune b/tunings/Module_29800.hctune new file mode 100644 index 000000000..9af4d2720 --- /dev/null +++ b/tunings/Module_29800.hctune @@ -0,0 +1,27 @@ +# +# Find the right -n value for your GPU: +# ===================================== +# +# 1. For example, to find the value for 27700, first create a valid hash for 27700 as follows: +# +# $ ./hashcat --example-hashes -m 27700 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.27700 +# +# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer. +# +# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.27700 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 27700 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x +# +# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning. +# +# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail +# +# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n + +#Device Attack Hash Vector Kernel Kernel +#Name Mode Type Width Accel Loops + +DEVICE_TYPE_CPU * 29800 1 N A +DEVICE_TYPE_GPU * 29800 1 N A + +GeForce_GTX_1070_Ti * 29800 1 14 A +GeForce_GTX_1080 * 29800 1 14 A +GeForce_GTX_1080_Ti * 29800 1 20 A From 7848a1426d6d3a6281f675a1dc990b39091feaa4 Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:22:27 +0200 Subject: [PATCH 2/8] Create m29800-pure.cl --- OpenCL/m29800-pure.cl | 667 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 667 insertions(+) create mode 100644 OpenCL/m29800-pure.cl diff --git a/OpenCL/m29800-pure.cl b/OpenCL/m29800-pure.cl new file mode 100644 index 000000000..6ef297c50 --- /dev/null +++ b/OpenCL/m29800-pure.cl @@ -0,0 +1,667 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_hash_sha256.cl) +#include M2S(INCLUDE_PATH/inc_cipher_aes.cl) +#endif + +typedef struct +{ + #ifndef SCRYPT_TMP_ELEM + #define SCRYPT_TMP_ELEM 1 + #endif + + uint4 P[SCRYPT_TMP_ELEM]; + +} scrypt_tmp_t; + +#if defined IS_CUDA || defined IS_HIP + +inline __device__ uint4 operator & (const uint4 a, const u32 b) { return make_uint4 ((a.x & b ), (a.y & b ), (a.z & b ), (a.w & b )); } +inline __device__ uint4 operator << (const uint4 a, const u32 b) { return make_uint4 ((a.x << b ), (a.y << b ), (a.z << b ), (a.w << b )); } +inline __device__ uint4 operator >> (const uint4 a, const u32 b) { return make_uint4 ((a.x >> b ), (a.y >> b ), (a.z >> b ), (a.w >> b )); } +inline __device__ uint4 operator + (const uint4 a, const uint4 b) { return make_uint4 ((a.x + b.x), (a.y + b.y), (a.z + b.z), (a.w + b.w)); } +inline __device__ uint4 operator ^ (const uint4 a, const uint4 b) { return make_uint4 ((a.x ^ b.x), (a.y ^ b.y), (a.z ^ b.z), (a.w ^ b.w)); } +inline __device__ uint4 operator | (const uint4 a, const uint4 b) { return make_uint4 ((a.x | b.x), (a.y | b.y), (a.z | b.z), (a.w | b.w)); } +inline __device__ void operator ^= ( uint4 &a, const uint4 b) { a.x ^= b.x; a.y ^= b.y; a.z ^= b.z; a.w ^= b.w; } + +inline __device__ uint4 rotate (const uint4 a, const int n) +{ + return ((a << n) | ((a >> (32 - n)))); +} + +#endif + +DECLSPEC uint4 hc_swap32_4 (uint4 v) +{ + return (rotate ((v & 0x00FF00FF), 24u) | rotate ((v & 0xFF00FF00), 8u)); +} + +#define GET_SCRYPT_CNT(r,p) (2 * (r) * 16 * (p)) +#define GET_SMIX_CNT(r,N) (2 * (r) * 16 * (N)) +#define GET_STATE_CNT(r) (2 * (r) * 16) + +#define SCRYPT_CNT GET_SCRYPT_CNT (SCRYPT_R, SCRYPT_P) +#define SCRYPT_CNT4 (SCRYPT_CNT / 4) +#define STATE_CNT GET_STATE_CNT (SCRYPT_R) +#define STATE_CNT4 (STATE_CNT / 4) + +#define ADD_ROTATE_XOR(r,i1,i2,s) (r) ^= rotate ((i1) + (i2), (s)); + +#if defined IS_CUDA || defined IS_HIP + +#define SALSA20_2R() \ +{ \ + ADD_ROTATE_XOR (X1, X0, X3, 7); \ + ADD_ROTATE_XOR (X2, X1, X0, 9); \ + ADD_ROTATE_XOR (X3, X2, X1, 13); \ + ADD_ROTATE_XOR (X0, X3, X2, 18); \ + \ + X1 = make_uint4 (X1.w, X1.x, X1.y, X1.z); \ + X2 = make_uint4 (X2.z, X2.w, X2.x, X2.y); \ + X3 = make_uint4 (X3.y, X3.z, X3.w, X3.x); \ + \ + ADD_ROTATE_XOR (X3, X0, X1, 7); \ + ADD_ROTATE_XOR (X2, X3, X0, 9); \ + ADD_ROTATE_XOR (X1, X2, X3, 13); \ + ADD_ROTATE_XOR (X0, X1, X2, 18); \ + \ + X1 = make_uint4 (X1.y, X1.z, X1.w, X1.x); \ + X2 = make_uint4 (X2.z, X2.w, X2.x, X2.y); \ + X3 = make_uint4 (X3.w, X3.x, X3.y, X3.z); \ +} +#elif defined IS_METAL +#define SALSA20_2R() \ +{ \ + ADD_ROTATE_XOR (X1, X0, X3, 7); \ + ADD_ROTATE_XOR (X2, X1, X0, 9); \ + ADD_ROTATE_XOR (X3, X2, X1, 13); \ + ADD_ROTATE_XOR (X0, X3, X2, 18); \ + \ + X1 = X1.wxyz; \ + X2 = X2.zwxy; \ + X3 = X3.yzwx; \ + \ + ADD_ROTATE_XOR (X3, X0, X1, 7); \ + ADD_ROTATE_XOR (X2, X3, X0, 9); \ + ADD_ROTATE_XOR (X1, X2, X3, 13); \ + ADD_ROTATE_XOR (X0, X1, X2, 18); \ + \ + X1 = X1.yzwx; \ + X2 = X2.zwxy; \ + X3 = X3.wxyz; \ +} +#else +#define SALSA20_2R() \ +{ \ + ADD_ROTATE_XOR (X1, X0, X3, 7); \ + ADD_ROTATE_XOR (X2, X1, X0, 9); \ + ADD_ROTATE_XOR (X3, X2, X1, 13); \ + ADD_ROTATE_XOR (X0, X3, X2, 18); \ + \ + X1 = X1.s3012; \ + X2 = X2.s2301; \ + X3 = X3.s1230; \ + \ + ADD_ROTATE_XOR (X3, X0, X1, 7); \ + ADD_ROTATE_XOR (X2, X3, X0, 9); \ + ADD_ROTATE_XOR (X1, X2, X3, 13); \ + ADD_ROTATE_XOR (X0, X1, X2, 18); \ + \ + X1 = X1.s1230; \ + X2 = X2.s2301; \ + X3 = X3.s3012; \ +} +#endif + +#define Coord(xd4,y,z) (((xd4) * ySIZE * zSIZE) + ((y) * zSIZE) + (z)) +#define CO Coord(xd4,y,z) + +DECLSPEC void salsa_r (PRIVATE_AS uint4 *TI) +{ + uint4 R0 = TI[STATE_CNT4 - 4]; + uint4 R1 = TI[STATE_CNT4 - 3]; + uint4 R2 = TI[STATE_CNT4 - 2]; + uint4 R3 = TI[STATE_CNT4 - 1]; + + for (int i = 0; i < STATE_CNT4; i += 4) + { + uint4 Y0 = TI[i + 0]; + uint4 Y1 = TI[i + 1]; + uint4 Y2 = TI[i + 2]; + uint4 Y3 = TI[i + 3]; + + R0 = R0 ^ Y0; + R1 = R1 ^ Y1; + R2 = R2 ^ Y2; + R3 = R3 ^ Y3; + + uint4 X0 = R0; + uint4 X1 = R1; + uint4 X2 = R2; + uint4 X3 = R3; + + SALSA20_2R (); + SALSA20_2R (); + SALSA20_2R (); + SALSA20_2R (); + + R0 = R0 + X0; + R1 = R1 + X1; + R2 = R2 + X2; + R3 = R3 + X3; + + TI[i + 0] = R0; + TI[i + 1] = R1; + TI[i + 2] = R2; + TI[i + 3] = R3; + } + + #if SCRYPT_R > 1 + + uint4 TT[STATE_CNT4 / 2]; + + for (int dst_off = 0, src_off = 4; src_off < STATE_CNT4; dst_off += 4, src_off += 8) + { + TT[dst_off + 0] = TI[src_off + 0]; + TT[dst_off + 1] = TI[src_off + 1]; + TT[dst_off + 2] = TI[src_off + 2]; + TT[dst_off + 3] = TI[src_off + 3]; + } + + for (int dst_off = 4, src_off = 8; src_off < STATE_CNT4; dst_off += 4, src_off += 8) + { + TI[dst_off + 0] = TI[src_off + 0]; + TI[dst_off + 1] = TI[src_off + 1]; + TI[dst_off + 2] = TI[src_off + 2]; + TI[dst_off + 3] = TI[src_off + 3]; + } + + for (int dst_off = STATE_CNT4 / 2, src_off = 0; dst_off < STATE_CNT4; dst_off += 4, src_off += 4) + { + TI[dst_off + 0] = TT[src_off + 0]; + TI[dst_off + 1] = TT[src_off + 1]; + TI[dst_off + 2] = TT[src_off + 2]; + TI[dst_off + 3] = TT[src_off + 3]; + } + + #endif +} + +DECLSPEC void scrypt_smix_init (PRIVATE_AS uint4 *X, GLOBAL_AS uint4 *V0, GLOBAL_AS uint4 *V1, GLOBAL_AS uint4 *V2, GLOBAL_AS uint4 *V3, const u64 gid) +{ + const u32 ySIZE = SCRYPT_N / SCRYPT_TMTO; + const u32 zSIZE = STATE_CNT4; + + const u32 x = (u32) gid; + + const u32 xd4 = x / 4; + const u32 xm4 = x & 3; + + GLOBAL_AS uint4 *V; + + switch (xm4) + { + case 0: V = V0; break; + case 1: V = V1; break; + case 2: V = V2; break; + case 3: V = V3; break; + } + + for (u32 y = 0; y < ySIZE; y++) + { + for (u32 z = 0; z < zSIZE; z++) V[CO] = X[z]; + + for (u32 i = 0; i < SCRYPT_TMTO; i++) salsa_r (X); + } +} + +DECLSPEC void scrypt_smix_loop (PRIVATE_AS uint4 *X, GLOBAL_AS uint4 *V0, GLOBAL_AS uint4 *V1, GLOBAL_AS uint4 *V2, GLOBAL_AS uint4 *V3, const u64 gid) +{ + const u32 ySIZE = SCRYPT_N / SCRYPT_TMTO; + const u32 zSIZE = STATE_CNT4; + + const u32 x = (u32) gid; + + const u32 xd4 = x / 4; + const u32 xm4 = x & 3; + + GLOBAL_AS uint4 *V; + + switch (xm4) + { + case 0: V = V0; break; + case 1: V = V1; break; + case 2: V = V2; break; + case 3: V = V3; break; + } + + // note: fixed 1024 iterations = forced -u 1024 + + for (u32 N_pos = 0; N_pos < 1024; N_pos++) + { + const u32 k = X[zSIZE - 4].x & (SCRYPT_N - 1); + + const u32 y = k / SCRYPT_TMTO; + + const u32 km = k - (y * SCRYPT_TMTO); + + uint4 T[STATE_CNT4]; + + for (u32 z = 0; z < zSIZE; z++) T[z] = V[CO]; + + for (u32 i = 0; i < km; i++) salsa_r (T); + + for (u32 z = 0; z < zSIZE; z++) X[z] ^= T[z]; + + salsa_r (X); + } +} + +KERNEL_FQ void m29800_init (KERN_ATTR_TMPS (scrypt_tmp_t)) +{ + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 w[128] = { 0 }; + + hc_enc_t hc_enc; + + hc_enc_init (&hc_enc); + + const int w_len = hc_enc_next_global (&hc_enc, pws[gid].i, pws[gid].pw_len, 256, w, sizeof (w)); + + if (w_len == -1) return; + + // utf16le to utf16be + + for (int i = 0, j = 0; i < w_len; i += 4, j += 1) + { + w[j] = ((w[j] >> 8) & 0x00ff00ff) + | ((w[j] << 8) & 0xff00ff00); + } + + sha256_hmac_ctx_t sha256_hmac_ctx; + + sha256_hmac_init_swap (&sha256_hmac_ctx, w, w_len); + + u32 s0[4] = { 0 }; + u32 s1[4] = { 0 }; + u32 s2[4] = { 0 }; + u32 s3[4] = { 0 }; + + s0[0] = salt_bufs[SALT_POS_HOST].salt_buf[0]; + s0[1] = salt_bufs[SALT_POS_HOST].salt_buf[1]; + + sha256_hmac_update_64 (&sha256_hmac_ctx, s0, s1, s2, s3, 8); + + for (u32 i = 0, j = 1, k = 0; i < SCRYPT_CNT; i += 8, j += 1, k += 2) + { + sha256_hmac_ctx_t sha256_hmac_ctx2 = sha256_hmac_ctx; + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = j; + w0[1] = 0; + w0[2] = 0; + w0[3] = 0; + w1[0] = 0; + w1[1] = 0; + w1[2] = 0; + w1[3] = 0; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + sha256_hmac_update_64 (&sha256_hmac_ctx2, w0, w1, w2, w3, 4); + + sha256_hmac_final (&sha256_hmac_ctx2); + + u32 digest[8]; + + digest[0] = sha256_hmac_ctx2.opad.h[0]; + digest[1] = sha256_hmac_ctx2.opad.h[1]; + digest[2] = sha256_hmac_ctx2.opad.h[2]; + digest[3] = sha256_hmac_ctx2.opad.h[3]; + digest[4] = sha256_hmac_ctx2.opad.h[4]; + digest[5] = sha256_hmac_ctx2.opad.h[5]; + digest[6] = sha256_hmac_ctx2.opad.h[6]; + digest[7] = sha256_hmac_ctx2.opad.h[7]; + + #if defined IS_CUDA || defined IS_HIP + const uint4 tmp0 = make_uint4 (digest[0], digest[1], digest[2], digest[3]); + const uint4 tmp1 = make_uint4 (digest[4], digest[5], digest[6], digest[7]); + #else + const uint4 tmp0 = (uint4) (digest[0], digest[1], digest[2], digest[3]); + const uint4 tmp1 = (uint4) (digest[4], digest[5], digest[6], digest[7]); + #endif + + tmps[gid].P[k + 0] = tmp0; + tmps[gid].P[k + 1] = tmp1; + } + + for (u32 l = 0; l < SCRYPT_CNT4; l += 4) + { + uint4 T[4]; + + T[0] = tmps[gid].P[l + 0]; + T[1] = tmps[gid].P[l + 1]; + T[2] = tmps[gid].P[l + 2]; + T[3] = tmps[gid].P[l + 3]; + + T[0] = hc_swap32_4 (T[0]); + T[1] = hc_swap32_4 (T[1]); + T[2] = hc_swap32_4 (T[2]); + T[3] = hc_swap32_4 (T[3]); + + uint4 X[4]; + + #if defined IS_CUDA || defined IS_HIP + X[0] = make_uint4 (T[0].x, T[1].y, T[2].z, T[3].w); + X[1] = make_uint4 (T[1].x, T[2].y, T[3].z, T[0].w); + X[2] = make_uint4 (T[2].x, T[3].y, T[0].z, T[1].w); + X[3] = make_uint4 (T[3].x, T[0].y, T[1].z, T[2].w); + #else + X[0] = (uint4) (T[0].x, T[1].y, T[2].z, T[3].w); + X[1] = (uint4) (T[1].x, T[2].y, T[3].z, T[0].w); + X[2] = (uint4) (T[2].x, T[3].y, T[0].z, T[1].w); + X[3] = (uint4) (T[3].x, T[0].y, T[1].z, T[2].w); + #endif + + tmps[gid].P[l + 0] = X[0]; + tmps[gid].P[l + 1] = X[1]; + tmps[gid].P[l + 2] = X[2]; + tmps[gid].P[l + 3] = X[3]; + } +} + +KERNEL_FQ void m29800_loop_prepare (KERN_ATTR_TMPS (scrypt_tmp_t)) +{ + /** + * base + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + // SCRYPT part, init V + + GLOBAL_AS uint4 *d_scrypt0_buf = (GLOBAL_AS uint4 *) d_extra0_buf; + GLOBAL_AS uint4 *d_scrypt1_buf = (GLOBAL_AS uint4 *) d_extra1_buf; + GLOBAL_AS uint4 *d_scrypt2_buf = (GLOBAL_AS uint4 *) d_extra2_buf; + GLOBAL_AS uint4 *d_scrypt3_buf = (GLOBAL_AS uint4 *) d_extra3_buf; + + uint4 X[STATE_CNT4]; + + const u32 P_offset = SALT_REPEAT * STATE_CNT4; + + GLOBAL_AS uint4 *P = tmps[gid].P + P_offset; + + for (int z = 0; z < STATE_CNT4; z++) X[z] = P[z]; + + scrypt_smix_init (X, d_scrypt0_buf, d_scrypt1_buf, d_scrypt2_buf, d_scrypt3_buf, gid); + + for (int z = 0; z < STATE_CNT4; z++) P[z] = X[z]; +} + +KERNEL_FQ void m29800_loop (KERN_ATTR_TMPS (scrypt_tmp_t)) +{ + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + GLOBAL_AS uint4 *d_scrypt0_buf = (GLOBAL_AS uint4 *) d_extra0_buf; + GLOBAL_AS uint4 *d_scrypt1_buf = (GLOBAL_AS uint4 *) d_extra1_buf; + GLOBAL_AS uint4 *d_scrypt2_buf = (GLOBAL_AS uint4 *) d_extra2_buf; + GLOBAL_AS uint4 *d_scrypt3_buf = (GLOBAL_AS uint4 *) d_extra3_buf; + + uint4 X[STATE_CNT4]; + + const u32 P_offset = SALT_REPEAT * STATE_CNT4; + + GLOBAL_AS uint4 *P = tmps[gid].P + P_offset; + + for (int z = 0; z < STATE_CNT4; z++) X[z] = P[z]; + + scrypt_smix_loop (X, d_scrypt0_buf, d_scrypt1_buf, d_scrypt2_buf, d_scrypt3_buf, gid); + + for (int z = 0; z < STATE_CNT4; z++) P[z] = X[z]; +} + +KERNEL_FQ void m29800_comp (KERN_ATTR_TMPS (scrypt_tmp_t)) +{ + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * aes shared + */ + + #ifdef REAL_SHM + + LOCAL_VK u32 s_td0[256]; + LOCAL_VK u32 s_td1[256]; + LOCAL_VK u32 s_td2[256]; + LOCAL_VK u32 s_td3[256]; + LOCAL_VK u32 s_td4[256]; + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_td0[i] = td0[i]; + s_td1[i] = td1[i]; + s_td2[i] = td2[i]; + s_td3[i] = td3[i]; + s_td4[i] = td4[i]; + + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS (); + + #else + + CONSTANT_AS u32a *s_td0 = td0; + CONSTANT_AS u32a *s_td1 = td1; + CONSTANT_AS u32a *s_td2 = td2; + CONSTANT_AS u32a *s_td3 = td3; + CONSTANT_AS u32a *s_td4 = td4; + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + + #endif + + if (gid >= GID_CNT) return; + + /** + * 2nd pbkdf2, creates B + */ + + u32 w[128] = { 0 }; + + hc_enc_t hc_enc; + + hc_enc_init (&hc_enc); + + const int w_len = hc_enc_next_global (&hc_enc, pws[gid].i, pws[gid].pw_len, 256, w, sizeof (w)); + + if (w_len == -1) return; + + // utf16le to utf16be + + for (int i = 0, j = 0; i < w_len; i += 4, j += 1) + { + w[j] = ((w[j] >> 8) & 0x00ff00ff) + | ((w[j] << 8) & 0xff00ff00); + } + + sha256_hmac_ctx_t ctx; + + sha256_hmac_init_swap (&ctx, w, w_len); + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + for (u32 l = 0; l < SCRYPT_CNT4; l += 4) + { + uint4 X[4]; + + X[0] = tmps[gid].P[l + 0]; + X[1] = tmps[gid].P[l + 1]; + X[2] = tmps[gid].P[l + 2]; + X[3] = tmps[gid].P[l + 3]; + + uint4 T[4]; + + #if defined IS_CUDA || defined IS_HIP + T[0] = make_uint4 (X[0].x, X[3].y, X[2].z, X[1].w); + T[1] = make_uint4 (X[1].x, X[0].y, X[3].z, X[2].w); + T[2] = make_uint4 (X[2].x, X[1].y, X[0].z, X[3].w); + T[3] = make_uint4 (X[3].x, X[2].y, X[1].z, X[0].w); + #else + T[0] = (uint4) (X[0].x, X[3].y, X[2].z, X[1].w); + T[1] = (uint4) (X[1].x, X[0].y, X[3].z, X[2].w); + T[2] = (uint4) (X[2].x, X[1].y, X[0].z, X[3].w); + T[3] = (uint4) (X[3].x, X[2].y, X[1].z, X[0].w); + #endif + + T[0] = hc_swap32_4 (T[0]); + T[1] = hc_swap32_4 (T[1]); + T[2] = hc_swap32_4 (T[2]); + T[3] = hc_swap32_4 (T[3]); + + w0[0] = T[0].x; + w0[1] = T[0].y; + w0[2] = T[0].z; + w0[3] = T[0].w; + w1[0] = T[1].x; + w1[1] = T[1].y; + w1[2] = T[1].z; + w1[3] = T[1].w; + w2[0] = T[2].x; + w2[1] = T[2].y; + w2[2] = T[2].z; + w2[3] = T[2].w; + w3[0] = T[3].x; + w3[1] = T[3].y; + w3[2] = T[3].z; + w3[3] = T[3].w; + + sha256_hmac_update_64 (&ctx, w0, w1, w2, w3, 64); + } + + w0[0] = 1; + w0[1] = 0; + w0[2] = 0; + w0[3] = 0; + w1[0] = 0; + w1[1] = 0; + w1[2] = 0; + w1[3] = 0; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + sha256_hmac_update_64 (&ctx, w0, w1, w2, w3, 4); + + sha256_hmac_final (&ctx); + + // AES256-CBC decrypt + + u32 key[8]; + + key[0] = ctx.opad.h[0]; + key[1] = ctx.opad.h[1]; + key[2] = ctx.opad.h[2]; + key[3] = ctx.opad.h[3]; + key[4] = ctx.opad.h[4]; + key[5] = ctx.opad.h[5]; + key[6] = ctx.opad.h[6]; + key[7] = ctx.opad.h[7]; + + #define KEYLEN 60 + + u32 ks[KEYLEN]; + + AES256_set_decrypt_key (ks, key, s_te0, s_te1, s_te2, s_te3, s_td0, s_td1, s_td2, s_td3); + + u32 iv[4]; + + iv[0] = salt_bufs[SALT_POS_HOST].salt_buf[2]; + iv[1] = salt_bufs[SALT_POS_HOST].salt_buf[3]; + iv[2] = salt_bufs[SALT_POS_HOST].salt_buf[4]; + iv[3] = salt_bufs[SALT_POS_HOST].salt_buf[5]; + + u32 enc[4]; + + enc[0] = salt_bufs[SALT_POS_HOST].salt_buf[6]; + enc[1] = salt_bufs[SALT_POS_HOST].salt_buf[7]; + enc[2] = salt_bufs[SALT_POS_HOST].salt_buf[8]; + enc[3] = salt_bufs[SALT_POS_HOST].salt_buf[9]; + + u32 dec[4]; + + aes256_decrypt (ks, enc, dec, s_td0, s_td1, s_td2, s_td3, s_td4); + + dec[0] ^= iv[0]; + dec[1] ^= iv[1]; + dec[2] ^= iv[2]; + dec[3] ^= iv[3]; + + if ((dec[0] == 0x10101010) && + (dec[1] == 0x10101010) && + (dec[2] == 0x10101010) && + (dec[3] == 0x10101010)) + { + if (hc_atomic_inc (&hashes_shown[DIGESTS_OFFSET_HOST]) == 0) + { + mark_hash (plains_buf, d_return_buf, SALT_POS_HOST, DIGESTS_CNT, 0, DIGESTS_OFFSET_HOST + 0, gid, 0, 0, 0); + } + + return; + } +} From 33a5ff2d40a0cd9a6e895eef1673d86c9f2e4cb1 Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:24:04 +0200 Subject: [PATCH 3/8] Create module_29800.c --- src/modules/module_29800.c | 490 +++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 src/modules/module_29800.c diff --git a/src/modules/module_29800.c b/src/modules/module_29800.c new file mode 100644 index 000000000..8ed6405bf --- /dev/null +++ b/src/modules/module_29800.c @@ -0,0 +1,490 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#include +#include "common.h" +#include "types.h" +#include "modules.h" +#include "bitops.h" +#include "convert.h" +#include "shared.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_OUTSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 1; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 3; +static const u32 DGST_SIZE = DGST_SIZE_4_4; +static const u32 HASH_CATEGORY = HASH_CATEGORY_CRYPTOCURRENCY_WALLET; +static const char *HASH_NAME = "Bisq .wallet (scrypt)"; +static const u64 KERN_TYPE = 29800; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_MP_MULTI_DISABLE + | OPTS_TYPE_NATIVE_THREADS + | OPTS_TYPE_LOOP_PREPARE + | OPTS_TYPE_SELF_TEST_DISABLE; +static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; +static const char *ST_PASS = "hashcat1"; +static const char *ST_HASH = "$bisq$3*32768*8*6*31d838af87f99cb8*5cfb7bf3228d9e865881156e17b1866589ffa6b757011e25d1319083595236d2"; + +u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } +u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } +u32 module_dgst_pos1 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1; } +u32 module_dgst_pos2 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2; } +u32 module_dgst_pos3 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3; } +u32 module_dgst_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE; } +u32 module_hash_category (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY; } +const char *module_hash_name (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME; } +u64 module_kern_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE; } +u32 module_opti_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE; } +u64 module_opts_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE; } +u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE; } +const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } +const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } + +static const char *SIGNATURE_BISQ = "$bisq$"; + +static const u64 SCRYPT_N = 32768; +static const u64 SCRYPT_R = 8; +static const u64 SCRYPT_P = 6; + +bool module_unstable_warning (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hc_device_param_t *device_param) +{ + // AMD Radeon Pro W5700X Compute Engine; 1.2 (Apr 22 2021 21:54:44); 11.3.1; 20E241 + if ((device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE) && (device_param->opencl_device_type & CL_DEVICE_TYPE_GPU)) + { + return true; + } + + return false; +} + +u32 module_kernel_loops_min (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const u32 kernel_loops_min = 1024; + + return kernel_loops_min; +} + +u32 module_kernel_loops_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const u32 kernel_loops_max = 1024; + + return kernel_loops_max; +} + +u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + // this overrides the reductions of PW_MAX in case optimized kernel is selected + // IOW, even in optimized kernel mode it support length 256 + + const u32 pw_max = PW_MAX; + + return pw_max; +} + +u64 module_extra_buffer_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param) +{ + // we need to set the self-test hash settings to pass the self-test + // the decoder for the self-test is called after this function + + const u64 scrypt_N = (hashes->salts_buf[0].scrypt_N) ? hashes->salts_buf[0].scrypt_N : SCRYPT_N; + const u64 scrypt_r = (hashes->salts_buf[0].scrypt_r) ? hashes->salts_buf[0].scrypt_r : SCRYPT_R; + + const u64 kernel_power_max = ((OPTS_TYPE & OPTS_TYPE_MP_MULTI_DISABLE) ? 1 : device_param->device_processors) * device_param->kernel_threads_max * device_param->kernel_accel_max; + + u64 tmto_start = 0; + u64 tmto_stop = 4; + + if (user_options->scrypt_tmto_chgd == true) + { + tmto_start = user_options->scrypt_tmto; + tmto_stop = user_options->scrypt_tmto; + } + + // size_pws + + const u64 size_pws = kernel_power_max * sizeof (pw_t); + + const u64 size_pws_amp = size_pws; + + // size_pws_comp + + const u64 size_pws_comp = kernel_power_max * (sizeof (u32) * 64); + + // size_pws_idx + + const u64 size_pws_idx = (kernel_power_max + 1) * sizeof (pw_idx_t); + + // size_tmps + + const u64 size_tmps = kernel_power_max * hashconfig->tmp_size; + + // size_hooks + + const u64 size_hooks = kernel_power_max * hashconfig->hook_size; + + u64 size_pws_pre = 4; + u64 size_pws_base = 4; + + if (user_options->slow_candidates == true) + { + // size_pws_pre + + size_pws_pre = kernel_power_max * sizeof (pw_pre_t); + + // size_pws_base + + size_pws_base = kernel_power_max * sizeof (pw_pre_t); + } + + // sometimes device_available_mem and device_maxmem_alloc reported back from the opencl runtime are a bit inaccurate. + // let's add some extra space just to be sure. + // now depends on the kernel-accel value (where scrypt and similar benefits), but also hard minimum 64mb and maximum 1024mb limit + + u64 EXTRA_SPACE = (1024ULL * 1024ULL) * device_param->kernel_accel_max; + + EXTRA_SPACE = MAX (EXTRA_SPACE, ( 64ULL * 1024ULL * 1024ULL)); + EXTRA_SPACE = MIN (EXTRA_SPACE, (1024ULL * 1024ULL * 1024ULL)); + + const u64 scrypt_extra_space + = device_param->size_bfs + + device_param->size_combs + + device_param->size_digests + + device_param->size_esalts + + device_param->size_markov_css + + device_param->size_plains + + device_param->size_results + + device_param->size_root_css + + device_param->size_rules + + device_param->size_rules_c + + device_param->size_salts + + device_param->size_shown + + device_param->size_tm + + device_param->size_st_digests + + device_param->size_st_salts + + device_param->size_st_esalts + + size_pws + + size_pws_amp + + size_pws_comp + + size_pws_idx + + size_tmps + + size_hooks + + size_pws_pre + + size_pws_base + + EXTRA_SPACE; + + bool not_enough_memory = true; + + u64 size_scrypt = 0; + + u64 tmto; + + for (tmto = tmto_start; tmto <= tmto_stop; tmto++) + { + size_scrypt = (128ULL * scrypt_r) * scrypt_N; + + size_scrypt /= 1ull << tmto; + + size_scrypt *= kernel_power_max; + + if ((size_scrypt / 4) > device_param->device_maxmem_alloc) continue; + + if ((size_scrypt + scrypt_extra_space) > device_param->device_available_mem) continue; + + not_enough_memory = false; + + break; + } + + if (not_enough_memory == true) return -1; + + return size_scrypt; +} + +u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const u64 tmp_size = 0; // we'll add some later + + return tmp_size; +} + +u64 module_extra_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes) +{ + const u64 scrypt_N = (hashes->salts_buf[0].scrypt_N) ? hashes->salts_buf[0].scrypt_N : SCRYPT_N; + const u64 scrypt_r = (hashes->salts_buf[0].scrypt_r) ? hashes->salts_buf[0].scrypt_r : SCRYPT_R; + const u64 scrypt_p = (hashes->salts_buf[0].scrypt_p) ? hashes->salts_buf[0].scrypt_p : SCRYPT_P; + + // we need to check that all hashes have the same scrypt settings + + for (u32 i = 1; i < hashes->salts_cnt; i++) + { + if ((hashes->salts_buf[i].scrypt_N != scrypt_N) + || (hashes->salts_buf[i].scrypt_r != scrypt_r) + || (hashes->salts_buf[i].scrypt_p != scrypt_p)) + { + return -1; + } + } + + const u64 tmp_size = 128ULL * scrypt_r * scrypt_p; + + return tmp_size; +} + +bool module_warmup_disable (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + return true; +} + +char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param) +{ + const u64 scrypt_N = (hashes->salts_buf[0].scrypt_N) ? hashes->salts_buf[0].scrypt_N : SCRYPT_N; + const u64 scrypt_r = (hashes->salts_buf[0].scrypt_r) ? hashes->salts_buf[0].scrypt_r : SCRYPT_R; + const u64 scrypt_p = (hashes->salts_buf[0].scrypt_p) ? hashes->salts_buf[0].scrypt_p : SCRYPT_P; + + const u64 extra_buffer_size = device_param->extra_buffer_size; + + const u64 kernel_power_max = ((OPTS_TYPE & OPTS_TYPE_MP_MULTI_DISABLE) ? 1 : device_param->device_processors) * device_param->kernel_threads_max * device_param->kernel_accel_max; + + const u64 size_scrypt = 128ULL * scrypt_r * scrypt_N; + + const u64 scrypt_tmto_final = (kernel_power_max * size_scrypt) / extra_buffer_size; + + const u64 tmp_size = 128ULL * scrypt_r * scrypt_p; + + char *jit_build_options = NULL; + + hc_asprintf (&jit_build_options, "-D SCRYPT_N=%u -D SCRYPT_R=%u -D SCRYPT_P=%u -D SCRYPT_TMTO=%" PRIu64 " -D SCRYPT_TMP_ELEM=%" PRIu64, + hashes->salts_buf[0].scrypt_N, + hashes->salts_buf[0].scrypt_r, + hashes->salts_buf[0].scrypt_p, + scrypt_tmto_final, + tmp_size / 16); + + return jit_build_options; +} + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + u32 *digest = (u32 *) digest_buf; + + hc_token_t token; + + token.token_cnt = 7; + + token.signatures_cnt = 1; + token.signatures_buf[0] = SIGNATURE_BISQ; + + token.len[0] = 6; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_SIGNATURE; + + token.len_min[1] = 1; + token.len_max[1] = 1; + token.sep[1] = '*'; + token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_DIGIT; + + token.len_min[2] = 1; + token.len_max[2] = 10; + token.sep[2] = '*'; + token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_DIGIT; + + token.len_min[3] = 1; + token.len_max[3] = 2; + token.sep[3] = '*'; + token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_DIGIT; + + token.len_min[4] = 1; + token.len_max[4] = 1; + token.sep[4] = '*'; + token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_DIGIT; + + token.len_min[5] = 16; + token.len_max[5] = 16; + token.sep[5] = '*'; + token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + token.len[6] = 64; + token.attr[6] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); + + if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); + + // version + + const u8 *version_pos = token.buf[1]; + + if (version_pos[0] != (u8) '3') return (PARSER_SIGNATURE_UNMATCHED); + + // scrypt settings + + const u8 *scrypt_n_pos = token.buf[2]; + + const u32 scrypt_n = hc_strtoul ((const char *) scrypt_n_pos, NULL, 10); + + const u8 *scrypt_r_pos = token.buf[3]; + + const u32 scrypt_r = hc_strtoul ((const char *) scrypt_r_pos, NULL, 10); + + const u8 *scrypt_p_pos = token.buf[4]; + + const u32 scrypt_p = hc_strtoul ((const char *) scrypt_p_pos, NULL, 10); + + salt->scrypt_N = scrypt_n; + salt->scrypt_r = scrypt_r; + salt->scrypt_p = scrypt_p; + + salt->salt_iter = salt->scrypt_N; + salt->salt_repeats = salt->scrypt_p - 1; + + // salt + + const u8 *salt_pos = token.buf[5]; + + salt->salt_buf[0] = hex_to_u32 (salt_pos + 0); + salt->salt_buf[1] = hex_to_u32 (salt_pos + 8); + + salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]); // swap the salt (only the salt) + salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]); + + // IV + + const u8 *blob_pos = token.buf[6]; + + salt->salt_buf[2] = hex_to_u32 (blob_pos + 0); + salt->salt_buf[3] = hex_to_u32 (blob_pos + 8); + salt->salt_buf[4] = hex_to_u32 (blob_pos + 16); + salt->salt_buf[5] = hex_to_u32 (blob_pos + 24); + + // data + + salt->salt_buf[6] = hex_to_u32 (blob_pos + 32); + salt->salt_buf[7] = hex_to_u32 (blob_pos + 40); + salt->salt_buf[8] = hex_to_u32 (blob_pos + 48); + salt->salt_buf[9] = hex_to_u32 (blob_pos + 56); + + salt->salt_len = 40; + + // fake digest: + + digest[0] = salt->salt_buf[4]; + digest[1] = salt->salt_buf[5]; + digest[2] = salt->salt_buf[6]; + digest[3] = salt->salt_buf[7]; + + return (PARSER_OK); +} + +int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) +{ + const int line_len = snprintf (line_buf, line_size, "%s%u*%u*%u*%u*%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", + SIGNATURE_BISQ, + 3, + salt->scrypt_N, + salt->scrypt_r, + salt->scrypt_p, + salt->salt_buf[0], + salt->salt_buf[1], + byte_swap_32 (salt->salt_buf[2]), + byte_swap_32 (salt->salt_buf[3]), + byte_swap_32 (salt->salt_buf[4]), + byte_swap_32 (salt->salt_buf[5]), + byte_swap_32 (salt->salt_buf[6]), + byte_swap_32 (salt->salt_buf[7]), + byte_swap_32 (salt->salt_buf[8]), + byte_swap_32 (salt->salt_buf[9])); + + return line_len; +} + +void module_init (module_ctx_t *module_ctx) +{ + module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; + module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; + + module_ctx->module_attack_exec = module_attack_exec; + module_ctx->module_benchmark_esalt = MODULE_DEFAULT; + module_ctx->module_benchmark_hook_salt = MODULE_DEFAULT; + module_ctx->module_benchmark_mask = MODULE_DEFAULT; + module_ctx->module_benchmark_charset = MODULE_DEFAULT; + module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; + module_ctx->module_deprecated_notice = MODULE_DEFAULT; + module_ctx->module_dgst_pos0 = module_dgst_pos0; + module_ctx->module_dgst_pos1 = module_dgst_pos1; + module_ctx->module_dgst_pos2 = module_dgst_pos2; + module_ctx->module_dgst_pos3 = module_dgst_pos3; + module_ctx->module_dgst_size = module_dgst_size; + module_ctx->module_dictstat_disable = MODULE_DEFAULT; + module_ctx->module_esalt_size = MODULE_DEFAULT; + module_ctx->module_extra_buffer_size = module_extra_buffer_size; + module_ctx->module_extra_tmp_size = module_extra_tmp_size; + module_ctx->module_extra_tuningdb_block = MODULE_DEFAULT; + module_ctx->module_forced_outfile_format = MODULE_DEFAULT; + module_ctx->module_hash_binary_count = MODULE_DEFAULT; + module_ctx->module_hash_binary_parse = MODULE_DEFAULT; + module_ctx->module_hash_binary_save = MODULE_DEFAULT; + module_ctx->module_hash_decode_postprocess = MODULE_DEFAULT; + module_ctx->module_hash_decode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = module_jit_build_options; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = module_kernel_loops_max; + module_ctx->module_kernel_loops_min = module_kernel_loops_min; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = module_pw_max; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = MODULE_DEFAULT; + module_ctx->module_salt_min = MODULE_DEFAULT; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = module_tmp_size; + module_ctx->module_unstable_warning = module_unstable_warning; + module_ctx->module_warmup_disable = module_warmup_disable; +} From 72d11fd0739bf004080b57765b6ac567104843e9 Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:25:09 +0200 Subject: [PATCH 4/8] Create m29800.pm --- tools/test_modules/m29800.pm | 135 +++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 tools/test_modules/m29800.pm diff --git a/tools/test_modules/m29800.pm b/tools/test_modules/m29800.pm new file mode 100644 index 000000000..96cc43c35 --- /dev/null +++ b/tools/test_modules/m29800.pm @@ -0,0 +1,135 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Crypt::ScryptKDF qw (scrypt_raw); +use Encode; +use Crypt::CBC; + +sub module_constraints { [[0, 256], [8, 8], [-1, -1], [-1, -1], [-1, -1]] } + +my $SCRYPT_N = 32768; +my $SCRYPT_R = 8; +my $SCRYPT_P = 6; + +my $DATA_FIXED = "\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10"; + +sub module_generate_hash +{ + my $word = shift; + my $salt = shift; + my $iv = shift // random_bytes (16); + my $data = shift; + + my $word_utf16be = encode ('UTF-16BE', $word); + + my $key = scrypt_raw ($word_utf16be, $salt, $SCRYPT_N, $SCRYPT_R, $SCRYPT_P, 32); + + my $aes_cbc = Crypt::CBC->new ({ + cipher => "Crypt::Rijndael", + iv => $iv, + key => $key, + keysize => 32, + literal_key => 1, + header => "none", + padding => "none" + }); + + my $data_block = ""; + + if (defined ($data)) # verify + { + my $data_dec = $aes_cbc->decrypt ($data); + + if ($data_dec eq $DATA_FIXED) + { + $data_block = $data; + } + } + else + { + $data = $DATA_FIXED; + + $data_block = $aes_cbc->encrypt ($data); + } + + my $hash = sprintf ("\$bisq\$3*%d*%d*%d*%s*%s", $SCRYPT_N, $SCRYPT_R, $SCRYPT_P, unpack ("H*", $salt), unpack ("H*", $iv . $data_block)); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + return unless (substr ($line, 0, 8) eq '$bisq$3*'); + + # split hash and word: + + my $idx1 = index ($line, ":", 12); + + return if ($idx1 < 1); + + my $hash = substr ($line, 0, $idx1); + my $word = substr ($line, $idx1 + 1); + + # scrypt parameters: + + my $idx2 = index ($hash, "*", 12); + + return if ($idx2 < 0); + + my $scrypt_n = substr ($hash, 12, $idx2 - 12); + + $idx1 = index ($hash, "*", $idx2 + 1); + + return if ($idx1 < 0); + + my $scrypt_r = substr ($hash, $idx2 + 1, $idx1 - $idx2 - 1); + + $idx2 = index ($hash, "*", $idx1 + 1); + + return if ($idx2 < 0); + + my $scrypt_p = substr ($hash, $idx1 + 1, $idx2 - $idx1 - 1); + + # salt: + + $idx1 = index ($hash, "*", $idx2 + 1); + + return if ($idx1 < 0); + + my $salt = substr ($hash, $idx2 + 1, $idx1 - $idx2 - 1); + + # IV: + + my $iv = substr ($hash, $idx1 + 1, 32); + + # data: + + my $data = substr ($hash, $idx1 + 1 + 32, 32); + + return unless $salt =~ m/^[0-9a-fA-F]{16}$/; + return unless $iv =~ m/^[0-9a-fA-F]{32}$/; + return unless $data =~ m/^[0-9a-fA-F]{32}$/; + + # hex to binary/raw: + + $salt = pack ("H*", $salt); + $iv = pack ("H*", $iv); + $data = pack ("H*", $data); + + $word = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word, $salt, $iv, $data); + + return ($new_hash, $word); +} + +1; From cf7521ef9fd82dd3f3ffea93fba43812cef28ccf Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:26:41 +0200 Subject: [PATCH 5/8] Update changes.txt --- docs/changes.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/changes.txt b/docs/changes.txt index b2e4c721d..01aef0566 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -1,5 +1,11 @@ * changes v6.2.6 -> v6.2.x +## +## Algorithms +## + +- Added hash-mode: Bisq .wallet (scrypt) + ## ## Technical ## From 20afb3ca553e6a1d8596a2ec1bba0288d1515c67 Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 16:28:08 +0200 Subject: [PATCH 6/8] Update readme.txt --- docs/readme.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/readme.txt b/docs/readme.txt index 5322facec..7b8982833 100644 --- a/docs/readme.txt +++ b/docs/readme.txt @@ -422,6 +422,7 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or - MultiBit HD (scrypt) - Exodus Desktop Wallet (scrypt) - Terra Station Wallet (AES256-CBC(PBKDF2($pass))) +- Bisq .wallet (scrypt) ## ## Attack-Modes From 303945f73c29a85881b4279dd48f8caa16dff3dd Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 21:40:50 +0200 Subject: [PATCH 7/8] Create bisq2hashcat.py --- tools/bisq2hashcat.py | 127 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 tools/bisq2hashcat.py diff --git a/tools/bisq2hashcat.py b/tools/bisq2hashcat.py new file mode 100644 index 000000000..253d33f07 --- /dev/null +++ b/tools/bisq2hashcat.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python + +# This software is Copyright (c) 2017, Dhiru Kholia +# and it is hereby released under GPL v2 license. +# +# Major parts are borrowed from the "btcrecover" program which is, +# Copyright (C) 2014-2016 Christopher Gurnee and under GPL v2. +# +# See https://github.com/gurnec/btcrecover for details. +# +# References, +# +# https://github.com/gurnec/btcrecover/blob/master/btcrecover/btcrpass.py +# + +# Updated script in order to work with Bisq wallet v1.9.5 (2022) +# Author: +# https://github.com/Banaanhangwagen +# License: MIT + +import os +import sys +import base64 +import binascii + +# The protobuf parsing code is borrowed from btcrecover, and was +# initially automatically generated by Google's protoc utility. +# The precompiled file is shipped in protobuf/wallet_pb2.py with John. +from protobuf.wallet_pb2 import * + + +def process_file(filename): + bname = os.path.basename(filename) + try: + f = open(filename, "rb") + data = f.read() + except IOError: + e = sys.exc_info()[1] + sys.stderr.write("%s\n" % str(e)) + return + + if "wallet" in bname or b"org.bitcoin.production" in data: + # sys.stderr.write("[WARNING] Cracking .wallet files is a very slow process, try cracking the associated .key file instead!\n") + version = 3 # MultiBit Classic .wallet file + # def is_wallet_file(wallet_file) from btcrecover + wallet_file = open(filename, "rb") + wallet_file.seek(0) + is_valid_bitcoinj_wallet = False + if wallet_file.read(1) == b"\x0a": # protobuf field number 1 of type length-delimited + network_identifier_len = ord(wallet_file.read(1)) + if 1 <= network_identifier_len < 128: + wallet_file.seek(2 + network_identifier_len) + c = wallet_file.read(1) + if c and c in b"\x12\x1a": # field number 2 or 3 of type length-delimited + is_valid_bitcoinj_wallet = True + if is_valid_bitcoinj_wallet: + pb_wallet = Wallet() + pb_wallet.ParseFromString(data) + if pb_wallet.encryption_type == Wallet.UNENCRYPTED: + raise ValueError("bitcoinj wallet is not encrypted") + if pb_wallet.encryption_type != Wallet.ENCRYPTED_SCRYPT_AES: + raise NotImplementedError("Unsupported bitcoinj encryption type " + str(pb_wallet.encryption_type)) + if not pb_wallet.HasField("encryption_parameters"): + raise ValueError("bitcoinj wallet is missing its scrypt encryption parameters") + for key in pb_wallet.key: + if key.type in (Key.ENCRYPTED_SCRYPT_AES, Key.DETERMINISTIC_KEY) and key.HasField("encrypted_data"): + encrypted_len = len(key.encrypted_data.encrypted_private_key) + if encrypted_len == 48: + # only need the final 2 encrypted blocks (half of it padding) plus the scrypt parameters + part_encrypted_key = key.encrypted_data.encrypted_private_key[-32:] + salt = pb_wallet.encryption_parameters.salt + n = pb_wallet.encryption_parameters.n + r = pb_wallet.encryption_parameters.r + p = pb_wallet.encryption_parameters.p + encrypted_data = binascii.hexlify(part_encrypted_key).decode("ascii") + salt = binascii.hexlify(salt).decode("ascii") + sys.stdout.write("%s:$bisq$%d*%s*%s*%s*%s*%s\n" % (bname, version, n, r, p, salt, encrypted_data)) + return + return + + pdata = b"".join(data.split()) + if len(pdata) < 64: + sys.stderr.write("%s: Short length for a bisq wallet file!\n" % bname) + return + + try: + pdata = base64.b64decode(pdata[:64]) + + if pdata.startswith(b"Salted__"): + version = 1 # MultiBit Classic + else: + version = 2 # MultiBit HD possibly? We need more tests! + except: + version = 2 # MultiBit HD possibly? + + if version == 1: + encrypted_data = pdata[16:48] # two AES blocks + salt = pdata[8:16] + encrypted_data = binascii.hexlify(encrypted_data).decode("ascii") + salt = binascii.hexlify(salt).decode("ascii") + sys.stdout.write("%s:$bisq$%d*%s*%s\n" % (bname, version, salt, encrypted_data)) + return + else: + version = 2 + # sanity check but not a very good one + if "wallet" not in bname and "aes" not in bname: + sys.stderr.write("%s: Make sure that this is a Bisq wallet!\n" % bname) + # two possibilities + iv = data[:16] # v0.5.0+ + block_iv = data[16:32] # v0.5.0+ + block_noiv = data[:16] # encrypted using hardcoded iv, < v0.5.0 + iv = binascii.hexlify(iv).decode("ascii") + block_iv = binascii.hexlify(block_iv).decode("ascii") + block_noiv = binascii.hexlify(block_noiv).decode("ascii") + sys.stdout.write("%s:$bisq$%d*%s*%s*%s\n" % (bname, version, iv, block_iv, block_noiv)) + return + + f.close() + +if __name__ == "__main__": + if len(sys.argv) < 2: + sys.stderr.write("Usage: %s [Bisq wallet file (.wallet)]\n" % sys.argv[0]) + # sys.stderr.write("\nMultiBit Classic -> for a wallet named 'xyz', we need the xyz-data/key-backup/xyz*.key OR xyz-data/wallet-backup/xyz*.wallet file\n") + sys.exit(1) + + for j in range(1, len(sys.argv)): + process_file(sys.argv[j]) From 327b28abfd762bef501998768937de68896c16ea Mon Sep 17 00:00:00 2001 From: Banaanhangwagen Date: Fri, 16 Sep 2022 21:41:44 +0200 Subject: [PATCH 8/8] Create wallet_pb2.py --- tools/protobuf/wallet_pb2.py | 1271 ++++++++++++++++++++++++++++++++++ 1 file changed, 1271 insertions(+) create mode 100644 tools/protobuf/wallet_pb2.py diff --git a/tools/protobuf/wallet_pb2.py b/tools/protobuf/wallet_pb2.py new file mode 100644 index 000000000..0bc0105b5 --- /dev/null +++ b/tools/protobuf/wallet_pb2.py @@ -0,0 +1,1271 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: wallet.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +try: + from google.protobuf import descriptor as _descriptor + from google.protobuf import message as _message + from google.protobuf import reflection as _reflection + from google.protobuf import symbol_database as _symbol_database + from google.protobuf import descriptor_pb2 +except ImportError: + sys.stderr.write("Install the missing protobuf package, use 'pip install protobuf' command to do so.\n") + sys.exit(1) +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + +DESCRIPTOR = _descriptor.FileDescriptor( + name='wallet.proto', + package='wallet', + serialized_pb=_b('\n\x0cwallet.proto\x12\x06wallet\"A\n\x0bPeerAddress\x12\x12\n\nip_address\x18\x01 \x02(\x0c\x12\x0c\n\x04port\x18\x02 \x02(\r\x12\x10\n\x08services\x18\x03 \x02(\x04\"M\n\rEncryptedData\x12\x1d\n\x15initialisation_vector\x18\x01 \x02(\x0c\x12\x1d\n\x15\x65ncrypted_private_key\x18\x02 \x02(\x0c\"y\n\x10\x44\x65terministicKey\x12\x12\n\nchain_code\x18\x01 \x02(\x0c\x12\x0c\n\x04path\x18\x02 \x03(\r\x12\x16\n\x0eissued_subkeys\x18\x03 \x01(\r\x12\x16\n\x0elookahead_size\x18\x04 \x01(\r\x12\x13\n\x0bisFollowing\x18\x05 \x01(\x08\"\x9a\x03\n\x03Key\x12\x1e\n\x04type\x18\x01 \x02(\x0e\x32\x10.wallet.Key.Type\x12\x14\n\x0csecret_bytes\x18\x02 \x01(\x0c\x12-\n\x0e\x65ncrypted_data\x18\x06 \x01(\x0b\x32\x15.wallet.EncryptedData\x12\x12\n\npublic_key\x18\x03 \x01(\x0c\x12\r\n\x05label\x18\x04 \x01(\t\x12\x1a\n\x12\x63reation_timestamp\x18\x05 \x01(\x03\x12\x33\n\x11\x64\x65terministic_key\x18\x07 \x01(\x0b\x32\x18.wallet.DeterministicKey\x12\x1a\n\x12\x64\x65terministic_seed\x18\x08 \x01(\x0c\x12;\n\x1c\x65ncrypted_deterministic_seed\x18\t \x01(\x0b\x32\x15.wallet.EncryptedData\"a\n\x04Type\x12\x0c\n\x08ORIGINAL\x10\x01\x12\x18\n\x14\x45NCRYPTED_SCRYPT_AES\x10\x02\x12\x1a\n\x16\x44\x45TERMINISTIC_MNEMONIC\x10\x03\x12\x15\n\x11\x44\x45TERMINISTIC_KEY\x10\x04\"5\n\x06Script\x12\x0f\n\x07program\x18\x01 \x02(\x0c\x12\x1a\n\x12\x63reation_timestamp\x18\x02 \x02(\x03\"\x92\x01\n\x10TransactionInput\x12\"\n\x1atransaction_out_point_hash\x18\x01 \x02(\x0c\x12#\n\x1btransaction_out_point_index\x18\x02 \x02(\r\x12\x14\n\x0cscript_bytes\x18\x03 \x02(\x0c\x12\x10\n\x08sequence\x18\x04 \x01(\r\x12\r\n\x05value\x18\x05 \x01(\x03\"\x7f\n\x11TransactionOutput\x12\r\n\x05value\x18\x01 \x02(\x03\x12\x14\n\x0cscript_bytes\x18\x02 \x02(\x0c\x12!\n\x19spent_by_transaction_hash\x18\x03 \x01(\x0c\x12\"\n\x1aspent_by_transaction_index\x18\x04 \x01(\x05\"\x89\x03\n\x15TransactionConfidence\x12\x30\n\x04type\x18\x01 \x01(\x0e\x32\".wallet.TransactionConfidence.Type\x12\x1a\n\x12\x61ppeared_at_height\x18\x02 \x01(\x05\x12\x1e\n\x16overriding_transaction\x18\x03 \x01(\x0c\x12\r\n\x05\x64\x65pth\x18\x04 \x01(\x05\x12)\n\x0c\x62roadcast_by\x18\x06 \x03(\x0b\x32\x13.wallet.PeerAddress\x12\x34\n\x06source\x18\x07 \x01(\x0e\x32$.wallet.TransactionConfidence.Source\"O\n\x04Type\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0c\n\x08\x42UILDING\x10\x01\x12\x0b\n\x07PENDING\x10\x02\x12\x15\n\x11NOT_IN_BEST_CHAIN\x10\x03\x12\x08\n\x04\x44\x45\x41\x44\x10\x04\"A\n\x06Source\x12\x12\n\x0eSOURCE_UNKNOWN\x10\x00\x12\x12\n\x0eSOURCE_NETWORK\x10\x01\x12\x0f\n\x0bSOURCE_SELF\x10\x02\"\xb4\x05\n\x0bTransaction\x12\x0f\n\x07version\x18\x01 \x02(\x05\x12\x0c\n\x04hash\x18\x02 \x02(\x0c\x12&\n\x04pool\x18\x03 \x01(\x0e\x32\x18.wallet.Transaction.Pool\x12\x11\n\tlock_time\x18\x04 \x01(\r\x12\x12\n\nupdated_at\x18\x05 \x01(\x03\x12\x33\n\x11transaction_input\x18\x06 \x03(\x0b\x32\x18.wallet.TransactionInput\x12\x35\n\x12transaction_output\x18\x07 \x03(\x0b\x32\x19.wallet.TransactionOutput\x12\x12\n\nblock_hash\x18\x08 \x03(\x0c\x12 \n\x18\x62lock_relativity_offsets\x18\x0b \x03(\x05\x12\x31\n\nconfidence\x18\t \x01(\x0b\x32\x1d.wallet.TransactionConfidence\x12\x35\n\x07purpose\x18\n \x01(\x0e\x32\x1b.wallet.Transaction.Purpose:\x07UNKNOWN\x12+\n\rexchange_rate\x18\x0c \x01(\x0b\x32\x14.wallet.ExchangeRate\x12\x0c\n\x04memo\x18\r \x01(\t\"Y\n\x04Pool\x12\x0b\n\x07UNSPENT\x10\x04\x12\t\n\x05SPENT\x10\x05\x12\x0c\n\x08INACTIVE\x10\x02\x12\x08\n\x04\x44\x45\x41\x44\x10\n\x12\x0b\n\x07PENDING\x10\x10\x12\x14\n\x10PENDING_INACTIVE\x10\x12\"\x94\x01\n\x07Purpose\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x10\n\x0cUSER_PAYMENT\x10\x01\x12\x10\n\x0cKEY_ROTATION\x10\x02\x12\x1c\n\x18\x41SSURANCE_CONTRACT_CLAIM\x10\x03\x12\x1d\n\x19\x41SSURANCE_CONTRACT_PLEDGE\x10\x04\x12\x1b\n\x17\x41SSURANCE_CONTRACT_STUB\x10\x05\"N\n\x10ScryptParameters\x12\x0c\n\x04salt\x18\x01 \x02(\x0c\x12\x10\n\x01n\x18\x02 \x01(\x03:\x05\x31\x36\x33\x38\x34\x12\x0c\n\x01r\x18\x03 \x01(\x05:\x01\x38\x12\x0c\n\x01p\x18\x04 \x01(\x05:\x01\x31\"8\n\tExtension\x12\n\n\x02id\x18\x01 \x02(\t\x12\x0c\n\x04\x64\x61ta\x18\x02 \x02(\x0c\x12\x11\n\tmandatory\x18\x03 \x02(\x08\" \n\x03Tag\x12\x0b\n\x03tag\x18\x01 \x02(\t\x12\x0c\n\x04\x64\x61ta\x18\x02 \x02(\x0c\"5\n\x11TransactionSigner\x12\x12\n\nclass_name\x18\x01 \x02(\t\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\"\x89\x05\n\x06Wallet\x12\x1a\n\x12network_identifier\x18\x01 \x02(\t\x12\x1c\n\x14last_seen_block_hash\x18\x02 \x01(\x0c\x12\x1e\n\x16last_seen_block_height\x18\x0c \x01(\r\x12!\n\x19last_seen_block_time_secs\x18\x0e \x01(\x03\x12\x18\n\x03key\x18\x03 \x03(\x0b\x32\x0b.wallet.Key\x12(\n\x0btransaction\x18\x04 \x03(\x0b\x32\x13.wallet.Transaction\x12&\n\x0ewatched_script\x18\x0f \x03(\x0b\x32\x0e.wallet.Script\x12\x43\n\x0f\x65ncryption_type\x18\x05 \x01(\x0e\x32\x1d.wallet.Wallet.EncryptionType:\x0bUNENCRYPTED\x12\x37\n\x15\x65ncryption_parameters\x18\x06 \x01(\x0b\x32\x18.wallet.ScryptParameters\x12\x12\n\x07version\x18\x07 \x01(\x05:\x01\x31\x12$\n\textension\x18\n \x03(\x0b\x32\x11.wallet.Extension\x12\x13\n\x0b\x64\x65scription\x18\x0b \x01(\t\x12\x19\n\x11key_rotation_time\x18\r \x01(\x04\x12\x19\n\x04tags\x18\x10 \x03(\x0b\x32\x0b.wallet.Tag\x12\x36\n\x13transaction_signers\x18\x11 \x03(\x0b\x32\x19.wallet.TransactionSigner\x12\x1e\n\x13sigsRequiredToSpend\x18\x12 \x01(\r:\x01\x31\";\n\x0e\x45ncryptionType\x12\x0f\n\x0bUNENCRYPTED\x10\x01\x12\x18\n\x14\x45NCRYPTED_SCRYPT_AES\x10\x02\"R\n\x0c\x45xchangeRate\x12\x12\n\ncoin_value\x18\x01 \x02(\x03\x12\x12\n\nfiat_value\x18\x02 \x02(\x03\x12\x1a\n\x12\x66iat_currency_code\x18\x03 \x02(\tB\x1d\n\x13org.bitcoinj.walletB\x06Protos') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + +_KEY_TYPE = _descriptor.EnumDescriptor( + name='Type', + full_name='wallet.Key.Type', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='ORIGINAL', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ENCRYPTED_SCRYPT_AES', index=1, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DETERMINISTIC_MNEMONIC', index=2, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DETERMINISTIC_KEY', index=3, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=607, + serialized_end=704, +) +_sym_db.RegisterEnumDescriptor(_KEY_TYPE) + +_TRANSACTIONCONFIDENCE_TYPE = _descriptor.EnumDescriptor( + name='Type', + full_name='wallet.TransactionConfidence.Type', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNKNOWN', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BUILDING', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PENDING', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='NOT_IN_BEST_CHAIN', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DEAD', index=4, number=4, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1287, + serialized_end=1366, +) +_sym_db.RegisterEnumDescriptor(_TRANSACTIONCONFIDENCE_TYPE) + +_TRANSACTIONCONFIDENCE_SOURCE = _descriptor.EnumDescriptor( + name='Source', + full_name='wallet.TransactionConfidence.Source', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='SOURCE_UNKNOWN', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SOURCE_NETWORK', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SOURCE_SELF', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1368, + serialized_end=1433, +) +_sym_db.RegisterEnumDescriptor(_TRANSACTIONCONFIDENCE_SOURCE) + +_TRANSACTION_POOL = _descriptor.EnumDescriptor( + name='Pool', + full_name='wallet.Transaction.Pool', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNSPENT', index=0, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='SPENT', index=1, number=5, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INACTIVE', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DEAD', index=3, number=10, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PENDING', index=4, number=16, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='PENDING_INACTIVE', index=5, number=18, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1888, + serialized_end=1977, +) +_sym_db.RegisterEnumDescriptor(_TRANSACTION_POOL) + +_TRANSACTION_PURPOSE = _descriptor.EnumDescriptor( + name='Purpose', + full_name='wallet.Transaction.Purpose', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNKNOWN', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='USER_PAYMENT', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='KEY_ROTATION', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ASSURANCE_CONTRACT_CLAIM', index=3, number=3, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ASSURANCE_CONTRACT_PLEDGE', index=4, number=4, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ASSURANCE_CONTRACT_STUB', index=5, number=5, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1980, + serialized_end=2128, +) +_sym_db.RegisterEnumDescriptor(_TRANSACTION_PURPOSE) + +_WALLET_ENCRYPTIONTYPE = _descriptor.EnumDescriptor( + name='EncryptionType', + full_name='wallet.Wallet.EncryptionType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNENCRYPTED', index=0, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='ENCRYPTED_SCRYPT_AES', index=1, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=2948, + serialized_end=3007, +) +_sym_db.RegisterEnumDescriptor(_WALLET_ENCRYPTIONTYPE) + + +_PEERADDRESS = _descriptor.Descriptor( + name='PeerAddress', + full_name='wallet.PeerAddress', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='ip_address', full_name='wallet.PeerAddress.ip_address', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='port', full_name='wallet.PeerAddress.port', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='services', full_name='wallet.PeerAddress.services', index=2, + number=3, type=4, cpp_type=4, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=24, + serialized_end=89, +) + + +_ENCRYPTEDDATA = _descriptor.Descriptor( + name='EncryptedData', + full_name='wallet.EncryptedData', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='initialisation_vector', full_name='wallet.EncryptedData.initialisation_vector', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encrypted_private_key', full_name='wallet.EncryptedData.encrypted_private_key', index=1, + number=2, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=91, + serialized_end=168, +) + + +_DETERMINISTICKEY = _descriptor.Descriptor( + name='DeterministicKey', + full_name='wallet.DeterministicKey', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='chain_code', full_name='wallet.DeterministicKey.chain_code', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='path', full_name='wallet.DeterministicKey.path', index=1, + number=2, type=13, cpp_type=3, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='issued_subkeys', full_name='wallet.DeterministicKey.issued_subkeys', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lookahead_size', full_name='wallet.DeterministicKey.lookahead_size', index=3, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='isFollowing', full_name='wallet.DeterministicKey.isFollowing', index=4, + number=5, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=170, + serialized_end=291, +) + + +_KEY = _descriptor.Descriptor( + name='Key', + full_name='wallet.Key', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='type', full_name='wallet.Key.type', index=0, + number=1, type=14, cpp_type=8, label=2, + has_default_value=False, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='secret_bytes', full_name='wallet.Key.secret_bytes', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encrypted_data', full_name='wallet.Key.encrypted_data', index=2, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='public_key', full_name='wallet.Key.public_key', index=3, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='label', full_name='wallet.Key.label', index=4, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='creation_timestamp', full_name='wallet.Key.creation_timestamp', index=5, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='deterministic_key', full_name='wallet.Key.deterministic_key', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='deterministic_seed', full_name='wallet.Key.deterministic_seed', index=7, + number=8, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encrypted_deterministic_seed', full_name='wallet.Key.encrypted_deterministic_seed', index=8, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _KEY_TYPE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=294, + serialized_end=704, +) + + +_SCRIPT = _descriptor.Descriptor( + name='Script', + full_name='wallet.Script', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='program', full_name='wallet.Script.program', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='creation_timestamp', full_name='wallet.Script.creation_timestamp', index=1, + number=2, type=3, cpp_type=2, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=706, + serialized_end=759, +) + + +_TRANSACTIONINPUT = _descriptor.Descriptor( + name='TransactionInput', + full_name='wallet.TransactionInput', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='transaction_out_point_hash', full_name='wallet.TransactionInput.transaction_out_point_hash', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transaction_out_point_index', full_name='wallet.TransactionInput.transaction_out_point_index', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='script_bytes', full_name='wallet.TransactionInput.script_bytes', index=2, + number=3, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sequence', full_name='wallet.TransactionInput.sequence', index=3, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='wallet.TransactionInput.value', index=4, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=762, + serialized_end=908, +) + + +_TRANSACTIONOUTPUT = _descriptor.Descriptor( + name='TransactionOutput', + full_name='wallet.TransactionOutput', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='value', full_name='wallet.TransactionOutput.value', index=0, + number=1, type=3, cpp_type=2, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='script_bytes', full_name='wallet.TransactionOutput.script_bytes', index=1, + number=2, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='spent_by_transaction_hash', full_name='wallet.TransactionOutput.spent_by_transaction_hash', index=2, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='spent_by_transaction_index', full_name='wallet.TransactionOutput.spent_by_transaction_index', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=910, + serialized_end=1037, +) + + +_TRANSACTIONCONFIDENCE = _descriptor.Descriptor( + name='TransactionConfidence', + full_name='wallet.TransactionConfidence', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='type', full_name='wallet.TransactionConfidence.type', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='appeared_at_height', full_name='wallet.TransactionConfidence.appeared_at_height', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='overriding_transaction', full_name='wallet.TransactionConfidence.overriding_transaction', index=2, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='depth', full_name='wallet.TransactionConfidence.depth', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='broadcast_by', full_name='wallet.TransactionConfidence.broadcast_by', index=4, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='source', full_name='wallet.TransactionConfidence.source', index=5, + number=7, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _TRANSACTIONCONFIDENCE_TYPE, + _TRANSACTIONCONFIDENCE_SOURCE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=1040, + serialized_end=1433, +) + + +_TRANSACTION = _descriptor.Descriptor( + name='Transaction', + full_name='wallet.Transaction', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='version', full_name='wallet.Transaction.version', index=0, + number=1, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='hash', full_name='wallet.Transaction.hash', index=1, + number=2, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pool', full_name='wallet.Transaction.pool', index=2, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=4, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='lock_time', full_name='wallet.Transaction.lock_time', index=3, + number=4, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='updated_at', full_name='wallet.Transaction.updated_at', index=4, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transaction_input', full_name='wallet.Transaction.transaction_input', index=5, + number=6, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transaction_output', full_name='wallet.Transaction.transaction_output', index=6, + number=7, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='block_hash', full_name='wallet.Transaction.block_hash', index=7, + number=8, type=12, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='block_relativity_offsets', full_name='wallet.Transaction.block_relativity_offsets', index=8, + number=11, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='confidence', full_name='wallet.Transaction.confidence', index=9, + number=9, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='purpose', full_name='wallet.Transaction.purpose', index=10, + number=10, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='exchange_rate', full_name='wallet.Transaction.exchange_rate', index=11, + number=12, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='memo', full_name='wallet.Transaction.memo', index=12, + number=13, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _TRANSACTION_POOL, + _TRANSACTION_PURPOSE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=1436, + serialized_end=2128, +) + + +_SCRYPTPARAMETERS = _descriptor.Descriptor( + name='ScryptParameters', + full_name='wallet.ScryptParameters', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='salt', full_name='wallet.ScryptParameters.salt', index=0, + number=1, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='n', full_name='wallet.ScryptParameters.n', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=True, default_value=16384, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='r', full_name='wallet.ScryptParameters.r', index=2, + number=3, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=8, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='p', full_name='wallet.ScryptParameters.p', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=2130, + serialized_end=2208, +) + + +_EXTENSION = _descriptor.Descriptor( + name='Extension', + full_name='wallet.Extension', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='id', full_name='wallet.Extension.id', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='wallet.Extension.data', index=1, + number=2, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mandatory', full_name='wallet.Extension.mandatory', index=2, + number=3, type=8, cpp_type=7, label=2, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=2210, + serialized_end=2266, +) + + +_TAG = _descriptor.Descriptor( + name='Tag', + full_name='wallet.Tag', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='tag', full_name='wallet.Tag.tag', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='wallet.Tag.data', index=1, + number=2, type=12, cpp_type=9, label=2, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=2268, + serialized_end=2300, +) + + +_TRANSACTIONSIGNER = _descriptor.Descriptor( + name='TransactionSigner', + full_name='wallet.TransactionSigner', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='class_name', full_name='wallet.TransactionSigner.class_name', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='data', full_name='wallet.TransactionSigner.data', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=2302, + serialized_end=2355, +) + + +_WALLET = _descriptor.Descriptor( + name='Wallet', + full_name='wallet.Wallet', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='network_identifier', full_name='wallet.Wallet.network_identifier', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='last_seen_block_hash', full_name='wallet.Wallet.last_seen_block_hash', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='last_seen_block_height', full_name='wallet.Wallet.last_seen_block_height', index=2, + number=12, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='last_seen_block_time_secs', full_name='wallet.Wallet.last_seen_block_time_secs', index=3, + number=14, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='key', full_name='wallet.Wallet.key', index=4, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transaction', full_name='wallet.Wallet.transaction', index=5, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='watched_script', full_name='wallet.Wallet.watched_script', index=6, + number=15, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encryption_type', full_name='wallet.Wallet.encryption_type', index=7, + number=5, type=14, cpp_type=8, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='encryption_parameters', full_name='wallet.Wallet.encryption_parameters', index=8, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='version', full_name='wallet.Wallet.version', index=9, + number=7, type=5, cpp_type=1, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='extension', full_name='wallet.Wallet.extension', index=10, + number=10, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='description', full_name='wallet.Wallet.description', index=11, + number=11, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='key_rotation_time', full_name='wallet.Wallet.key_rotation_time', index=12, + number=13, type=4, cpp_type=4, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='tags', full_name='wallet.Wallet.tags', index=13, + number=16, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='transaction_signers', full_name='wallet.Wallet.transaction_signers', index=14, + number=17, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sigsRequiredToSpend', full_name='wallet.Wallet.sigsRequiredToSpend', index=15, + number=18, type=13, cpp_type=3, label=1, + has_default_value=True, default_value=1, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _WALLET_ENCRYPTIONTYPE, + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=2358, + serialized_end=3007, +) + + +_EXCHANGERATE = _descriptor.Descriptor( + name='ExchangeRate', + full_name='wallet.ExchangeRate', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='coin_value', full_name='wallet.ExchangeRate.coin_value', index=0, + number=1, type=3, cpp_type=2, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fiat_value', full_name='wallet.ExchangeRate.fiat_value', index=1, + number=2, type=3, cpp_type=2, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='fiat_currency_code', full_name='wallet.ExchangeRate.fiat_currency_code', index=2, + number=3, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + oneofs=[ + ], + serialized_start=3009, + serialized_end=3091, +) + +_KEY.fields_by_name['type'].enum_type = _KEY_TYPE +_KEY.fields_by_name['encrypted_data'].message_type = _ENCRYPTEDDATA +_KEY.fields_by_name['deterministic_key'].message_type = _DETERMINISTICKEY +_KEY.fields_by_name['encrypted_deterministic_seed'].message_type = _ENCRYPTEDDATA +_KEY_TYPE.containing_type = _KEY +_TRANSACTIONCONFIDENCE.fields_by_name['type'].enum_type = _TRANSACTIONCONFIDENCE_TYPE +_TRANSACTIONCONFIDENCE.fields_by_name['broadcast_by'].message_type = _PEERADDRESS +_TRANSACTIONCONFIDENCE.fields_by_name['source'].enum_type = _TRANSACTIONCONFIDENCE_SOURCE +_TRANSACTIONCONFIDENCE_TYPE.containing_type = _TRANSACTIONCONFIDENCE +_TRANSACTIONCONFIDENCE_SOURCE.containing_type = _TRANSACTIONCONFIDENCE +_TRANSACTION.fields_by_name['pool'].enum_type = _TRANSACTION_POOL +_TRANSACTION.fields_by_name['transaction_input'].message_type = _TRANSACTIONINPUT +_TRANSACTION.fields_by_name['transaction_output'].message_type = _TRANSACTIONOUTPUT +_TRANSACTION.fields_by_name['confidence'].message_type = _TRANSACTIONCONFIDENCE +_TRANSACTION.fields_by_name['purpose'].enum_type = _TRANSACTION_PURPOSE +_TRANSACTION.fields_by_name['exchange_rate'].message_type = _EXCHANGERATE +_TRANSACTION_POOL.containing_type = _TRANSACTION +_TRANSACTION_PURPOSE.containing_type = _TRANSACTION +_WALLET.fields_by_name['key'].message_type = _KEY +_WALLET.fields_by_name['transaction'].message_type = _TRANSACTION +_WALLET.fields_by_name['watched_script'].message_type = _SCRIPT +_WALLET.fields_by_name['encryption_type'].enum_type = _WALLET_ENCRYPTIONTYPE +_WALLET.fields_by_name['encryption_parameters'].message_type = _SCRYPTPARAMETERS +_WALLET.fields_by_name['extension'].message_type = _EXTENSION +_WALLET.fields_by_name['tags'].message_type = _TAG +_WALLET.fields_by_name['transaction_signers'].message_type = _TRANSACTIONSIGNER +_WALLET_ENCRYPTIONTYPE.containing_type = _WALLET +DESCRIPTOR.message_types_by_name['PeerAddress'] = _PEERADDRESS +DESCRIPTOR.message_types_by_name['EncryptedData'] = _ENCRYPTEDDATA +DESCRIPTOR.message_types_by_name['DeterministicKey'] = _DETERMINISTICKEY +DESCRIPTOR.message_types_by_name['Key'] = _KEY +DESCRIPTOR.message_types_by_name['Script'] = _SCRIPT +DESCRIPTOR.message_types_by_name['TransactionInput'] = _TRANSACTIONINPUT +DESCRIPTOR.message_types_by_name['TransactionOutput'] = _TRANSACTIONOUTPUT +DESCRIPTOR.message_types_by_name['TransactionConfidence'] = _TRANSACTIONCONFIDENCE +DESCRIPTOR.message_types_by_name['Transaction'] = _TRANSACTION +DESCRIPTOR.message_types_by_name['ScryptParameters'] = _SCRYPTPARAMETERS +DESCRIPTOR.message_types_by_name['Extension'] = _EXTENSION +DESCRIPTOR.message_types_by_name['Tag'] = _TAG +DESCRIPTOR.message_types_by_name['TransactionSigner'] = _TRANSACTIONSIGNER +DESCRIPTOR.message_types_by_name['Wallet'] = _WALLET +DESCRIPTOR.message_types_by_name['ExchangeRate'] = _EXCHANGERATE + +PeerAddress = _reflection.GeneratedProtocolMessageType('PeerAddress', (_message.Message,), dict( + DESCRIPTOR = _PEERADDRESS, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.PeerAddress) + )) +_sym_db.RegisterMessage(PeerAddress) + +EncryptedData = _reflection.GeneratedProtocolMessageType('EncryptedData', (_message.Message,), dict( + DESCRIPTOR = _ENCRYPTEDDATA, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.EncryptedData) + )) +_sym_db.RegisterMessage(EncryptedData) + +DeterministicKey = _reflection.GeneratedProtocolMessageType('DeterministicKey', (_message.Message,), dict( + DESCRIPTOR = _DETERMINISTICKEY, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.DeterministicKey) + )) +_sym_db.RegisterMessage(DeterministicKey) + +Key = _reflection.GeneratedProtocolMessageType('Key', (_message.Message,), dict( + DESCRIPTOR = _KEY, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Key) + )) +_sym_db.RegisterMessage(Key) + +Script = _reflection.GeneratedProtocolMessageType('Script', (_message.Message,), dict( + DESCRIPTOR = _SCRIPT, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Script) + )) +_sym_db.RegisterMessage(Script) + +TransactionInput = _reflection.GeneratedProtocolMessageType('TransactionInput', (_message.Message,), dict( + DESCRIPTOR = _TRANSACTIONINPUT, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.TransactionInput) + )) +_sym_db.RegisterMessage(TransactionInput) + +TransactionOutput = _reflection.GeneratedProtocolMessageType('TransactionOutput', (_message.Message,), dict( + DESCRIPTOR = _TRANSACTIONOUTPUT, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.TransactionOutput) + )) +_sym_db.RegisterMessage(TransactionOutput) + +TransactionConfidence = _reflection.GeneratedProtocolMessageType('TransactionConfidence', (_message.Message,), dict( + DESCRIPTOR = _TRANSACTIONCONFIDENCE, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.TransactionConfidence) + )) +_sym_db.RegisterMessage(TransactionConfidence) + +Transaction = _reflection.GeneratedProtocolMessageType('Transaction', (_message.Message,), dict( + DESCRIPTOR = _TRANSACTION, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Transaction) + )) +_sym_db.RegisterMessage(Transaction) + +ScryptParameters = _reflection.GeneratedProtocolMessageType('ScryptParameters', (_message.Message,), dict( + DESCRIPTOR = _SCRYPTPARAMETERS, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.ScryptParameters) + )) +_sym_db.RegisterMessage(ScryptParameters) + +Extension = _reflection.GeneratedProtocolMessageType('Extension', (_message.Message,), dict( + DESCRIPTOR = _EXTENSION, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Extension) + )) +_sym_db.RegisterMessage(Extension) + +Tag = _reflection.GeneratedProtocolMessageType('Tag', (_message.Message,), dict( + DESCRIPTOR = _TAG, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Tag) + )) +_sym_db.RegisterMessage(Tag) + +TransactionSigner = _reflection.GeneratedProtocolMessageType('TransactionSigner', (_message.Message,), dict( + DESCRIPTOR = _TRANSACTIONSIGNER, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.TransactionSigner) + )) +_sym_db.RegisterMessage(TransactionSigner) + +Wallet = _reflection.GeneratedProtocolMessageType('Wallet', (_message.Message,), dict( + DESCRIPTOR = _WALLET, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.Wallet) + )) +_sym_db.RegisterMessage(Wallet) + +ExchangeRate = _reflection.GeneratedProtocolMessageType('ExchangeRate', (_message.Message,), dict( + DESCRIPTOR = _EXCHANGERATE, + __module__ = 'wallet_pb2' + # @@protoc_insertion_point(class_scope:wallet.ExchangeRate) + )) +_sym_db.RegisterMessage(ExchangeRate) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\023org.bitcoinj.walletB\006Protos')) +# @@protoc_insertion_point(module_scope)