PatchPogoHandle::PatchPogoHandle(XaxVFSHandleIfc *base_handle, Elf32_Shdr *pogo_shdr)
: FilterVFSHandle(base_handle)
{
uint8_t *patch_ptr = patch_bytes;
#define SPLAT(v) { lite_memcpy(patch_ptr, &v, sizeof(v)); patch_ptr+=sizeof(v); }
SPLAT(x86_push_immediate);
uint32_t jump_destination = (uint32_t) &xinterpose;
SPLAT(jump_destination);
SPLAT(x86_ret);
lite_assert((patch_ptr - patch_bytes) == POGO_PATCH_SIZE);
patch_offset = pogo_shdr->sh_offset;
}
/*
* NAME: sha256->search()
* DESCRIPTION: try to find a nonce which satisfies a target hash
*/
int64_t sha256_search(const message_t M,
const hash_t target, const hash_t midstate,
uint32_t start_nonce, uint32_t range)
{
uint32_t nonce, stop_nonce = start_nonce + range + (4 - (range % 4)) % 4;
# if !defined(UNROLL_SHA256)
int t;
# endif
vec_uint4 W0[3], a0, b0, c0, d0, e0, f0, g0, h0;
vec_uint4 W[16], a, b, c, d, e, f, g, h, T1, T2;
vec_uint4 borrow;
const vec_uchar16 reverse_endian = {
3, 2, 1, 0,
7, 6, 5, 4,
11, 10, 9, 8,
15, 14, 13, 12
};
/* precompute first three rounds */
a = SPLAT(midstate.words[0]);
b = SPLAT(midstate.words[1]);
c = SPLAT(midstate.words[2]);
d = SPLAT(midstate.words[3]);
e = SPLAT(midstate.words[4]);
f = SPLAT(midstate.words[5]);
g = SPLAT(midstate.words[6]);
h = SPLAT(midstate.words[7]);
# ifdef UNROLL_SHA256
W[0] = SPLAT(M.words[0]); ROUND(0);
W[1] = SPLAT(M.words[1]); ROUND(1);
W[2] = SPLAT(M.words[2]); ROUND(2);
# else
for (t = 0; t < 3; ++t) {
W[t] = SPLAT(M.words[t]);
ROUND(t);
}
# endif
W0[0] = W[0];
W0[1] = W[1];
W0[2] = W[2];
a0 = a;
b0 = b;
c0 = c;
d0 = d;
e0 = e;
f0 = f;
g0 = g;
h0 = h;
/* do the search, four at a time */
for (nonce = start_nonce; nonce != stop_nonce; nonce += 4) {
W[0] = W0[0];
W[1] = W0[1];
W[2] = W0[2];
a = a0;
b = b0;
c = c0;
d = d0;
e = e0;
f = f0;
g = g0;
h = h0;
/* t = 3 */
W[3] = (vec_uint4) { nonce + 0, nonce + 1, nonce + 2, nonce + 3 };
ROUND(3);
# ifdef UNROLL_SHA256
W[ 4] = SPLAT(M.words[ 4]); ROUND( 4);
W[ 5] = SPLAT(M.words[ 5]); ROUND( 5);
W[ 6] = SPLAT(M.words[ 6]); ROUND( 6);
W[ 7] = SPLAT(M.words[ 7]); ROUND( 7);
W[ 8] = SPLAT(M.words[ 8]); ROUND( 8);
W[ 9] = SPLAT(M.words[ 9]); ROUND( 9);
W[10] = SPLAT(M.words[10]); ROUND(10);
W[11] = SPLAT(M.words[11]); ROUND(11);
W[12] = SPLAT(M.words[12]); ROUND(12);
W[13] = SPLAT(M.words[13]); ROUND(13);
W[14] = SPLAT(M.words[14]); ROUND(14);
W[15] = SPLAT(M.words[15]); ROUND(15);
# else
for (t = 4; t < 16; ++t) {
W[t] = SPLAT(M.words[t]);
ROUND(t);
}
# endif
# ifdef UNROLL_SHA256
W[16 % 16] = W(16); ROUND(16);
W[17 % 16] = W(17); ROUND(17);
W[18 % 16] = W(18); ROUND(18);
W[19 % 16] = W(19); ROUND(19);
W[20 % 16] = W(20); ROUND(20);
W[21 % 16] = W(21); ROUND(21);
W[22 % 16] = W(22); ROUND(22);
W[23 % 16] = W(23); ROUND(23);
W[24 % 16] = W(24); ROUND(24);
W[25 % 16] = W(25); ROUND(25);
W[26 % 16] = W(26); ROUND(26);
W[27 % 16] = W(27); ROUND(27);
W[28 % 16] = W(28); ROUND(28);
W[29 % 16] = W(29); ROUND(29);
W[30 % 16] = W(30); ROUND(30);
W[31 % 16] = W(31); ROUND(31);
W[32 % 16] = W(32); ROUND(32);
W[33 % 16] = W(33); ROUND(33);
W[34 % 16] = W(34); ROUND(34);
W[35 % 16] = W(35); ROUND(35);
W[36 % 16] = W(36); ROUND(36);
W[37 % 16] = W(37); ROUND(37);
W[38 % 16] = W(38); ROUND(38);
W[39 % 16] = W(39); ROUND(39);
W[40 % 16] = W(40); ROUND(40);
W[41 % 16] = W(41); ROUND(41);
W[42 % 16] = W(42); ROUND(42);
W[43 % 16] = W(43); ROUND(43);
W[44 % 16] = W(44); ROUND(44);
W[45 % 16] = W(45); ROUND(45);
W[46 % 16] = W(46); ROUND(46);
W[47 % 16] = W(47); ROUND(47);
W[48 % 16] = W(48); ROUND(48);
W[49 % 16] = W(49); ROUND(49);
W[50 % 16] = W(50); ROUND(50);
W[51 % 16] = W(51); ROUND(51);
W[52 % 16] = W(52); ROUND(52);
W[53 % 16] = W(53); ROUND(53);
W[54 % 16] = W(54); ROUND(54);
W[55 % 16] = W(55); ROUND(55);
W[56 % 16] = W(56); ROUND(56);
W[57 % 16] = W(57); ROUND(57);
W[58 % 16] = W(58); ROUND(58);
W[59 % 16] = W(59); ROUND(59);
W[60 % 16] = W(60); ROUND(60);
W[61 % 16] = W(61); ROUND(61);
W[62 % 16] = W(62); ROUND(62);
W[63 % 16] = W(63); ROUND(63);
# else
for (t = 16; t < 64; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
W[0] = ADD(a, SPLAT(midstate.words[0]));
W[1] = ADD(b, SPLAT(midstate.words[1]));
W[2] = ADD(c, SPLAT(midstate.words[2]));
W[3] = ADD(d, SPLAT(midstate.words[3]));
W[4] = ADD(e, SPLAT(midstate.words[4]));
W[5] = ADD(f, SPLAT(midstate.words[5]));
W[6] = ADD(g, SPLAT(midstate.words[6]));
W[7] = ADD(h, SPLAT(midstate.words[7]));
/* first SHA-256 complete */
a = SPLAT(H0.words[0]);
b = SPLAT(H0.words[1]);
c = SPLAT(H0.words[2]);
d = SPLAT(H0.words[3]);
e = SPLAT(H0.words[4]);
f = SPLAT(H0.words[5]);
g = SPLAT(H0.words[6]);
h = SPLAT(H0.words[7]);
ROUND(0);
ROUND(1);
ROUND(2);
ROUND(3);
ROUND(4);
ROUND(5);
ROUND(6);
ROUND(7);
W[ 8] = SPLAT(0x80000000U); ROUND( 8);
# ifdef UNROLL_SHA256
W[ 9] = SPLAT(0x00000000U); ROUND( 9);
W[10] = SPLAT(0x00000000U); ROUND(10);
W[11] = SPLAT(0x00000000U); ROUND(11);
W[12] = SPLAT(0x00000000U); ROUND(12);
W[13] = SPLAT(0x00000000U); ROUND(13);
W[14] = SPLAT(0x00000000U); ROUND(14);
# else
for (t = 9; t < 15; ++t) {
W[t] = SPLAT(0U);
ROUND(t);
}
# endif
W[15] = SPLAT(0x00000100U); ROUND(15);
# ifdef UNROLL_SHA256
W[16 % 16] = W(16); ROUND(16);
W[17 % 16] = W(17); ROUND(17);
W[18 % 16] = W(18); ROUND(18);
W[19 % 16] = W(19); ROUND(19);
W[20 % 16] = W(20); ROUND(20);
W[21 % 16] = W(21); ROUND(21);
W[22 % 16] = W(22); ROUND(22);
W[23 % 16] = W(23); ROUND(23);
W[24 % 16] = W(24); ROUND(24);
W[25 % 16] = W(25); ROUND(25);
W[26 % 16] = W(26); ROUND(26);
W[27 % 16] = W(27); ROUND(27);
W[28 % 16] = W(28); ROUND(28);
W[29 % 16] = W(29); ROUND(29);
W[30 % 16] = W(30); ROUND(30);
W[31 % 16] = W(31); ROUND(31);
W[32 % 16] = W(32); ROUND(32);
W[33 % 16] = W(33); ROUND(33);
W[34 % 16] = W(34); ROUND(34);
W[35 % 16] = W(35); ROUND(35);
W[36 % 16] = W(36); ROUND(36);
W[37 % 16] = W(37); ROUND(37);
W[38 % 16] = W(38); ROUND(38);
W[39 % 16] = W(39); ROUND(39);
W[40 % 16] = W(40); ROUND(40);
W[41 % 16] = W(41); ROUND(41);
W[42 % 16] = W(42); ROUND(42);
W[43 % 16] = W(43); ROUND(43);
W[44 % 16] = W(44); ROUND(44);
W[45 % 16] = W(45); ROUND(45);
W[46 % 16] = W(46); ROUND(46);
W[47 % 16] = W(47); ROUND(47);
W[48 % 16] = W(48); ROUND(48);
W[49 % 16] = W(49); ROUND(49);
W[50 % 16] = W(50); ROUND(50);
W[51 % 16] = W(51); ROUND(51);
W[52 % 16] = W(52); ROUND(52);
W[53 % 16] = W(53); ROUND(53);
W[54 % 16] = W(54); ROUND(54);
W[55 % 16] = W(55); ROUND(55);
W[56 % 16] = W(56); ROUND(56);
W[57 % 16] = W(57); ROUND(57);
W[58 % 16] = W(58); ROUND(58);
W[59 % 16] = W(59); ROUND(59);
/* t = 60..63 delayed */
# else
for (t = 16; t < 60; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
W[60 % 16] = W(60);
T1 = T1(60, e, f, g, h);
T2 = ADD(ADD(d, T1), SPLAT(H0.words[7]));
/* quick check to see if any element of the last word vector is zero */
if (__builtin_expect(!vec_any_eq(T2, vec_splat_u32(0)), 1))
continue;
/* we have something interesting; finish the SHA-256 */
ROUND(60);
# ifdef UNROLL_SHA256
W[61 % 16] = W(61); ROUND(61);
W[62 % 16] = W(62); ROUND(62);
W[63 % 16] = W(63); ROUND(63);
# else
for (t = 61; t < 64; ++t) {
W[t % 16] = W(t);
ROUND(t);
}
# endif
a = ADD(a, SPLAT(H0.words[0]));
b = ADD(b, SPLAT(H0.words[1]));
c = ADD(c, SPLAT(H0.words[2]));
d = ADD(d, SPLAT(H0.words[3]));
e = ADD(e, SPLAT(H0.words[4]));
f = ADD(f, SPLAT(H0.words[5]));
g = ADD(g, SPLAT(H0.words[6]));
h = ADD(h, SPLAT(H0.words[7]));
/* now do the full (reversed-endian) subtraction */
borrow = GENB(SPLAT(target.words[7]),
vec_perm(a, a, reverse_endian));
borrow = GENBX(SPLAT(target.words[6]),
vec_perm(b, b, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[5]),
vec_perm(c, c, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[4]),
vec_perm(d, d, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[3]),
vec_perm(e, e, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[2]),
vec_perm(f, f, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[1]),
vec_perm(g, g, reverse_endian), borrow);
borrow = GENBX(SPLAT(target.words[0]),
vec_perm(h, h, reverse_endian), borrow);
if (__builtin_expect(vec_all_eq(borrow, vec_splat_u32(0)), 1))
continue;
/* we have a winner */
if (vec_extract(borrow, 0))
return nonce + 0;
if (vec_extract(borrow, 1))
return nonce + 1;
if (vec_extract(borrow, 2))
return nonce + 2;
if (vec_extract(borrow, 3))
return nonce + 3;
}
return -1;
}
