mirror of
https://github.com/bvanroll/odiseectf.git
synced 2025-08-29 03:42:41 +00:00
idk
This commit is contained in:
25
yt/OpenCL/amp_a0.cl
Normal file
25
yt/OpenCL/amp_a0.cl
Normal file
@@ -0,0 +1,25 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
|
||||
__kernel void amp (__global pw_t *pws, __global pw_t *pws_amp, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
if (rules_buf[0].cmds[0] == RULE_OP_MANGLE_NOOP && rules_buf[0].cmds[1] == 0) return;
|
||||
|
||||
pw_t pw = pws_amp[gid];
|
||||
|
||||
pw.pw_len = apply_rules (rules_buf[0].cmds, pw.i, pw.pw_len);
|
||||
|
||||
pws[gid] = pw;
|
||||
}
|
||||
43
yt/OpenCL/amp_a1.cl
Normal file
43
yt/OpenCL/amp_a1.cl
Normal file
@@ -0,0 +1,43 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
|
||||
__kernel void amp (__global pw_t *pws, __global pw_t *pws_amp, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
pw_t pw = pws_amp[gid];
|
||||
|
||||
pw_t comb = combs_buf[0];
|
||||
|
||||
const u32 pw_len = pw.pw_len;
|
||||
|
||||
const u32 comb_len = comb.pw_len;
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_1x64_le_S (comb.i, pw_len);
|
||||
}
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
|
||||
{
|
||||
switch_buffer_by_offset_1x64_le_S (pw.i, comb_len);
|
||||
}
|
||||
|
||||
#pragma unroll
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
pw.i[i] |= comb.i[i];
|
||||
}
|
||||
|
||||
pw.pw_len = pw_len + comb_len;
|
||||
|
||||
pws[gid] = pw;
|
||||
}
|
||||
19
yt/OpenCL/amp_a3.cl
Normal file
19
yt/OpenCL/amp_a3.cl
Normal file
@@ -0,0 +1,19 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_types.cl"
|
||||
|
||||
__kernel void amp (__global pw_t *pws, __global pw_t *pws_amp, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const bf_t *bfs_buf, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
const u32 w0r = bfs_buf[0].i;
|
||||
|
||||
pws[gid].i[0] |= w0r;
|
||||
}
|
||||
1292
yt/OpenCL/inc_cipher_aes.cl
Normal file
1292
yt/OpenCL/inc_cipher_aes.cl
Normal file
File diff suppressed because it is too large
Load Diff
728
yt/OpenCL/inc_cipher_serpent.cl
Normal file
728
yt/OpenCL/inc_cipher_serpent.cl
Normal file
@@ -0,0 +1,728 @@
|
||||
/* This is an independent implementation of the encryption algorithm: */
|
||||
/* */
|
||||
/* Serpent by Ross Anderson, Eli Biham and Lars Knudsen */
|
||||
/* */
|
||||
/* which is a candidate algorithm in the Advanced Encryption Standard */
|
||||
/* programme of the US National Institute of Standards and Technology. */
|
||||
/* */
|
||||
/* Copyright in this implementation is held by Dr B R Gladman but I */
|
||||
/* hereby give permission for its free direct or derivative use subject */
|
||||
/* to acknowledgment of its origin and compliance with any conditions */
|
||||
/* that the originators of the algorithm place on its exploitation. */
|
||||
/* */
|
||||
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
|
||||
/* */
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* */
|
||||
/* Cleaned and optimized for GPU use with hashcat by Jens Steube */
|
||||
|
||||
/* 15 terms */
|
||||
|
||||
#define sb0(a,b,c,d,e,f,g,h) \
|
||||
t1 = a ^ d; \
|
||||
t2 = a & d; \
|
||||
t3 = c ^ t1; \
|
||||
t6 = b & t1; \
|
||||
t4 = b ^ t3; \
|
||||
t10 = ~t3; \
|
||||
h = t2 ^ t4; \
|
||||
t7 = a ^ t6; \
|
||||
t14 = ~t7; \
|
||||
t8 = c | t7; \
|
||||
t11 = t3 ^ t7; \
|
||||
g = t4 ^ t8; \
|
||||
t12 = h & t11; \
|
||||
f = t10 ^ t12; \
|
||||
e = t12 ^ t14
|
||||
|
||||
/* 15 terms */
|
||||
|
||||
#define ib0(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = a ^ b; \
|
||||
t3 = t1 | t2; \
|
||||
t4 = d ^ t3; \
|
||||
t7 = d & t2; \
|
||||
t5 = c ^ t4; \
|
||||
t8 = t1 ^ t7; \
|
||||
g = t2 ^ t5; \
|
||||
t11 = a & t4; \
|
||||
t9 = g & t8; \
|
||||
t14 = t5 ^ t8; \
|
||||
f = t4 ^ t9; \
|
||||
t12 = t5 | f; \
|
||||
h = t11 ^ t12; \
|
||||
e = h ^ t14
|
||||
|
||||
/* 14 terms! */
|
||||
|
||||
#define sb1(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = b ^ t1; \
|
||||
t3 = a | t2; \
|
||||
t4 = d | t2; \
|
||||
t5 = c ^ t3; \
|
||||
g = d ^ t5; \
|
||||
t7 = b ^ t4; \
|
||||
t8 = t2 ^ g; \
|
||||
t9 = t5 & t7; \
|
||||
h = t8 ^ t9; \
|
||||
t11 = t5 ^ t7; \
|
||||
f = h ^ t11; \
|
||||
t13 = t8 & t11; \
|
||||
e = t5 ^ t13
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define ib1(a,b,c,d,e,f,g,h) \
|
||||
t1 = a ^ d; \
|
||||
t2 = a & b; \
|
||||
t3 = b ^ c; \
|
||||
t4 = a ^ t3; \
|
||||
t5 = b | d; \
|
||||
t7 = c | t1; \
|
||||
h = t4 ^ t5; \
|
||||
t8 = b ^ t7; \
|
||||
t11 = ~t2; \
|
||||
t9 = t4 & t8; \
|
||||
f = t1 ^ t9; \
|
||||
t13 = t9 ^ t11; \
|
||||
t12 = h & f; \
|
||||
g = t12 ^ t13; \
|
||||
t15 = a & d; \
|
||||
t16 = c ^ t13; \
|
||||
e = t15 ^ t16
|
||||
|
||||
/* 16 terms */
|
||||
|
||||
#define sb2(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = b ^ d; \
|
||||
t3 = c & t1; \
|
||||
t13 = d | t1; \
|
||||
e = t2 ^ t3; \
|
||||
t5 = c ^ t1; \
|
||||
t6 = c ^ e; \
|
||||
t7 = b & t6; \
|
||||
t10 = e | t5; \
|
||||
h = t5 ^ t7; \
|
||||
t9 = d | t7; \
|
||||
t11 = t9 & t10; \
|
||||
t14 = t2 ^ h; \
|
||||
g = a ^ t11; \
|
||||
t15 = g ^ t13; \
|
||||
f = t14 ^ t15
|
||||
|
||||
/* 16 terms */
|
||||
|
||||
#define ib2(a,b,c,d,e,f,g,h) \
|
||||
t1 = b ^ d; \
|
||||
t2 = ~t1; \
|
||||
t3 = a ^ c; \
|
||||
t4 = c ^ t1; \
|
||||
t7 = a | t2; \
|
||||
t5 = b & t4; \
|
||||
t8 = d ^ t7; \
|
||||
t11 = ~t4; \
|
||||
e = t3 ^ t5; \
|
||||
t9 = t3 | t8; \
|
||||
t14 = d & t11; \
|
||||
h = t1 ^ t9; \
|
||||
t12 = e | h; \
|
||||
f = t11 ^ t12; \
|
||||
t15 = t3 ^ t12; \
|
||||
g = t14 ^ t15
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define sb3(a,b,c,d,e,f,g,h) \
|
||||
t1 = a ^ c; \
|
||||
t2 = d ^ t1; \
|
||||
t3 = a & t2; \
|
||||
t4 = d ^ t3; \
|
||||
t5 = b & t4; \
|
||||
g = t2 ^ t5; \
|
||||
t7 = a | g; \
|
||||
t8 = b | d; \
|
||||
t11 = a | d; \
|
||||
t9 = t4 & t7; \
|
||||
f = t8 ^ t9; \
|
||||
t12 = b ^ t11; \
|
||||
t13 = g ^ t9; \
|
||||
t15 = t3 ^ t8; \
|
||||
h = t12 ^ t13; \
|
||||
t16 = c & t15; \
|
||||
e = t12 ^ t16
|
||||
|
||||
/* 16 term solution that performs less well than 17 term one
|
||||
in my environment (PPro/PII)
|
||||
|
||||
#define sb3(a,b,c,d,e,f,g,h) \
|
||||
t1 = a ^ b; \
|
||||
t2 = a & c; \
|
||||
t3 = a | d; \
|
||||
t4 = c ^ d; \
|
||||
t5 = t1 & t3; \
|
||||
t6 = t2 | t5; \
|
||||
g = t4 ^ t6; \
|
||||
t8 = b ^ t3; \
|
||||
t9 = t6 ^ t8; \
|
||||
t10 = t4 & t9; \
|
||||
e = t1 ^ t10; \
|
||||
t12 = g & e; \
|
||||
f = t9 ^ t12; \
|
||||
t14 = b | d; \
|
||||
t15 = t4 ^ t12; \
|
||||
h = t14 ^ t15
|
||||
*/
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define ib3(a,b,c,d,e,f,g,h) \
|
||||
t1 = b ^ c; \
|
||||
t2 = b | c; \
|
||||
t3 = a ^ c; \
|
||||
t7 = a ^ d; \
|
||||
t4 = t2 ^ t3; \
|
||||
t5 = d | t4; \
|
||||
t9 = t2 ^ t7; \
|
||||
e = t1 ^ t5; \
|
||||
t8 = t1 | t5; \
|
||||
t11 = a & t4; \
|
||||
g = t8 ^ t9; \
|
||||
t12 = e | t9; \
|
||||
f = t11 ^ t12; \
|
||||
t14 = a & g; \
|
||||
t15 = t2 ^ t14; \
|
||||
t16 = e & t15; \
|
||||
h = t4 ^ t16
|
||||
|
||||
/* 15 terms */
|
||||
|
||||
#define sb4(a,b,c,d,e,f,g,h) \
|
||||
t1 = a ^ d; \
|
||||
t2 = d & t1; \
|
||||
t3 = c ^ t2; \
|
||||
t4 = b | t3; \
|
||||
h = t1 ^ t4; \
|
||||
t6 = ~b; \
|
||||
t7 = t1 | t6; \
|
||||
e = t3 ^ t7; \
|
||||
t9 = a & e; \
|
||||
t10 = t1 ^ t6; \
|
||||
t11 = t4 & t10; \
|
||||
g = t9 ^ t11; \
|
||||
t13 = a ^ t3; \
|
||||
t14 = t10 & g; \
|
||||
f = t13 ^ t14
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define ib4(a,b,c,d,e,f,g,h) \
|
||||
t1 = c ^ d; \
|
||||
t2 = c | d; \
|
||||
t3 = b ^ t2; \
|
||||
t4 = a & t3; \
|
||||
f = t1 ^ t4; \
|
||||
t6 = a ^ d; \
|
||||
t7 = b | d; \
|
||||
t8 = t6 & t7; \
|
||||
h = t3 ^ t8; \
|
||||
t10 = ~a; \
|
||||
t11 = c ^ h; \
|
||||
t12 = t10 | t11;\
|
||||
e = t3 ^ t12; \
|
||||
t14 = c | t4; \
|
||||
t15 = t7 ^ t14; \
|
||||
t16 = h | t10; \
|
||||
g = t15 ^ t16
|
||||
|
||||
/* 16 terms */
|
||||
|
||||
#define sb5(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = a ^ b; \
|
||||
t3 = a ^ d; \
|
||||
t4 = c ^ t1; \
|
||||
t5 = t2 | t3; \
|
||||
e = t4 ^ t5; \
|
||||
t7 = d & e; \
|
||||
t8 = t2 ^ e; \
|
||||
t10 = t1 | e; \
|
||||
f = t7 ^ t8; \
|
||||
t11 = t2 | t7; \
|
||||
t12 = t3 ^ t10; \
|
||||
t14 = b ^ t7; \
|
||||
g = t11 ^ t12; \
|
||||
t15 = f & t12; \
|
||||
h = t14 ^ t15
|
||||
|
||||
/* 16 terms */
|
||||
|
||||
#define ib5(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~c; \
|
||||
t2 = b & t1; \
|
||||
t3 = d ^ t2; \
|
||||
t4 = a & t3; \
|
||||
t5 = b ^ t1; \
|
||||
h = t4 ^ t5; \
|
||||
t7 = b | h; \
|
||||
t8 = a & t7; \
|
||||
f = t3 ^ t8; \
|
||||
t10 = a | d; \
|
||||
t11 = t1 ^ t7; \
|
||||
e = t10 ^ t11; \
|
||||
t13 = a ^ c; \
|
||||
t14 = b & t10; \
|
||||
t15 = t4 | t13; \
|
||||
g = t14 ^ t15
|
||||
|
||||
/* 15 terms */
|
||||
|
||||
#define sb6(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = a ^ d; \
|
||||
t3 = b ^ t2; \
|
||||
t4 = t1 | t2; \
|
||||
t5 = c ^ t4; \
|
||||
f = b ^ t5; \
|
||||
t13 = ~t5; \
|
||||
t7 = t2 | f; \
|
||||
t8 = d ^ t7; \
|
||||
t9 = t5 & t8; \
|
||||
g = t3 ^ t9; \
|
||||
t11 = t5 ^ t8; \
|
||||
e = g ^ t11; \
|
||||
t14 = t3 & t11; \
|
||||
h = t13 ^ t14
|
||||
|
||||
/* 15 terms */
|
||||
|
||||
#define ib6(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~a; \
|
||||
t2 = a ^ b; \
|
||||
t3 = c ^ t2; \
|
||||
t4 = c | t1; \
|
||||
t5 = d ^ t4; \
|
||||
t13 = d & t1; \
|
||||
f = t3 ^ t5; \
|
||||
t7 = t3 & t5; \
|
||||
t8 = t2 ^ t7; \
|
||||
t9 = b | t8; \
|
||||
h = t5 ^ t9; \
|
||||
t11 = b | h; \
|
||||
e = t8 ^ t11; \
|
||||
t14 = t3 ^ t11; \
|
||||
g = t13 ^ t14
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define sb7(a,b,c,d,e,f,g,h) \
|
||||
t1 = ~c; \
|
||||
t2 = b ^ c; \
|
||||
t3 = b | t1; \
|
||||
t4 = d ^ t3; \
|
||||
t5 = a & t4; \
|
||||
t7 = a ^ d; \
|
||||
h = t2 ^ t5; \
|
||||
t8 = b ^ t5; \
|
||||
t9 = t2 | t8; \
|
||||
t11 = d & t3; \
|
||||
f = t7 ^ t9; \
|
||||
t12 = t5 ^ f; \
|
||||
t15 = t1 | t4; \
|
||||
t13 = h & t12; \
|
||||
g = t11 ^ t13; \
|
||||
t16 = t12 ^ g; \
|
||||
e = t15 ^ t16
|
||||
|
||||
/* 17 terms */
|
||||
|
||||
#define ib7(a,b,c,d,e,f,g,h) \
|
||||
t1 = a & b; \
|
||||
t2 = a | b; \
|
||||
t3 = c | t1; \
|
||||
t4 = d & t2; \
|
||||
h = t3 ^ t4; \
|
||||
t6 = ~d; \
|
||||
t7 = b ^ t4; \
|
||||
t8 = h ^ t6; \
|
||||
t11 = c ^ t7; \
|
||||
t9 = t7 | t8; \
|
||||
f = a ^ t9; \
|
||||
t12 = d | f; \
|
||||
e = t11 ^ t12; \
|
||||
t14 = a & h; \
|
||||
t15 = t3 ^ f; \
|
||||
t16 = e ^ t14; \
|
||||
g = t15 ^ t16
|
||||
|
||||
#define k_xor(r,a,b,c,d) \
|
||||
a ^= ks[4 * r + 8]; \
|
||||
b ^= ks[4 * r + 9]; \
|
||||
c ^= ks[4 * r + 10]; \
|
||||
d ^= ks[4 * r + 11]
|
||||
|
||||
#define k_set(r,a,b,c,d) \
|
||||
a = ks[4 * r + 8]; \
|
||||
b = ks[4 * r + 9]; \
|
||||
c = ks[4 * r + 10]; \
|
||||
d = ks[4 * r + 11]
|
||||
|
||||
#define k_get(r,a,b,c,d) \
|
||||
ks[4 * r + 8] = a; \
|
||||
ks[4 * r + 9] = b; \
|
||||
ks[4 * r + 10] = c; \
|
||||
ks[4 * r + 11] = d
|
||||
|
||||
/* the linear transformation and its inverse */
|
||||
|
||||
#define rot(a,b,c,d) \
|
||||
a = rotl32_S(a, 13); \
|
||||
c = rotl32_S(c, 3); \
|
||||
d ^= c ^ (a << 3); \
|
||||
b ^= a ^ c; \
|
||||
d = rotl32_S(d, 7); \
|
||||
b = rotl32_S(b, 1); \
|
||||
a ^= b ^ d; \
|
||||
c ^= d ^ (b << 7); \
|
||||
a = rotl32_S(a, 5); \
|
||||
c = rotl32_S(c, 22)
|
||||
|
||||
#define irot(a,b,c,d) \
|
||||
c = rotr32_S(c, 22); \
|
||||
a = rotr32_S(a, 5); \
|
||||
c ^= d ^ (b << 7); \
|
||||
a ^= b ^ d; \
|
||||
d = rotr32_S(d, 7); \
|
||||
b = rotr32_S(b, 1); \
|
||||
d ^= c ^ (a << 3); \
|
||||
b ^= a ^ c; \
|
||||
c = rotr32_S(c, 3); \
|
||||
a = rotr32_S(a, 13)
|
||||
|
||||
// 128 bit key
|
||||
|
||||
DECLSPEC void serpent128_set_key (u32 *ks, const u32 *ukey)
|
||||
{
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (volatile int i = 0; i < 4; i++)
|
||||
{
|
||||
ks[i] = ukey[i];
|
||||
}
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (volatile int i = 4; i < 8; i++)
|
||||
{
|
||||
ks[i] = 0;
|
||||
}
|
||||
|
||||
ks[4] = 1;
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (volatile int i = 0; i < 132; i++)
|
||||
{
|
||||
ks[i + 8] = rotl32_S (ks[i + 7] ^ ks[i + 5] ^ ks[i + 3] ^ ks[i + 0] ^ 0x9e3779b9 ^ i, 11);
|
||||
}
|
||||
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
k_set( 0,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get( 0,e,f,g,h);
|
||||
k_set( 1,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get( 1,e,f,g,h);
|
||||
k_set( 2,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get( 2,e,f,g,h);
|
||||
k_set( 3,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get( 3,e,f,g,h);
|
||||
k_set( 4,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get( 4,e,f,g,h);
|
||||
k_set( 5,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get( 5,e,f,g,h);
|
||||
k_set( 6,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get( 6,e,f,g,h);
|
||||
k_set( 7,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get( 7,e,f,g,h);
|
||||
k_set( 8,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get( 8,e,f,g,h);
|
||||
k_set( 9,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get( 9,e,f,g,h);
|
||||
k_set(10,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(10,e,f,g,h);
|
||||
k_set(11,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(11,e,f,g,h);
|
||||
k_set(12,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(12,e,f,g,h);
|
||||
k_set(13,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(13,e,f,g,h);
|
||||
k_set(14,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(14,e,f,g,h);
|
||||
k_set(15,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(15,e,f,g,h);
|
||||
k_set(16,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(16,e,f,g,h);
|
||||
k_set(17,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get(17,e,f,g,h);
|
||||
k_set(18,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(18,e,f,g,h);
|
||||
k_set(19,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(19,e,f,g,h);
|
||||
k_set(20,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(20,e,f,g,h);
|
||||
k_set(21,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(21,e,f,g,h);
|
||||
k_set(22,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(22,e,f,g,h);
|
||||
k_set(23,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(23,e,f,g,h);
|
||||
k_set(24,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(24,e,f,g,h);
|
||||
k_set(25,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get(25,e,f,g,h);
|
||||
k_set(26,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(26,e,f,g,h);
|
||||
k_set(27,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(27,e,f,g,h);
|
||||
k_set(28,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(28,e,f,g,h);
|
||||
k_set(29,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(29,e,f,g,h);
|
||||
k_set(30,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(30,e,f,g,h);
|
||||
k_set(31,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(31,e,f,g,h);
|
||||
k_set(32,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(32,e,f,g,h);
|
||||
}
|
||||
|
||||
DECLSPEC void serpent128_encrypt (const u32 *ks, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
a = in[0];
|
||||
b = in[1];
|
||||
c = in[2];
|
||||
d = in[3];
|
||||
|
||||
k_xor( 0,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 1,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 2,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 3,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 4,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 5,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 6,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 7,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 8,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 9,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(10,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(11,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(12,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(13,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(14,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(15,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(16,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(17,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(18,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(19,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(20,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(21,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(22,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(23,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(24,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(25,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(26,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(27,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(28,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(29,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(30,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(31,e,f,g,h); sb7(e,f,g,h,a,b,c,d);
|
||||
k_xor(32,a,b,c,d);
|
||||
|
||||
out[0] = a;
|
||||
out[1] = b;
|
||||
out[2] = c;
|
||||
out[3] = d;
|
||||
}
|
||||
|
||||
DECLSPEC void serpent128_decrypt (const u32 *ks, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
a = in[0];
|
||||
b = in[1];
|
||||
c = in[2];
|
||||
d = in[3];
|
||||
|
||||
k_xor(32,a,b,c,d);
|
||||
ib7(a,b,c,d,e,f,g,h); k_xor(31,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(30,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(29,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(28,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(27,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(26,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor(25,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor(24,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor(23,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(22,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(21,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(20,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(19,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(18,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor(17,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor(16,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor(15,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(14,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(13,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(12,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(11,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(10,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor( 9,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor( 8,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor( 7,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor( 6,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor( 5,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor( 4,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor( 3,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor( 2,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor( 1,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor( 0,a,b,c,d);
|
||||
|
||||
out[0] = a;
|
||||
out[1] = b;
|
||||
out[2] = c;
|
||||
out[3] = d;
|
||||
}
|
||||
|
||||
// 256 bit key
|
||||
|
||||
DECLSPEC void serpent256_set_key (u32 *ks, const u32 *ukey)
|
||||
{
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (volatile int i = 0; i < 8; i++)
|
||||
{
|
||||
ks[i] = ukey[i];
|
||||
}
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (volatile int i = 0; i < 132; i++)
|
||||
{
|
||||
ks[i + 8] = rotl32_S (ks[i + 7] ^ ks[i + 5] ^ ks[i + 3] ^ ks[i + 0] ^ 0x9e3779b9 ^ i, 11);
|
||||
}
|
||||
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
k_set( 0,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get( 0,e,f,g,h);
|
||||
k_set( 1,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get( 1,e,f,g,h);
|
||||
k_set( 2,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get( 2,e,f,g,h);
|
||||
k_set( 3,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get( 3,e,f,g,h);
|
||||
k_set( 4,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get( 4,e,f,g,h);
|
||||
k_set( 5,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get( 5,e,f,g,h);
|
||||
k_set( 6,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get( 6,e,f,g,h);
|
||||
k_set( 7,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get( 7,e,f,g,h);
|
||||
k_set( 8,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get( 8,e,f,g,h);
|
||||
k_set( 9,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get( 9,e,f,g,h);
|
||||
k_set(10,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(10,e,f,g,h);
|
||||
k_set(11,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(11,e,f,g,h);
|
||||
k_set(12,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(12,e,f,g,h);
|
||||
k_set(13,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(13,e,f,g,h);
|
||||
k_set(14,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(14,e,f,g,h);
|
||||
k_set(15,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(15,e,f,g,h);
|
||||
k_set(16,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(16,e,f,g,h);
|
||||
k_set(17,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get(17,e,f,g,h);
|
||||
k_set(18,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(18,e,f,g,h);
|
||||
k_set(19,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(19,e,f,g,h);
|
||||
k_set(20,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(20,e,f,g,h);
|
||||
k_set(21,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(21,e,f,g,h);
|
||||
k_set(22,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(22,e,f,g,h);
|
||||
k_set(23,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(23,e,f,g,h);
|
||||
k_set(24,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(24,e,f,g,h);
|
||||
k_set(25,a,b,c,d); sb2(a,b,c,d,e,f,g,h); k_get(25,e,f,g,h);
|
||||
k_set(26,a,b,c,d); sb1(a,b,c,d,e,f,g,h); k_get(26,e,f,g,h);
|
||||
k_set(27,a,b,c,d); sb0(a,b,c,d,e,f,g,h); k_get(27,e,f,g,h);
|
||||
k_set(28,a,b,c,d); sb7(a,b,c,d,e,f,g,h); k_get(28,e,f,g,h);
|
||||
k_set(29,a,b,c,d); sb6(a,b,c,d,e,f,g,h); k_get(29,e,f,g,h);
|
||||
k_set(30,a,b,c,d); sb5(a,b,c,d,e,f,g,h); k_get(30,e,f,g,h);
|
||||
k_set(31,a,b,c,d); sb4(a,b,c,d,e,f,g,h); k_get(31,e,f,g,h);
|
||||
k_set(32,a,b,c,d); sb3(a,b,c,d,e,f,g,h); k_get(32,e,f,g,h);
|
||||
}
|
||||
|
||||
DECLSPEC void serpent256_encrypt (const u32 *ks, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
a = in[0];
|
||||
b = in[1];
|
||||
c = in[2];
|
||||
d = in[3];
|
||||
|
||||
k_xor( 0,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 1,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 2,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 3,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 4,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 5,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 6,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 7,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor( 8,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor( 9,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(10,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(11,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(12,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(13,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(14,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(15,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(16,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(17,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(18,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(19,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(20,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(21,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(22,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(23,e,f,g,h); sb7(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(24,a,b,c,d); sb0(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(25,e,f,g,h); sb1(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(26,a,b,c,d); sb2(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(27,e,f,g,h); sb3(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(28,a,b,c,d); sb4(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(29,e,f,g,h); sb5(e,f,g,h,a,b,c,d); rot(a,b,c,d);
|
||||
k_xor(30,a,b,c,d); sb6(a,b,c,d,e,f,g,h); rot(e,f,g,h);
|
||||
k_xor(31,e,f,g,h); sb7(e,f,g,h,a,b,c,d);
|
||||
k_xor(32,a,b,c,d);
|
||||
|
||||
out[0] = a;
|
||||
out[1] = b;
|
||||
out[2] = c;
|
||||
out[3] = d;
|
||||
}
|
||||
|
||||
DECLSPEC void serpent256_decrypt (const u32 *ks, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 a,b,c,d,e,f,g,h;
|
||||
u32 t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16;
|
||||
|
||||
a = in[0];
|
||||
b = in[1];
|
||||
c = in[2];
|
||||
d = in[3];
|
||||
|
||||
k_xor(32,a,b,c,d);
|
||||
ib7(a,b,c,d,e,f,g,h); k_xor(31,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(30,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(29,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(28,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(27,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(26,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor(25,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor(24,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor(23,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(22,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(21,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(20,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(19,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(18,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor(17,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor(16,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor(15,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor(14,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor(13,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor(12,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor(11,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor(10,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor( 9,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor( 8,a,b,c,d);
|
||||
irot(a,b,c,d); ib7(a,b,c,d,e,f,g,h); k_xor( 7,e,f,g,h);
|
||||
irot(e,f,g,h); ib6(e,f,g,h,a,b,c,d); k_xor( 6,a,b,c,d);
|
||||
irot(a,b,c,d); ib5(a,b,c,d,e,f,g,h); k_xor( 5,e,f,g,h);
|
||||
irot(e,f,g,h); ib4(e,f,g,h,a,b,c,d); k_xor( 4,a,b,c,d);
|
||||
irot(a,b,c,d); ib3(a,b,c,d,e,f,g,h); k_xor( 3,e,f,g,h);
|
||||
irot(e,f,g,h); ib2(e,f,g,h,a,b,c,d); k_xor( 2,a,b,c,d);
|
||||
irot(a,b,c,d); ib1(a,b,c,d,e,f,g,h); k_xor( 1,e,f,g,h);
|
||||
irot(e,f,g,h); ib0(e,f,g,h,a,b,c,d); k_xor( 0,a,b,c,d);
|
||||
|
||||
out[0] = a;
|
||||
out[1] = b;
|
||||
out[2] = c;
|
||||
out[3] = d;
|
||||
}
|
||||
577
yt/OpenCL/inc_cipher_twofish.cl
Normal file
577
yt/OpenCL/inc_cipher_twofish.cl
Normal file
@@ -0,0 +1,577 @@
|
||||
/* This is an independent implementation of the encryption algorithm: */
|
||||
/* */
|
||||
/* Twofish by Bruce Schneier and colleagues */
|
||||
/* */
|
||||
/* which is a candidate algorithm in the Advanced Encryption Standard */
|
||||
/* programme of the US National Institute of Standards and Technology. */
|
||||
/* */
|
||||
/* Copyright in this implementation is held by Dr B R Gladman but I */
|
||||
/* hereby give permission for its free direct or derivative use subject */
|
||||
/* to acknowledgment of its origin and compliance with any conditions */
|
||||
/* that the originators of t he algorithm place on its exploitation. */
|
||||
/* */
|
||||
/* My thanks to Doug Whiting and Niels Ferguson for comments that led */
|
||||
/* to improvements in this implementation. */
|
||||
/* */
|
||||
/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999 */
|
||||
/* */
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* */
|
||||
/* Cleaned and optimized for GPU use with hashcat by Jens Steube */
|
||||
|
||||
#define extract_byte(x,n) (((x) >> (8 * (n))) & 0xff)
|
||||
|
||||
__constant u32a q_tab[2][256] =
|
||||
{
|
||||
{
|
||||
0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 0x9A, 0x92, 0x80, 0x78,
|
||||
0xE4, 0xDD, 0xD1, 0x38, 0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C,
|
||||
0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48, 0xF2, 0xD0, 0x8B, 0x30,
|
||||
0x84, 0x54, 0xDF, 0x23, 0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82,
|
||||
0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 0xA6, 0xEB, 0xA5, 0xBE,
|
||||
0x16, 0x0C, 0xE3, 0x61, 0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B,
|
||||
0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1, 0xE1, 0xE6, 0xBD, 0x45,
|
||||
0xE2, 0xF4, 0xB6, 0x66, 0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7,
|
||||
0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 0xEA, 0x77, 0x39, 0xAF,
|
||||
0x33, 0xC9, 0x62, 0x71, 0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8,
|
||||
0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7, 0xA1, 0x1D, 0xAA, 0xED,
|
||||
0x06, 0x70, 0xB2, 0xD2, 0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90,
|
||||
0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 0x9E, 0x9C, 0x52, 0x1B,
|
||||
0x5F, 0x93, 0x0A, 0xEF, 0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B,
|
||||
0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64, 0x2A, 0xCE, 0xCB, 0x2F,
|
||||
0xFC, 0x97, 0x05, 0x7A, 0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A,
|
||||
0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 0xB8, 0xDA, 0xB0, 0x17,
|
||||
0x55, 0x1F, 0x8A, 0x7D, 0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72,
|
||||
0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34, 0x6E, 0x50, 0xDE, 0x68,
|
||||
0x65, 0xBC, 0xDB, 0xF8, 0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4,
|
||||
0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 0x6F, 0x9D, 0x36, 0x42,
|
||||
0x4A, 0x5E, 0xC1, 0xE0
|
||||
},
|
||||
{
|
||||
0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 0x4A, 0xD3, 0xE6, 0x6B,
|
||||
0x45, 0x7D, 0xE8, 0x4B, 0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1,
|
||||
0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F, 0x5E, 0xBA, 0xAE, 0x5B,
|
||||
0x8A, 0x00, 0xBC, 0x9D, 0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5,
|
||||
0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 0xB2, 0x73, 0x4C, 0x54,
|
||||
0x92, 0x74, 0x36, 0x51, 0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96,
|
||||
0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C, 0x13, 0x95, 0x9C, 0xC7,
|
||||
0x24, 0x46, 0x3B, 0x70, 0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8,
|
||||
0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 0x03, 0x6F, 0x08, 0xBF,
|
||||
0x40, 0xE7, 0x2B, 0xE2, 0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9,
|
||||
0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17, 0x66, 0x94, 0xA1, 0x1D,
|
||||
0x3D, 0xF0, 0xDE, 0xB3, 0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E,
|
||||
0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 0x81, 0x88, 0xEE, 0x21,
|
||||
0xC4, 0x1A, 0xEB, 0xD9, 0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01,
|
||||
0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48, 0x4F, 0xF2, 0x65, 0x8E,
|
||||
0x78, 0x5C, 0x58, 0x19, 0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64,
|
||||
0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 0xCE, 0xE9, 0x68, 0x44,
|
||||
0xE0, 0x4D, 0x43, 0x69, 0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E,
|
||||
0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC, 0x22, 0xC9, 0xC0, 0x9B,
|
||||
0x89, 0xD4, 0xED, 0xAB, 0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9,
|
||||
0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 0x16, 0x25, 0x86, 0x56,
|
||||
0x55, 0x09, 0xBE, 0x91
|
||||
}
|
||||
};
|
||||
|
||||
#define q(n,x) q_tab[n][x]
|
||||
|
||||
__constant u32a m_tab[4][256] =
|
||||
{
|
||||
{ 0xBCBC3275, 0xECEC21F3, 0x202043C6, 0xB3B3C9F4, 0xDADA03DB, 0x02028B7B,
|
||||
0xE2E22BFB, 0x9E9EFAC8, 0xC9C9EC4A, 0xD4D409D3, 0x18186BE6, 0x1E1E9F6B,
|
||||
0x98980E45, 0xB2B2387D, 0xA6A6D2E8, 0x2626B74B, 0x3C3C57D6, 0x93938A32,
|
||||
0x8282EED8, 0x525298FD, 0x7B7BD437, 0xBBBB3771, 0x5B5B97F1, 0x474783E1,
|
||||
0x24243C30, 0x5151E20F, 0xBABAC6F8, 0x4A4AF31B, 0xBFBF4887, 0x0D0D70FA,
|
||||
0xB0B0B306, 0x7575DE3F, 0xD2D2FD5E, 0x7D7D20BA, 0x666631AE, 0x3A3AA35B,
|
||||
0x59591C8A, 0x00000000, 0xCDCD93BC, 0x1A1AE09D, 0xAEAE2C6D, 0x7F7FABC1,
|
||||
0x2B2BC7B1, 0xBEBEB90E, 0xE0E0A080, 0x8A8A105D, 0x3B3B52D2, 0x6464BAD5,
|
||||
0xD8D888A0, 0xE7E7A584, 0x5F5FE807, 0x1B1B1114, 0x2C2CC2B5, 0xFCFCB490,
|
||||
0x3131272C, 0x808065A3, 0x73732AB2, 0x0C0C8173, 0x79795F4C, 0x6B6B4154,
|
||||
0x4B4B0292, 0x53536974, 0x94948F36, 0x83831F51, 0x2A2A3638, 0xC4C49CB0,
|
||||
0x2222C8BD, 0xD5D5F85A, 0xBDBDC3FC, 0x48487860, 0xFFFFCE62, 0x4C4C0796,
|
||||
0x4141776C, 0xC7C7E642, 0xEBEB24F7, 0x1C1C1410, 0x5D5D637C, 0x36362228,
|
||||
0x6767C027, 0xE9E9AF8C, 0x4444F913, 0x1414EA95, 0xF5F5BB9C, 0xCFCF18C7,
|
||||
0x3F3F2D24, 0xC0C0E346, 0x7272DB3B, 0x54546C70, 0x29294CCA, 0xF0F035E3,
|
||||
0x0808FE85, 0xC6C617CB, 0xF3F34F11, 0x8C8CE4D0, 0xA4A45993, 0xCACA96B8,
|
||||
0x68683BA6, 0xB8B84D83, 0x38382820, 0xE5E52EFF, 0xADAD569F, 0x0B0B8477,
|
||||
0xC8C81DC3, 0x9999FFCC, 0x5858ED03, 0x19199A6F, 0x0E0E0A08, 0x95957EBF,
|
||||
0x70705040, 0xF7F730E7, 0x6E6ECF2B, 0x1F1F6EE2, 0xB5B53D79, 0x09090F0C,
|
||||
0x616134AA, 0x57571682, 0x9F9F0B41, 0x9D9D803A, 0x111164EA, 0x2525CDB9,
|
||||
0xAFAFDDE4, 0x4545089A, 0xDFDF8DA4, 0xA3A35C97, 0xEAEAD57E, 0x353558DA,
|
||||
0xEDEDD07A, 0x4343FC17, 0xF8F8CB66, 0xFBFBB194, 0x3737D3A1, 0xFAFA401D,
|
||||
0xC2C2683D, 0xB4B4CCF0, 0x32325DDE, 0x9C9C71B3, 0x5656E70B, 0xE3E3DA72,
|
||||
0x878760A7, 0x15151B1C, 0xF9F93AEF, 0x6363BFD1, 0x3434A953, 0x9A9A853E,
|
||||
0xB1B1428F, 0x7C7CD133, 0x88889B26, 0x3D3DA65F, 0xA1A1D7EC, 0xE4E4DF76,
|
||||
0x8181942A, 0x91910149, 0x0F0FFB81, 0xEEEEAA88, 0x161661EE, 0xD7D77321,
|
||||
0x9797F5C4, 0xA5A5A81A, 0xFEFE3FEB, 0x6D6DB5D9, 0x7878AEC5, 0xC5C56D39,
|
||||
0x1D1DE599, 0x7676A4CD, 0x3E3EDCAD, 0xCBCB6731, 0xB6B6478B, 0xEFEF5B01,
|
||||
0x12121E18, 0x6060C523, 0x6A6AB0DD, 0x4D4DF61F, 0xCECEE94E, 0xDEDE7C2D,
|
||||
0x55559DF9, 0x7E7E5A48, 0x2121B24F, 0x03037AF2, 0xA0A02665, 0x5E5E198E,
|
||||
0x5A5A6678, 0x65654B5C, 0x62624E58, 0xFDFD4519, 0x0606F48D, 0x404086E5,
|
||||
0xF2F2BE98, 0x3333AC57, 0x17179067, 0x05058E7F, 0xE8E85E05, 0x4F4F7D64,
|
||||
0x89896AAF, 0x10109563, 0x74742FB6, 0x0A0A75FE, 0x5C5C92F5, 0x9B9B74B7,
|
||||
0x2D2D333C, 0x3030D6A5, 0x2E2E49CE, 0x494989E9, 0x46467268, 0x77775544,
|
||||
0xA8A8D8E0, 0x9696044D, 0x2828BD43, 0xA9A92969, 0xD9D97929, 0x8686912E,
|
||||
0xD1D187AC, 0xF4F44A15, 0x8D8D1559, 0xD6D682A8, 0xB9B9BC0A, 0x42420D9E,
|
||||
0xF6F6C16E, 0x2F2FB847, 0xDDDD06DF, 0x23233934, 0xCCCC6235, 0xF1F1C46A,
|
||||
0xC1C112CF, 0x8585EBDC, 0x8F8F9E22, 0x7171A1C9, 0x9090F0C0, 0xAAAA539B,
|
||||
0x0101F189, 0x8B8BE1D4, 0x4E4E8CED, 0x8E8E6FAB, 0xABABA212, 0x6F6F3EA2,
|
||||
0xE6E6540D, 0xDBDBF252, 0x92927BBB, 0xB7B7B602, 0x6969CA2F, 0x3939D9A9,
|
||||
0xD3D30CD7, 0xA7A72361, 0xA2A2AD1E, 0xC3C399B4, 0x6C6C4450, 0x07070504,
|
||||
0x04047FF6, 0x272746C2, 0xACACA716, 0xD0D07625, 0x50501386, 0xDCDCF756,
|
||||
0x84841A55, 0xE1E15109, 0x7A7A25BE, 0x1313EF91 },
|
||||
|
||||
{ 0xA9D93939, 0x67901717, 0xB3719C9C, 0xE8D2A6A6, 0x04050707, 0xFD985252,
|
||||
0xA3658080, 0x76DFE4E4, 0x9A084545, 0x92024B4B, 0x80A0E0E0, 0x78665A5A,
|
||||
0xE4DDAFAF, 0xDDB06A6A, 0xD1BF6363, 0x38362A2A, 0x0D54E6E6, 0xC6432020,
|
||||
0x3562CCCC, 0x98BEF2F2, 0x181E1212, 0xF724EBEB, 0xECD7A1A1, 0x6C774141,
|
||||
0x43BD2828, 0x7532BCBC, 0x37D47B7B, 0x269B8888, 0xFA700D0D, 0x13F94444,
|
||||
0x94B1FBFB, 0x485A7E7E, 0xF27A0303, 0xD0E48C8C, 0x8B47B6B6, 0x303C2424,
|
||||
0x84A5E7E7, 0x54416B6B, 0xDF06DDDD, 0x23C56060, 0x1945FDFD, 0x5BA33A3A,
|
||||
0x3D68C2C2, 0x59158D8D, 0xF321ECEC, 0xAE316666, 0xA23E6F6F, 0x82165757,
|
||||
0x63951010, 0x015BEFEF, 0x834DB8B8, 0x2E918686, 0xD9B56D6D, 0x511F8383,
|
||||
0x9B53AAAA, 0x7C635D5D, 0xA63B6868, 0xEB3FFEFE, 0xA5D63030, 0xBE257A7A,
|
||||
0x16A7ACAC, 0x0C0F0909, 0xE335F0F0, 0x6123A7A7, 0xC0F09090, 0x8CAFE9E9,
|
||||
0x3A809D9D, 0xF5925C5C, 0x73810C0C, 0x2C273131, 0x2576D0D0, 0x0BE75656,
|
||||
0xBB7B9292, 0x4EE9CECE, 0x89F10101, 0x6B9F1E1E, 0x53A93434, 0x6AC4F1F1,
|
||||
0xB499C3C3, 0xF1975B5B, 0xE1834747, 0xE66B1818, 0xBDC82222, 0x450E9898,
|
||||
0xE26E1F1F, 0xF4C9B3B3, 0xB62F7474, 0x66CBF8F8, 0xCCFF9999, 0x95EA1414,
|
||||
0x03ED5858, 0x56F7DCDC, 0xD4E18B8B, 0x1C1B1515, 0x1EADA2A2, 0xD70CD3D3,
|
||||
0xFB2BE2E2, 0xC31DC8C8, 0x8E195E5E, 0xB5C22C2C, 0xE9894949, 0xCF12C1C1,
|
||||
0xBF7E9595, 0xBA207D7D, 0xEA641111, 0x77840B0B, 0x396DC5C5, 0xAF6A8989,
|
||||
0x33D17C7C, 0xC9A17171, 0x62CEFFFF, 0x7137BBBB, 0x81FB0F0F, 0x793DB5B5,
|
||||
0x0951E1E1, 0xADDC3E3E, 0x242D3F3F, 0xCDA47676, 0xF99D5555, 0xD8EE8282,
|
||||
0xE5864040, 0xC5AE7878, 0xB9CD2525, 0x4D049696, 0x44557777, 0x080A0E0E,
|
||||
0x86135050, 0xE730F7F7, 0xA1D33737, 0x1D40FAFA, 0xAA346161, 0xED8C4E4E,
|
||||
0x06B3B0B0, 0x706C5454, 0xB22A7373, 0xD2523B3B, 0x410B9F9F, 0x7B8B0202,
|
||||
0xA088D8D8, 0x114FF3F3, 0x3167CBCB, 0xC2462727, 0x27C06767, 0x90B4FCFC,
|
||||
0x20283838, 0xF67F0404, 0x60784848, 0xFF2EE5E5, 0x96074C4C, 0x5C4B6565,
|
||||
0xB1C72B2B, 0xAB6F8E8E, 0x9E0D4242, 0x9CBBF5F5, 0x52F2DBDB, 0x1BF34A4A,
|
||||
0x5FA63D3D, 0x9359A4A4, 0x0ABCB9B9, 0xEF3AF9F9, 0x91EF1313, 0x85FE0808,
|
||||
0x49019191, 0xEE611616, 0x2D7CDEDE, 0x4FB22121, 0x8F42B1B1, 0x3BDB7272,
|
||||
0x47B82F2F, 0x8748BFBF, 0x6D2CAEAE, 0x46E3C0C0, 0xD6573C3C, 0x3E859A9A,
|
||||
0x6929A9A9, 0x647D4F4F, 0x2A948181, 0xCE492E2E, 0xCB17C6C6, 0x2FCA6969,
|
||||
0xFCC3BDBD, 0x975CA3A3, 0x055EE8E8, 0x7AD0EDED, 0xAC87D1D1, 0x7F8E0505,
|
||||
0xD5BA6464, 0x1AA8A5A5, 0x4BB72626, 0x0EB9BEBE, 0xA7608787, 0x5AF8D5D5,
|
||||
0x28223636, 0x14111B1B, 0x3FDE7575, 0x2979D9D9, 0x88AAEEEE, 0x3C332D2D,
|
||||
0x4C5F7979, 0x02B6B7B7, 0xB896CACA, 0xDA583535, 0xB09CC4C4, 0x17FC4343,
|
||||
0x551A8484, 0x1FF64D4D, 0x8A1C5959, 0x7D38B2B2, 0x57AC3333, 0xC718CFCF,
|
||||
0x8DF40606, 0x74695353, 0xB7749B9B, 0xC4F59797, 0x9F56ADAD, 0x72DAE3E3,
|
||||
0x7ED5EAEA, 0x154AF4F4, 0x229E8F8F, 0x12A2ABAB, 0x584E6262, 0x07E85F5F,
|
||||
0x99E51D1D, 0x34392323, 0x6EC1F6F6, 0x50446C6C, 0xDE5D3232, 0x68724646,
|
||||
0x6526A0A0, 0xBC93CDCD, 0xDB03DADA, 0xF8C6BABA, 0xC8FA9E9E, 0xA882D6D6,
|
||||
0x2BCF6E6E, 0x40507070, 0xDCEB8585, 0xFE750A0A, 0x328A9393, 0xA48DDFDF,
|
||||
0xCA4C2929, 0x10141C1C, 0x2173D7D7, 0xF0CCB4B4, 0xD309D4D4, 0x5D108A8A,
|
||||
0x0FE25151, 0x00000000, 0x6F9A1919, 0x9DE01A1A, 0x368F9494, 0x42E6C7C7,
|
||||
0x4AECC9C9, 0x5EFDD2D2, 0xC1AB7F7F, 0xE0D8A8A8 },
|
||||
|
||||
{ 0xBC75BC32, 0xECF3EC21, 0x20C62043, 0xB3F4B3C9, 0xDADBDA03, 0x027B028B,
|
||||
0xE2FBE22B, 0x9EC89EFA, 0xC94AC9EC, 0xD4D3D409, 0x18E6186B, 0x1E6B1E9F,
|
||||
0x9845980E, 0xB27DB238, 0xA6E8A6D2, 0x264B26B7, 0x3CD63C57, 0x9332938A,
|
||||
0x82D882EE, 0x52FD5298, 0x7B377BD4, 0xBB71BB37, 0x5BF15B97, 0x47E14783,
|
||||
0x2430243C, 0x510F51E2, 0xBAF8BAC6, 0x4A1B4AF3, 0xBF87BF48, 0x0DFA0D70,
|
||||
0xB006B0B3, 0x753F75DE, 0xD25ED2FD, 0x7DBA7D20, 0x66AE6631, 0x3A5B3AA3,
|
||||
0x598A591C, 0x00000000, 0xCDBCCD93, 0x1A9D1AE0, 0xAE6DAE2C, 0x7FC17FAB,
|
||||
0x2BB12BC7, 0xBE0EBEB9, 0xE080E0A0, 0x8A5D8A10, 0x3BD23B52, 0x64D564BA,
|
||||
0xD8A0D888, 0xE784E7A5, 0x5F075FE8, 0x1B141B11, 0x2CB52CC2, 0xFC90FCB4,
|
||||
0x312C3127, 0x80A38065, 0x73B2732A, 0x0C730C81, 0x794C795F, 0x6B546B41,
|
||||
0x4B924B02, 0x53745369, 0x9436948F, 0x8351831F, 0x2A382A36, 0xC4B0C49C,
|
||||
0x22BD22C8, 0xD55AD5F8, 0xBDFCBDC3, 0x48604878, 0xFF62FFCE, 0x4C964C07,
|
||||
0x416C4177, 0xC742C7E6, 0xEBF7EB24, 0x1C101C14, 0x5D7C5D63, 0x36283622,
|
||||
0x672767C0, 0xE98CE9AF, 0x441344F9, 0x149514EA, 0xF59CF5BB, 0xCFC7CF18,
|
||||
0x3F243F2D, 0xC046C0E3, 0x723B72DB, 0x5470546C, 0x29CA294C, 0xF0E3F035,
|
||||
0x088508FE, 0xC6CBC617, 0xF311F34F, 0x8CD08CE4, 0xA493A459, 0xCAB8CA96,
|
||||
0x68A6683B, 0xB883B84D, 0x38203828, 0xE5FFE52E, 0xAD9FAD56, 0x0B770B84,
|
||||
0xC8C3C81D, 0x99CC99FF, 0x580358ED, 0x196F199A, 0x0E080E0A, 0x95BF957E,
|
||||
0x70407050, 0xF7E7F730, 0x6E2B6ECF, 0x1FE21F6E, 0xB579B53D, 0x090C090F,
|
||||
0x61AA6134, 0x57825716, 0x9F419F0B, 0x9D3A9D80, 0x11EA1164, 0x25B925CD,
|
||||
0xAFE4AFDD, 0x459A4508, 0xDFA4DF8D, 0xA397A35C, 0xEA7EEAD5, 0x35DA3558,
|
||||
0xED7AEDD0, 0x431743FC, 0xF866F8CB, 0xFB94FBB1, 0x37A137D3, 0xFA1DFA40,
|
||||
0xC23DC268, 0xB4F0B4CC, 0x32DE325D, 0x9CB39C71, 0x560B56E7, 0xE372E3DA,
|
||||
0x87A78760, 0x151C151B, 0xF9EFF93A, 0x63D163BF, 0x345334A9, 0x9A3E9A85,
|
||||
0xB18FB142, 0x7C337CD1, 0x8826889B, 0x3D5F3DA6, 0xA1ECA1D7, 0xE476E4DF,
|
||||
0x812A8194, 0x91499101, 0x0F810FFB, 0xEE88EEAA, 0x16EE1661, 0xD721D773,
|
||||
0x97C497F5, 0xA51AA5A8, 0xFEEBFE3F, 0x6DD96DB5, 0x78C578AE, 0xC539C56D,
|
||||
0x1D991DE5, 0x76CD76A4, 0x3EAD3EDC, 0xCB31CB67, 0xB68BB647, 0xEF01EF5B,
|
||||
0x1218121E, 0x602360C5, 0x6ADD6AB0, 0x4D1F4DF6, 0xCE4ECEE9, 0xDE2DDE7C,
|
||||
0x55F9559D, 0x7E487E5A, 0x214F21B2, 0x03F2037A, 0xA065A026, 0x5E8E5E19,
|
||||
0x5A785A66, 0x655C654B, 0x6258624E, 0xFD19FD45, 0x068D06F4, 0x40E54086,
|
||||
0xF298F2BE, 0x335733AC, 0x17671790, 0x057F058E, 0xE805E85E, 0x4F644F7D,
|
||||
0x89AF896A, 0x10631095, 0x74B6742F, 0x0AFE0A75, 0x5CF55C92, 0x9BB79B74,
|
||||
0x2D3C2D33, 0x30A530D6, 0x2ECE2E49, 0x49E94989, 0x46684672, 0x77447755,
|
||||
0xA8E0A8D8, 0x964D9604, 0x284328BD, 0xA969A929, 0xD929D979, 0x862E8691,
|
||||
0xD1ACD187, 0xF415F44A, 0x8D598D15, 0xD6A8D682, 0xB90AB9BC, 0x429E420D,
|
||||
0xF66EF6C1, 0x2F472FB8, 0xDDDFDD06, 0x23342339, 0xCC35CC62, 0xF16AF1C4,
|
||||
0xC1CFC112, 0x85DC85EB, 0x8F228F9E, 0x71C971A1, 0x90C090F0, 0xAA9BAA53,
|
||||
0x018901F1, 0x8BD48BE1, 0x4EED4E8C, 0x8EAB8E6F, 0xAB12ABA2, 0x6FA26F3E,
|
||||
0xE60DE654, 0xDB52DBF2, 0x92BB927B, 0xB702B7B6, 0x692F69CA, 0x39A939D9,
|
||||
0xD3D7D30C, 0xA761A723, 0xA21EA2AD, 0xC3B4C399, 0x6C506C44, 0x07040705,
|
||||
0x04F6047F, 0x27C22746, 0xAC16ACA7, 0xD025D076, 0x50865013, 0xDC56DCF7,
|
||||
0x8455841A, 0xE109E151, 0x7ABE7A25, 0x139113EF },
|
||||
|
||||
{ 0xD939A9D9, 0x90176790, 0x719CB371, 0xD2A6E8D2, 0x05070405, 0x9852FD98,
|
||||
0x6580A365, 0xDFE476DF, 0x08459A08, 0x024B9202, 0xA0E080A0, 0x665A7866,
|
||||
0xDDAFE4DD, 0xB06ADDB0, 0xBF63D1BF, 0x362A3836, 0x54E60D54, 0x4320C643,
|
||||
0x62CC3562, 0xBEF298BE, 0x1E12181E, 0x24EBF724, 0xD7A1ECD7, 0x77416C77,
|
||||
0xBD2843BD, 0x32BC7532, 0xD47B37D4, 0x9B88269B, 0x700DFA70, 0xF94413F9,
|
||||
0xB1FB94B1, 0x5A7E485A, 0x7A03F27A, 0xE48CD0E4, 0x47B68B47, 0x3C24303C,
|
||||
0xA5E784A5, 0x416B5441, 0x06DDDF06, 0xC56023C5, 0x45FD1945, 0xA33A5BA3,
|
||||
0x68C23D68, 0x158D5915, 0x21ECF321, 0x3166AE31, 0x3E6FA23E, 0x16578216,
|
||||
0x95106395, 0x5BEF015B, 0x4DB8834D, 0x91862E91, 0xB56DD9B5, 0x1F83511F,
|
||||
0x53AA9B53, 0x635D7C63, 0x3B68A63B, 0x3FFEEB3F, 0xD630A5D6, 0x257ABE25,
|
||||
0xA7AC16A7, 0x0F090C0F, 0x35F0E335, 0x23A76123, 0xF090C0F0, 0xAFE98CAF,
|
||||
0x809D3A80, 0x925CF592, 0x810C7381, 0x27312C27, 0x76D02576, 0xE7560BE7,
|
||||
0x7B92BB7B, 0xE9CE4EE9, 0xF10189F1, 0x9F1E6B9F, 0xA93453A9, 0xC4F16AC4,
|
||||
0x99C3B499, 0x975BF197, 0x8347E183, 0x6B18E66B, 0xC822BDC8, 0x0E98450E,
|
||||
0x6E1FE26E, 0xC9B3F4C9, 0x2F74B62F, 0xCBF866CB, 0xFF99CCFF, 0xEA1495EA,
|
||||
0xED5803ED, 0xF7DC56F7, 0xE18BD4E1, 0x1B151C1B, 0xADA21EAD, 0x0CD3D70C,
|
||||
0x2BE2FB2B, 0x1DC8C31D, 0x195E8E19, 0xC22CB5C2, 0x8949E989, 0x12C1CF12,
|
||||
0x7E95BF7E, 0x207DBA20, 0x6411EA64, 0x840B7784, 0x6DC5396D, 0x6A89AF6A,
|
||||
0xD17C33D1, 0xA171C9A1, 0xCEFF62CE, 0x37BB7137, 0xFB0F81FB, 0x3DB5793D,
|
||||
0x51E10951, 0xDC3EADDC, 0x2D3F242D, 0xA476CDA4, 0x9D55F99D, 0xEE82D8EE,
|
||||
0x8640E586, 0xAE78C5AE, 0xCD25B9CD, 0x04964D04, 0x55774455, 0x0A0E080A,
|
||||
0x13508613, 0x30F7E730, 0xD337A1D3, 0x40FA1D40, 0x3461AA34, 0x8C4EED8C,
|
||||
0xB3B006B3, 0x6C54706C, 0x2A73B22A, 0x523BD252, 0x0B9F410B, 0x8B027B8B,
|
||||
0x88D8A088, 0x4FF3114F, 0x67CB3167, 0x4627C246, 0xC06727C0, 0xB4FC90B4,
|
||||
0x28382028, 0x7F04F67F, 0x78486078, 0x2EE5FF2E, 0x074C9607, 0x4B655C4B,
|
||||
0xC72BB1C7, 0x6F8EAB6F, 0x0D429E0D, 0xBBF59CBB, 0xF2DB52F2, 0xF34A1BF3,
|
||||
0xA63D5FA6, 0x59A49359, 0xBCB90ABC, 0x3AF9EF3A, 0xEF1391EF, 0xFE0885FE,
|
||||
0x01914901, 0x6116EE61, 0x7CDE2D7C, 0xB2214FB2, 0x42B18F42, 0xDB723BDB,
|
||||
0xB82F47B8, 0x48BF8748, 0x2CAE6D2C, 0xE3C046E3, 0x573CD657, 0x859A3E85,
|
||||
0x29A96929, 0x7D4F647D, 0x94812A94, 0x492ECE49, 0x17C6CB17, 0xCA692FCA,
|
||||
0xC3BDFCC3, 0x5CA3975C, 0x5EE8055E, 0xD0ED7AD0, 0x87D1AC87, 0x8E057F8E,
|
||||
0xBA64D5BA, 0xA8A51AA8, 0xB7264BB7, 0xB9BE0EB9, 0x6087A760, 0xF8D55AF8,
|
||||
0x22362822, 0x111B1411, 0xDE753FDE, 0x79D92979, 0xAAEE88AA, 0x332D3C33,
|
||||
0x5F794C5F, 0xB6B702B6, 0x96CAB896, 0x5835DA58, 0x9CC4B09C, 0xFC4317FC,
|
||||
0x1A84551A, 0xF64D1FF6, 0x1C598A1C, 0x38B27D38, 0xAC3357AC, 0x18CFC718,
|
||||
0xF4068DF4, 0x69537469, 0x749BB774, 0xF597C4F5, 0x56AD9F56, 0xDAE372DA,
|
||||
0xD5EA7ED5, 0x4AF4154A, 0x9E8F229E, 0xA2AB12A2, 0x4E62584E, 0xE85F07E8,
|
||||
0xE51D99E5, 0x39233439, 0xC1F66EC1, 0x446C5044, 0x5D32DE5D, 0x72466872,
|
||||
0x26A06526, 0x93CDBC93, 0x03DADB03, 0xC6BAF8C6, 0xFA9EC8FA, 0x82D6A882,
|
||||
0xCF6E2BCF, 0x50704050, 0xEB85DCEB, 0x750AFE75, 0x8A93328A, 0x8DDFA48D,
|
||||
0x4C29CA4C, 0x141C1014, 0x73D72173, 0xCCB4F0CC, 0x09D4D309, 0x108A5D10,
|
||||
0xE2510FE2, 0x00000000, 0x9A196F9A, 0xE01A9DE0, 0x8F94368F, 0xE6C742E6,
|
||||
0xECC94AEC, 0xFDD25EFD, 0xAB7FC1AB, 0xD8A8E0D8 }
|
||||
};
|
||||
|
||||
#define mds(n,x) m_tab[n][x]
|
||||
|
||||
#define q20(x,k) q (0, q (0, x) ^ extract_byte (k[1], 0)) ^ extract_byte (k[0], 0)
|
||||
#define q21(x,k) q (0, q (1, x) ^ extract_byte (k[1], 1)) ^ extract_byte (k[0], 1)
|
||||
#define q22(x,k) q (1, q (0, x) ^ extract_byte (k[1], 2)) ^ extract_byte (k[0], 2)
|
||||
#define q23(x,k) q (1, q (1, x) ^ extract_byte (k[1], 3)) ^ extract_byte (k[0], 3)
|
||||
|
||||
#define q40(x,k) q (0, q (0, q (1, q (1, x) ^ extract_byte (k[3], 0)) ^ extract_byte (k[2], 0)) ^ extract_byte (k[1], 0)) ^ extract_byte (k[0], 0)
|
||||
#define q41(x,k) q (0, q (1, q (1, q (0, x) ^ extract_byte (k[3], 1)) ^ extract_byte (k[2], 1)) ^ extract_byte (k[1], 1)) ^ extract_byte (k[0], 1)
|
||||
#define q42(x,k) q (1, q (0, q (0, q (0, x) ^ extract_byte (k[3], 2)) ^ extract_byte (k[2], 2)) ^ extract_byte (k[1], 2)) ^ extract_byte (k[0], 2)
|
||||
#define q43(x,k) q (1, q (1, q (0, q (1, x) ^ extract_byte (k[3], 3)) ^ extract_byte (k[2], 3)) ^ extract_byte (k[1], 3)) ^ extract_byte (k[0], 3)
|
||||
|
||||
DECLSPEC u32 mds_rem (u32 p0, u32 p1)
|
||||
{
|
||||
#define G_MOD 0x14d
|
||||
|
||||
for (volatile int i = 0; i < 8; i++)
|
||||
{
|
||||
u32 t = p1 >> 24;
|
||||
|
||||
p1 = (p1 << 8) | (p0 >> 24);
|
||||
|
||||
p0 <<= 8;
|
||||
|
||||
u32 u = (t << 1);
|
||||
|
||||
if (t & 0x80) u ^= G_MOD;
|
||||
|
||||
p1 ^= t ^ (u << 16);
|
||||
|
||||
u ^= (t >> 1);
|
||||
|
||||
if (t & 0x01) u ^= G_MOD >> 1;
|
||||
|
||||
p1 ^= (u << 24) | (u << 8);
|
||||
}
|
||||
|
||||
return p1;
|
||||
}
|
||||
|
||||
// 128 bit key
|
||||
|
||||
#define g1_fun128(x) \
|
||||
(mds (0, q20 (extract_byte (x, 3), sk)) ^ \
|
||||
mds (1, q21 (extract_byte (x, 0), sk)) ^ \
|
||||
mds (2, q22 (extract_byte (x, 1), sk)) ^ \
|
||||
mds (3, q23 (extract_byte (x, 2), sk)))
|
||||
|
||||
#define g0_fun128(x) \
|
||||
(mds (0, q20 (extract_byte (x, 0), sk)) ^ \
|
||||
mds (1, q21 (extract_byte (x, 1), sk)) ^ \
|
||||
mds (2, q22 (extract_byte (x, 2), sk)) ^ \
|
||||
mds (3, q23 (extract_byte (x, 3), sk)))
|
||||
|
||||
#define f_rnd128(i) \
|
||||
{ \
|
||||
u32 t0 = g0_fun128 (data[0]); \
|
||||
u32 t1 = g1_fun128 (data[1]); \
|
||||
data[2] = rotr32_S (data[2] ^ (t0 + t1 + lk[4 * (i) + 8]), 1); \
|
||||
data[3] = rotl32_S (data[3], 1) ^ (t0 + 2 * t1 + lk[4 * (i) + 9]); \
|
||||
u32 t2 = g0_fun128 (data[2]); \
|
||||
u32 t3 = g1_fun128 (data[3]); \
|
||||
data[0] = rotr32_S (data[0] ^ (t2 + t3 + lk[4 * (i) + 10]), 1); \
|
||||
data[1] = rotl32_S (data[1], 1) ^ (t2 + 2 * t3 + lk[4 * (i) + 11]); \
|
||||
}
|
||||
|
||||
#define i_rnd128(i) \
|
||||
{ \
|
||||
u32 t0 = g0_fun128 (data[0]); \
|
||||
u32 t1 = g1_fun128 (data[1]); \
|
||||
data[2] = rotl32_S (data[2], 1) ^ (t0 + t1 + lk[4 * (i) + 10]); \
|
||||
data[3] = rotr32_S (data[3] ^ (t0 + 2 * t1 + lk[4 * (i) + 11]), 1); \
|
||||
u32 t2 = g0_fun128 (data[2]); \
|
||||
u32 t3 = g1_fun128 (data[3]); \
|
||||
data[0] = rotl32_S (data[0], 1) ^ (t2 + t3 + lk[4 * (i) + 8]); \
|
||||
data[1] = rotr32_S (data[1] ^ (t2 + 2 * t3 + lk[4 * (i) + 9]), 1); \
|
||||
}
|
||||
|
||||
DECLSPEC u32 h_fun128 (u32 *sk, u32 *lk, const u32 x, const u32 *key)
|
||||
{
|
||||
u32 b0, b1, b2, b3;
|
||||
|
||||
b0 = extract_byte (x, 0);
|
||||
b1 = extract_byte (x, 1);
|
||||
b2 = extract_byte (x, 2);
|
||||
b3 = extract_byte (x, 3);
|
||||
|
||||
b0 = q (0, (q (0, b0) ^ extract_byte (key[1], 0))) ^ extract_byte (key[0], 0);
|
||||
b1 = q (0, (q (1, b1) ^ extract_byte (key[1], 1))) ^ extract_byte (key[0], 1);
|
||||
b2 = q (1, (q (0, b2) ^ extract_byte (key[1], 2))) ^ extract_byte (key[0], 2);
|
||||
b3 = q (1, (q (1, b3) ^ extract_byte (key[1], 3))) ^ extract_byte (key[0], 3);
|
||||
|
||||
return mds (0, b0) ^ mds (1, b1) ^ mds (2, b2) ^ mds (3, b3);
|
||||
}
|
||||
|
||||
DECLSPEC void twofish128_set_key (u32 *sk, u32 *lk, const u32 *ukey)
|
||||
{
|
||||
u32 me_key[2];
|
||||
|
||||
me_key[0] = ukey[0];
|
||||
me_key[1] = ukey[2];
|
||||
|
||||
u32 mo_key[2];
|
||||
|
||||
mo_key[0] = ukey[1];
|
||||
mo_key[1] = ukey[3];
|
||||
|
||||
sk[1] = mds_rem (me_key[0], mo_key[0]);
|
||||
sk[0] = mds_rem (me_key[1], mo_key[1]);
|
||||
|
||||
for (volatile int i = 0; i < 40; i += 2)
|
||||
{
|
||||
u32 a = 0x01010101 * i;
|
||||
u32 b = 0x01010101 + a;
|
||||
|
||||
a = h_fun128 (sk, lk, a, me_key);
|
||||
b = h_fun128 (sk, lk, b, mo_key);
|
||||
|
||||
b = rotl32_S (b, 8);
|
||||
|
||||
lk[i + 0] = a + b;
|
||||
lk[i + 1] = rotl32_S (a + 2 * b, 9);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void twofish128_encrypt (const u32 *sk, const u32 *lk, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 data[4];
|
||||
|
||||
data[0] = in[0] ^ lk[0];
|
||||
data[1] = in[1] ^ lk[1];
|
||||
data[2] = in[2] ^ lk[2];
|
||||
data[3] = in[3] ^ lk[3];
|
||||
|
||||
f_rnd128 (0);
|
||||
f_rnd128 (1);
|
||||
f_rnd128 (2);
|
||||
f_rnd128 (3);
|
||||
f_rnd128 (4);
|
||||
f_rnd128 (5);
|
||||
f_rnd128 (6);
|
||||
f_rnd128 (7);
|
||||
|
||||
out[0] = data[2] ^ lk[4];
|
||||
out[1] = data[3] ^ lk[5];
|
||||
out[2] = data[0] ^ lk[6];
|
||||
out[3] = data[1] ^ lk[7];
|
||||
}
|
||||
|
||||
DECLSPEC void twofish128_decrypt (const u32 *sk, const u32 *lk, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 data[4];
|
||||
|
||||
data[0] = in[0] ^ lk[4];
|
||||
data[1] = in[1] ^ lk[5];
|
||||
data[2] = in[2] ^ lk[6];
|
||||
data[3] = in[3] ^ lk[7];
|
||||
|
||||
i_rnd128 (7);
|
||||
i_rnd128 (6);
|
||||
i_rnd128 (5);
|
||||
i_rnd128 (4);
|
||||
i_rnd128 (3);
|
||||
i_rnd128 (2);
|
||||
i_rnd128 (1);
|
||||
i_rnd128 (0);
|
||||
|
||||
out[0] = data[2] ^ lk[0];
|
||||
out[1] = data[3] ^ lk[1];
|
||||
out[2] = data[0] ^ lk[2];
|
||||
out[3] = data[1] ^ lk[3];
|
||||
}
|
||||
|
||||
// 256 bit key
|
||||
|
||||
#define g1_fun256(x) \
|
||||
(mds (0, q40 (extract_byte (x, 3), sk)) ^ \
|
||||
mds (1, q41 (extract_byte (x, 0), sk)) ^ \
|
||||
mds (2, q42 (extract_byte (x, 1), sk)) ^ \
|
||||
mds (3, q43 (extract_byte (x, 2), sk)))
|
||||
|
||||
#define g0_fun256(x) \
|
||||
(mds (0, q40 (extract_byte (x, 0), sk)) ^ \
|
||||
mds (1, q41 (extract_byte (x, 1), sk)) ^ \
|
||||
mds (2, q42 (extract_byte (x, 2), sk)) ^ \
|
||||
mds (3, q43 (extract_byte (x, 3), sk)))
|
||||
|
||||
#define f_rnd256(i) \
|
||||
{ \
|
||||
u32 t0 = g0_fun256 (data[0]); \
|
||||
u32 t1 = g1_fun256 (data[1]); \
|
||||
data[2] = rotr32_S (data[2] ^ (t0 + t1 + lk[4 * (i) + 8]), 1); \
|
||||
data[3] = rotl32_S (data[3], 1) ^ (t0 + 2 * t1 + lk[4 * (i) + 9]); \
|
||||
u32 t2 = g0_fun256 (data[2]); \
|
||||
u32 t3 = g1_fun256 (data[3]); \
|
||||
data[0] = rotr32_S (data[0] ^ (t2 + t3 + lk[4 * (i) + 10]), 1); \
|
||||
data[1] = rotl32_S (data[1], 1) ^ (t2 + 2 * t3 + lk[4 * (i) + 11]); \
|
||||
}
|
||||
|
||||
#define i_rnd256(i) \
|
||||
{ \
|
||||
u32 t0 = g0_fun256 (data[0]); \
|
||||
u32 t1 = g1_fun256 (data[1]); \
|
||||
data[2] = rotl32_S (data[2], 1) ^ (t0 + t1 + lk[4 * (i) + 10]); \
|
||||
data[3] = rotr32_S (data[3] ^ (t0 + 2 * t1 + lk[4 * (i) + 11]), 1); \
|
||||
u32 t2 = g0_fun256 (data[2]); \
|
||||
u32 t3 = g1_fun256 (data[3]); \
|
||||
data[0] = rotl32_S (data[0], 1) ^ (t2 + t3 + lk[4 * (i) + 8]); \
|
||||
data[1] = rotr32_S (data[1] ^ (t2 + 2 * t3 + lk[4 * (i) + 9]), 1); \
|
||||
}
|
||||
|
||||
DECLSPEC u32 h_fun256 (u32 *sk, u32 *lk, const u32 x, const u32 *key)
|
||||
{
|
||||
u32 b0, b1, b2, b3;
|
||||
|
||||
b0 = extract_byte (x, 0);
|
||||
b1 = extract_byte (x, 1);
|
||||
b2 = extract_byte (x, 2);
|
||||
b3 = extract_byte (x, 3);
|
||||
|
||||
b0 = q (1, b0) ^ extract_byte (key[3], 0);
|
||||
b1 = q (0, b1) ^ extract_byte (key[3], 1);
|
||||
b2 = q (0, b2) ^ extract_byte (key[3], 2);
|
||||
b3 = q (1, b3) ^ extract_byte (key[3], 3);
|
||||
|
||||
b0 = q (1, b0) ^ extract_byte (key[2], 0);
|
||||
b1 = q (1, b1) ^ extract_byte (key[2], 1);
|
||||
b2 = q (0, b2) ^ extract_byte (key[2], 2);
|
||||
b3 = q (0, b3) ^ extract_byte (key[2], 3);
|
||||
|
||||
b0 = q (0, (q (0, b0) ^ extract_byte (key[1], 0))) ^ extract_byte (key[0], 0);
|
||||
b1 = q (0, (q (1, b1) ^ extract_byte (key[1], 1))) ^ extract_byte (key[0], 1);
|
||||
b2 = q (1, (q (0, b2) ^ extract_byte (key[1], 2))) ^ extract_byte (key[0], 2);
|
||||
b3 = q (1, (q (1, b3) ^ extract_byte (key[1], 3))) ^ extract_byte (key[0], 3);
|
||||
|
||||
return mds (0, b0) ^ mds (1, b1) ^ mds (2, b2) ^ mds (3, b3);
|
||||
}
|
||||
|
||||
DECLSPEC void twofish256_set_key (u32 *sk, u32 *lk, const u32 *ukey)
|
||||
{
|
||||
u32 me_key[4];
|
||||
|
||||
me_key[0] = ukey[0];
|
||||
me_key[1] = ukey[2];
|
||||
me_key[2] = ukey[4];
|
||||
me_key[3] = ukey[6];
|
||||
|
||||
u32 mo_key[4];
|
||||
|
||||
mo_key[0] = ukey[1];
|
||||
mo_key[1] = ukey[3];
|
||||
mo_key[2] = ukey[5];
|
||||
mo_key[3] = ukey[7];
|
||||
|
||||
sk[3] = mds_rem (me_key[0], mo_key[0]);
|
||||
sk[2] = mds_rem (me_key[1], mo_key[1]);
|
||||
sk[1] = mds_rem (me_key[2], mo_key[2]);
|
||||
sk[0] = mds_rem (me_key[3], mo_key[3]);
|
||||
|
||||
for (volatile int i = 0; i < 40; i += 2)
|
||||
{
|
||||
u32 a = 0x01010101 * i;
|
||||
u32 b = 0x01010101 + a;
|
||||
|
||||
a = h_fun256 (sk, lk, a, me_key);
|
||||
b = h_fun256 (sk, lk, b, mo_key);
|
||||
|
||||
b = rotl32_S (b, 8);
|
||||
|
||||
lk[i + 0] = a + b;
|
||||
lk[i + 1] = rotl32_S (a + 2 * b, 9);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void twofish256_encrypt (const u32 *sk, const u32 *lk, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 data[4];
|
||||
|
||||
data[0] = in[0] ^ lk[0];
|
||||
data[1] = in[1] ^ lk[1];
|
||||
data[2] = in[2] ^ lk[2];
|
||||
data[3] = in[3] ^ lk[3];
|
||||
|
||||
f_rnd256 (0);
|
||||
f_rnd256 (1);
|
||||
f_rnd256 (2);
|
||||
f_rnd256 (3);
|
||||
f_rnd256 (4);
|
||||
f_rnd256 (5);
|
||||
f_rnd256 (6);
|
||||
f_rnd256 (7);
|
||||
|
||||
out[0] = data[2] ^ lk[4];
|
||||
out[1] = data[3] ^ lk[5];
|
||||
out[2] = data[0] ^ lk[6];
|
||||
out[3] = data[1] ^ lk[7];
|
||||
}
|
||||
|
||||
DECLSPEC void twofish256_decrypt (const u32 *sk, const u32 *lk, const u32 *in, u32 *out)
|
||||
{
|
||||
u32 data[4];
|
||||
|
||||
data[0] = in[0] ^ lk[4];
|
||||
data[1] = in[1] ^ lk[5];
|
||||
data[2] = in[2] ^ lk[6];
|
||||
data[3] = in[3] ^ lk[7];
|
||||
|
||||
i_rnd256 (7);
|
||||
i_rnd256 (6);
|
||||
i_rnd256 (5);
|
||||
i_rnd256 (4);
|
||||
i_rnd256 (3);
|
||||
i_rnd256 (2);
|
||||
i_rnd256 (1);
|
||||
i_rnd256 (0);
|
||||
|
||||
out[0] = data[2] ^ lk[0];
|
||||
out[1] = data[3] ^ lk[1];
|
||||
out[2] = data[0] ^ lk[2];
|
||||
out[3] = data[1] ^ lk[3];
|
||||
}
|
||||
60435
yt/OpenCL/inc_common.cl
Normal file
60435
yt/OpenCL/inc_common.cl
Normal file
File diff suppressed because it is too large
Load Diff
32
yt/OpenCL/inc_comp_multi.cl
Normal file
32
yt/OpenCL/inc_comp_multi.cl
Normal file
@@ -0,0 +1,32 @@
|
||||
u32 digest_tp[4];
|
||||
|
||||
digest_tp[0] = r0;
|
||||
digest_tp[1] = r1;
|
||||
digest_tp[2] = r2;
|
||||
digest_tp[3] = r3;
|
||||
|
||||
if (check (digest_tp,
|
||||
bitmaps_buf_s1_a,
|
||||
bitmaps_buf_s1_b,
|
||||
bitmaps_buf_s1_c,
|
||||
bitmaps_buf_s1_d,
|
||||
bitmaps_buf_s2_a,
|
||||
bitmaps_buf_s2_b,
|
||||
bitmaps_buf_s2_c,
|
||||
bitmaps_buf_s2_d,
|
||||
bitmap_mask,
|
||||
bitmap_shift1,
|
||||
bitmap_shift2))
|
||||
{
|
||||
int digest_pos = find_hash (digest_tp, digests_cnt, &digests_buf[digests_offset]);
|
||||
|
||||
if (digest_pos != -1)
|
||||
{
|
||||
const u32 final_hash_pos = digests_offset + digest_pos;
|
||||
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0)
|
||||
{
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, digest_pos, final_hash_pos, gid, il_pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
35
yt/OpenCL/inc_comp_multi_bs.cl
Normal file
35
yt/OpenCL/inc_comp_multi_bs.cl
Normal file
@@ -0,0 +1,35 @@
|
||||
u32 digest_tp[4];
|
||||
|
||||
digest_tp[0] = r0;
|
||||
digest_tp[1] = r1;
|
||||
digest_tp[2] = r2;
|
||||
digest_tp[3] = r3;
|
||||
|
||||
if (check (digest_tp,
|
||||
bitmaps_buf_s1_a,
|
||||
bitmaps_buf_s1_b,
|
||||
bitmaps_buf_s1_c,
|
||||
bitmaps_buf_s1_d,
|
||||
bitmaps_buf_s2_a,
|
||||
bitmaps_buf_s2_b,
|
||||
bitmaps_buf_s2_c,
|
||||
bitmaps_buf_s2_d,
|
||||
bitmap_mask,
|
||||
bitmap_shift1,
|
||||
bitmap_shift2))
|
||||
{
|
||||
int digest_pos = find_hash (digest_tp, digests_cnt, &digests_buf[digests_offset]);
|
||||
|
||||
if (digest_pos != -1)
|
||||
{
|
||||
if ((il_pos + slice) < il_cnt)
|
||||
{
|
||||
const u32 final_hash_pos = digests_offset + digest_pos;
|
||||
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0)
|
||||
{
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, digest_pos, final_hash_pos, gid, il_pos + slice);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
12
yt/OpenCL/inc_comp_single.cl
Normal file
12
yt/OpenCL/inc_comp_single.cl
Normal file
@@ -0,0 +1,12 @@
|
||||
if ((r0 == search[0])
|
||||
&& (r1 == search[1])
|
||||
&& (r2 == search[2])
|
||||
&& (r3 == search[3]))
|
||||
{
|
||||
const u32 final_hash_pos = digests_offset + 0;
|
||||
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0)
|
||||
{
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, 0, final_hash_pos, gid, il_pos);
|
||||
}
|
||||
}
|
||||
10
yt/OpenCL/inc_comp_single_bs.cl
Normal file
10
yt/OpenCL/inc_comp_single_bs.cl
Normal file
@@ -0,0 +1,10 @@
|
||||
|
||||
if ((il_pos + slice) < il_cnt)
|
||||
{
|
||||
const u32 final_hash_pos = digests_offset + 0;
|
||||
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0)
|
||||
{
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, 0, final_hash_pos, gid, il_pos + slice);
|
||||
}
|
||||
}
|
||||
654
yt/OpenCL/inc_hash_constants.h
Normal file
654
yt/OpenCL/inc_hash_constants.h
Normal file
@@ -0,0 +1,654 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
typedef enum siphash_constants
|
||||
{
|
||||
SIPHASHM_0=0x736f6d6570736575,
|
||||
SIPHASHM_1=0x646f72616e646f6d,
|
||||
SIPHASHM_2=0x6c7967656e657261,
|
||||
SIPHASHM_3=0x7465646279746573
|
||||
|
||||
} siphash_constants_t;
|
||||
|
||||
typedef enum bcrypt_constants
|
||||
{
|
||||
BCRYPTM_0=0x4F727068,
|
||||
BCRYPTM_1=0x65616E42,
|
||||
BCRYPTM_2=0x65686F6C,
|
||||
BCRYPTM_3=0x64657253,
|
||||
BCRYPTM_4=0x63727944,
|
||||
BCRYPTM_5=0x6F756274u
|
||||
|
||||
} bcrypt_constants_t;
|
||||
|
||||
typedef enum md4_constants
|
||||
{
|
||||
MD4M_A=0x67452301,
|
||||
MD4M_B=0xefcdab89,
|
||||
MD4M_C=0x98badcfe,
|
||||
MD4M_D=0x10325476,
|
||||
|
||||
MD4S00=3,
|
||||
MD4S01=7,
|
||||
MD4S02=11,
|
||||
MD4S03=19,
|
||||
MD4S10=3,
|
||||
MD4S11=5,
|
||||
MD4S12=9,
|
||||
MD4S13=13,
|
||||
MD4S20=3,
|
||||
MD4S21=9,
|
||||
MD4S22=11,
|
||||
MD4S23=15,
|
||||
|
||||
MD4C00=0x00000000,
|
||||
MD4C01=0x5a827999,
|
||||
MD4C02=0x6ed9eba1u
|
||||
|
||||
} md4_constants_t;
|
||||
|
||||
typedef enum md5_constants
|
||||
{
|
||||
MD5M_A=0x67452301,
|
||||
MD5M_B=0xefcdab89,
|
||||
MD5M_C=0x98badcfe,
|
||||
MD5M_D=0x10325476,
|
||||
|
||||
MD5S00=7,
|
||||
MD5S01=12,
|
||||
MD5S02=17,
|
||||
MD5S03=22,
|
||||
MD5S10=5,
|
||||
MD5S11=9,
|
||||
MD5S12=14,
|
||||
MD5S13=20,
|
||||
MD5S20=4,
|
||||
MD5S21=11,
|
||||
MD5S22=16,
|
||||
MD5S23=23,
|
||||
MD5S30=6,
|
||||
MD5S31=10,
|
||||
MD5S32=15,
|
||||
MD5S33=21,
|
||||
|
||||
MD5C00=0xd76aa478,
|
||||
MD5C01=0xe8c7b756,
|
||||
MD5C02=0x242070db,
|
||||
MD5C03=0xc1bdceee,
|
||||
MD5C04=0xf57c0faf,
|
||||
MD5C05=0x4787c62a,
|
||||
MD5C06=0xa8304613,
|
||||
MD5C07=0xfd469501,
|
||||
MD5C08=0x698098d8,
|
||||
MD5C09=0x8b44f7af,
|
||||
MD5C0a=0xffff5bb1,
|
||||
MD5C0b=0x895cd7be,
|
||||
MD5C0c=0x6b901122,
|
||||
MD5C0d=0xfd987193,
|
||||
MD5C0e=0xa679438e,
|
||||
MD5C0f=0x49b40821,
|
||||
MD5C10=0xf61e2562,
|
||||
MD5C11=0xc040b340,
|
||||
MD5C12=0x265e5a51,
|
||||
MD5C13=0xe9b6c7aa,
|
||||
MD5C14=0xd62f105d,
|
||||
MD5C15=0x02441453,
|
||||
MD5C16=0xd8a1e681,
|
||||
MD5C17=0xe7d3fbc8,
|
||||
MD5C18=0x21e1cde6,
|
||||
MD5C19=0xc33707d6,
|
||||
MD5C1a=0xf4d50d87,
|
||||
MD5C1b=0x455a14ed,
|
||||
MD5C1c=0xa9e3e905,
|
||||
MD5C1d=0xfcefa3f8,
|
||||
MD5C1e=0x676f02d9,
|
||||
MD5C1f=0x8d2a4c8a,
|
||||
MD5C20=0xfffa3942,
|
||||
MD5C21=0x8771f681,
|
||||
MD5C22=0x6d9d6122,
|
||||
MD5C23=0xfde5380c,
|
||||
MD5C24=0xa4beea44,
|
||||
MD5C25=0x4bdecfa9,
|
||||
MD5C26=0xf6bb4b60,
|
||||
MD5C27=0xbebfbc70,
|
||||
MD5C28=0x289b7ec6,
|
||||
MD5C29=0xeaa127fa,
|
||||
MD5C2a=0xd4ef3085,
|
||||
MD5C2b=0x04881d05,
|
||||
MD5C2c=0xd9d4d039,
|
||||
MD5C2d=0xe6db99e5,
|
||||
MD5C2e=0x1fa27cf8,
|
||||
MD5C2f=0xc4ac5665,
|
||||
MD5C30=0xf4292244,
|
||||
MD5C31=0x432aff97,
|
||||
MD5C32=0xab9423a7,
|
||||
MD5C33=0xfc93a039,
|
||||
MD5C34=0x655b59c3,
|
||||
MD5C35=0x8f0ccc92,
|
||||
MD5C36=0xffeff47d,
|
||||
MD5C37=0x85845dd1,
|
||||
MD5C38=0x6fa87e4f,
|
||||
MD5C39=0xfe2ce6e0,
|
||||
MD5C3a=0xa3014314,
|
||||
MD5C3b=0x4e0811a1,
|
||||
MD5C3c=0xf7537e82,
|
||||
MD5C3d=0xbd3af235,
|
||||
MD5C3e=0x2ad7d2bb,
|
||||
MD5C3f=0xeb86d391u
|
||||
|
||||
} md5_constants_t;
|
||||
|
||||
typedef enum sha1_constants
|
||||
{
|
||||
SHA1M_A=0x67452301,
|
||||
SHA1M_B=0xefcdab89,
|
||||
SHA1M_C=0x98badcfe,
|
||||
SHA1M_D=0x10325476,
|
||||
SHA1M_E=0xc3d2e1f0,
|
||||
|
||||
SHA1C00=0x5a827999,
|
||||
SHA1C01=0x6ed9eba1,
|
||||
SHA1C02=0x8f1bbcdc,
|
||||
SHA1C03=0xca62c1d6u
|
||||
|
||||
} sha1_constants_t;
|
||||
|
||||
typedef enum sha2_32_constants
|
||||
{
|
||||
// SHA-224 Initial Hash Values
|
||||
SHA224M_A=0xc1059ed8,
|
||||
SHA224M_B=0x367cd507,
|
||||
SHA224M_C=0x3070dd17,
|
||||
SHA224M_D=0xf70e5939,
|
||||
SHA224M_E=0xffc00b31,
|
||||
SHA224M_F=0x68581511,
|
||||
SHA224M_G=0x64f98fa7,
|
||||
SHA224M_H=0xbefa4fa4,
|
||||
|
||||
// SHA-256 Initial Hash Values
|
||||
SHA256M_A=0x6a09e667,
|
||||
SHA256M_B=0xbb67ae85,
|
||||
SHA256M_C=0x3c6ef372,
|
||||
SHA256M_D=0xa54ff53a,
|
||||
SHA256M_E=0x510e527f,
|
||||
SHA256M_F=0x9b05688c,
|
||||
SHA256M_G=0x1f83d9ab,
|
||||
SHA256M_H=0x5be0cd19,
|
||||
|
||||
// SHA-224/256 Constants
|
||||
SHA256C00=0x428a2f98,
|
||||
SHA256C01=0x71374491,
|
||||
SHA256C02=0xb5c0fbcf,
|
||||
SHA256C03=0xe9b5dba5,
|
||||
SHA256C04=0x3956c25b,
|
||||
SHA256C05=0x59f111f1,
|
||||
SHA256C06=0x923f82a4,
|
||||
SHA256C07=0xab1c5ed5,
|
||||
SHA256C08=0xd807aa98,
|
||||
SHA256C09=0x12835b01,
|
||||
SHA256C0a=0x243185be,
|
||||
SHA256C0b=0x550c7dc3,
|
||||
SHA256C0c=0x72be5d74,
|
||||
SHA256C0d=0x80deb1fe,
|
||||
SHA256C0e=0x9bdc06a7,
|
||||
SHA256C0f=0xc19bf174,
|
||||
SHA256C10=0xe49b69c1,
|
||||
SHA256C11=0xefbe4786,
|
||||
SHA256C12=0x0fc19dc6,
|
||||
SHA256C13=0x240ca1cc,
|
||||
SHA256C14=0x2de92c6f,
|
||||
SHA256C15=0x4a7484aa,
|
||||
SHA256C16=0x5cb0a9dc,
|
||||
SHA256C17=0x76f988da,
|
||||
SHA256C18=0x983e5152,
|
||||
SHA256C19=0xa831c66d,
|
||||
SHA256C1a=0xb00327c8,
|
||||
SHA256C1b=0xbf597fc7,
|
||||
SHA256C1c=0xc6e00bf3,
|
||||
SHA256C1d=0xd5a79147,
|
||||
SHA256C1e=0x06ca6351,
|
||||
SHA256C1f=0x14292967,
|
||||
SHA256C20=0x27b70a85,
|
||||
SHA256C21=0x2e1b2138,
|
||||
SHA256C22=0x4d2c6dfc,
|
||||
SHA256C23=0x53380d13,
|
||||
SHA256C24=0x650a7354,
|
||||
SHA256C25=0x766a0abb,
|
||||
SHA256C26=0x81c2c92e,
|
||||
SHA256C27=0x92722c85,
|
||||
SHA256C28=0xa2bfe8a1,
|
||||
SHA256C29=0xa81a664b,
|
||||
SHA256C2a=0xc24b8b70,
|
||||
SHA256C2b=0xc76c51a3,
|
||||
SHA256C2c=0xd192e819,
|
||||
SHA256C2d=0xd6990624,
|
||||
SHA256C2e=0xf40e3585,
|
||||
SHA256C2f=0x106aa070,
|
||||
SHA256C30=0x19a4c116,
|
||||
SHA256C31=0x1e376c08,
|
||||
SHA256C32=0x2748774c,
|
||||
SHA256C33=0x34b0bcb5,
|
||||
SHA256C34=0x391c0cb3,
|
||||
SHA256C35=0x4ed8aa4a,
|
||||
SHA256C36=0x5b9cca4f,
|
||||
SHA256C37=0x682e6ff3,
|
||||
SHA256C38=0x748f82ee,
|
||||
SHA256C39=0x78a5636f,
|
||||
SHA256C3a=0x84c87814,
|
||||
SHA256C3b=0x8cc70208,
|
||||
SHA256C3c=0x90befffa,
|
||||
SHA256C3d=0xa4506ceb,
|
||||
SHA256C3e=0xbef9a3f7,
|
||||
SHA256C3f=0xc67178f2
|
||||
|
||||
} sha2_32_constants_t;
|
||||
|
||||
typedef enum sha2_64_constants
|
||||
{
|
||||
// SHA-384 Initial Hash Values
|
||||
SHA384M_A=0xcbbb9d5dc1059ed8,
|
||||
SHA384M_B=0x629a292a367cd507,
|
||||
SHA384M_C=0x9159015a3070dd17,
|
||||
SHA384M_D=0x152fecd8f70e5939,
|
||||
SHA384M_E=0x67332667ffc00b31,
|
||||
SHA384M_F=0x8eb44a8768581511,
|
||||
SHA384M_G=0xdb0c2e0d64f98fa7,
|
||||
SHA384M_H=0x47b5481dbefa4fa4,
|
||||
|
||||
// SHA-512 Initial Hash Values
|
||||
SHA512M_A=0x6a09e667f3bcc908,
|
||||
SHA512M_B=0xbb67ae8584caa73b,
|
||||
SHA512M_C=0x3c6ef372fe94f82b,
|
||||
SHA512M_D=0xa54ff53a5f1d36f1,
|
||||
SHA512M_E=0x510e527fade682d1,
|
||||
SHA512M_F=0x9b05688c2b3e6c1f,
|
||||
SHA512M_G=0x1f83d9abfb41bd6b,
|
||||
SHA512M_H=0x5be0cd19137e2179,
|
||||
|
||||
// SHA-384/512 Constants
|
||||
SHA512C00=0x428a2f98d728ae22,
|
||||
SHA512C01=0x7137449123ef65cd,
|
||||
SHA512C02=0xb5c0fbcfec4d3b2f,
|
||||
SHA512C03=0xe9b5dba58189dbbc,
|
||||
SHA512C04=0x3956c25bf348b538,
|
||||
SHA512C05=0x59f111f1b605d019,
|
||||
SHA512C06=0x923f82a4af194f9b,
|
||||
SHA512C07=0xab1c5ed5da6d8118,
|
||||
SHA512C08=0xd807aa98a3030242,
|
||||
SHA512C09=0x12835b0145706fbe,
|
||||
SHA512C0a=0x243185be4ee4b28c,
|
||||
SHA512C0b=0x550c7dc3d5ffb4e2,
|
||||
SHA512C0c=0x72be5d74f27b896f,
|
||||
SHA512C0d=0x80deb1fe3b1696b1,
|
||||
SHA512C0e=0x9bdc06a725c71235,
|
||||
SHA512C0f=0xc19bf174cf692694,
|
||||
SHA512C10=0xe49b69c19ef14ad2,
|
||||
SHA512C11=0xefbe4786384f25e3,
|
||||
SHA512C12=0x0fc19dc68b8cd5b5,
|
||||
SHA512C13=0x240ca1cc77ac9c65,
|
||||
SHA512C14=0x2de92c6f592b0275,
|
||||
SHA512C15=0x4a7484aa6ea6e483,
|
||||
SHA512C16=0x5cb0a9dcbd41fbd4,
|
||||
SHA512C17=0x76f988da831153b5,
|
||||
SHA512C18=0x983e5152ee66dfab,
|
||||
SHA512C19=0xa831c66d2db43210,
|
||||
SHA512C1a=0xb00327c898fb213f,
|
||||
SHA512C1b=0xbf597fc7beef0ee4,
|
||||
SHA512C1c=0xc6e00bf33da88fc2,
|
||||
SHA512C1d=0xd5a79147930aa725,
|
||||
SHA512C1e=0x06ca6351e003826f,
|
||||
SHA512C1f=0x142929670a0e6e70,
|
||||
SHA512C20=0x27b70a8546d22ffc,
|
||||
SHA512C21=0x2e1b21385c26c926,
|
||||
SHA512C22=0x4d2c6dfc5ac42aed,
|
||||
SHA512C23=0x53380d139d95b3df,
|
||||
SHA512C24=0x650a73548baf63de,
|
||||
SHA512C25=0x766a0abb3c77b2a8,
|
||||
SHA512C26=0x81c2c92e47edaee6,
|
||||
SHA512C27=0x92722c851482353b,
|
||||
SHA512C28=0xa2bfe8a14cf10364,
|
||||
SHA512C29=0xa81a664bbc423001,
|
||||
SHA512C2a=0xc24b8b70d0f89791,
|
||||
SHA512C2b=0xc76c51a30654be30,
|
||||
SHA512C2c=0xd192e819d6ef5218,
|
||||
SHA512C2d=0xd69906245565a910,
|
||||
SHA512C2e=0xf40e35855771202a,
|
||||
SHA512C2f=0x106aa07032bbd1b8,
|
||||
SHA512C30=0x19a4c116b8d2d0c8,
|
||||
SHA512C31=0x1e376c085141ab53,
|
||||
SHA512C32=0x2748774cdf8eeb99,
|
||||
SHA512C33=0x34b0bcb5e19b48a8,
|
||||
SHA512C34=0x391c0cb3c5c95a63,
|
||||
SHA512C35=0x4ed8aa4ae3418acb,
|
||||
SHA512C36=0x5b9cca4f7763e373,
|
||||
SHA512C37=0x682e6ff3d6b2b8a3,
|
||||
SHA512C38=0x748f82ee5defb2fc,
|
||||
SHA512C39=0x78a5636f43172f60,
|
||||
SHA512C3a=0x84c87814a1f0ab72,
|
||||
SHA512C3b=0x8cc702081a6439ec,
|
||||
SHA512C3c=0x90befffa23631e28,
|
||||
SHA512C3d=0xa4506cebde82bde9,
|
||||
SHA512C3e=0xbef9a3f7b2c67915,
|
||||
SHA512C3f=0xc67178f2e372532b,
|
||||
SHA512C40=0xca273eceea26619c,
|
||||
SHA512C41=0xd186b8c721c0c207,
|
||||
SHA512C42=0xeada7dd6cde0eb1e,
|
||||
SHA512C43=0xf57d4f7fee6ed178,
|
||||
SHA512C44=0x06f067aa72176fba,
|
||||
SHA512C45=0x0a637dc5a2c898a6,
|
||||
SHA512C46=0x113f9804bef90dae,
|
||||
SHA512C47=0x1b710b35131c471b,
|
||||
SHA512C48=0x28db77f523047d84,
|
||||
SHA512C49=0x32caab7b40c72493,
|
||||
SHA512C4a=0x3c9ebe0a15c9bebc,
|
||||
SHA512C4b=0x431d67c49c100d4c,
|
||||
SHA512C4c=0x4cc5d4becb3e42b6,
|
||||
SHA512C4d=0x597f299cfc657e2a,
|
||||
SHA512C4e=0x5fcb6fab3ad6faec,
|
||||
SHA512C4f=0x6c44198c4a475817
|
||||
|
||||
} sha2_64_constants_t;
|
||||
|
||||
typedef enum ripemd160_constants
|
||||
{
|
||||
RIPEMD160M_A=0x67452301,
|
||||
RIPEMD160M_B=0xefcdab89,
|
||||
RIPEMD160M_C=0x98badcfe,
|
||||
RIPEMD160M_D=0x10325476,
|
||||
RIPEMD160M_E=0xc3d2e1f0,
|
||||
|
||||
RIPEMD160C00=0x00000000,
|
||||
RIPEMD160C10=0x5a827999,
|
||||
RIPEMD160C20=0x6ed9eba1,
|
||||
RIPEMD160C30=0x8f1bbcdc,
|
||||
RIPEMD160C40=0xa953fd4e,
|
||||
RIPEMD160C50=0x50a28be6,
|
||||
RIPEMD160C60=0x5c4dd124,
|
||||
RIPEMD160C70=0x6d703ef3,
|
||||
RIPEMD160C80=0x7a6d76e9,
|
||||
RIPEMD160C90=0x00000000,
|
||||
|
||||
RIPEMD160S00=11,
|
||||
RIPEMD160S01=14,
|
||||
RIPEMD160S02=15,
|
||||
RIPEMD160S03=12,
|
||||
RIPEMD160S04=5,
|
||||
RIPEMD160S05=8,
|
||||
RIPEMD160S06=7,
|
||||
RIPEMD160S07=9,
|
||||
RIPEMD160S08=11,
|
||||
RIPEMD160S09=13,
|
||||
RIPEMD160S0A=14,
|
||||
RIPEMD160S0B=15,
|
||||
RIPEMD160S0C=6,
|
||||
RIPEMD160S0D=7,
|
||||
RIPEMD160S0E=9,
|
||||
RIPEMD160S0F=8,
|
||||
|
||||
RIPEMD160S10=7,
|
||||
RIPEMD160S11=6,
|
||||
RIPEMD160S12=8,
|
||||
RIPEMD160S13=13,
|
||||
RIPEMD160S14=11,
|
||||
RIPEMD160S15=9,
|
||||
RIPEMD160S16=7,
|
||||
RIPEMD160S17=15,
|
||||
RIPEMD160S18=7,
|
||||
RIPEMD160S19=12,
|
||||
RIPEMD160S1A=15,
|
||||
RIPEMD160S1B=9,
|
||||
RIPEMD160S1C=11,
|
||||
RIPEMD160S1D=7,
|
||||
RIPEMD160S1E=13,
|
||||
RIPEMD160S1F=12,
|
||||
|
||||
RIPEMD160S20=11,
|
||||
RIPEMD160S21=13,
|
||||
RIPEMD160S22=6,
|
||||
RIPEMD160S23=7,
|
||||
RIPEMD160S24=14,
|
||||
RIPEMD160S25=9,
|
||||
RIPEMD160S26=13,
|
||||
RIPEMD160S27=15,
|
||||
RIPEMD160S28=14,
|
||||
RIPEMD160S29=8,
|
||||
RIPEMD160S2A=13,
|
||||
RIPEMD160S2B=6,
|
||||
RIPEMD160S2C=5,
|
||||
RIPEMD160S2D=12,
|
||||
RIPEMD160S2E=7,
|
||||
RIPEMD160S2F=5,
|
||||
|
||||
RIPEMD160S30=11,
|
||||
RIPEMD160S31=12,
|
||||
RIPEMD160S32=14,
|
||||
RIPEMD160S33=15,
|
||||
RIPEMD160S34=14,
|
||||
RIPEMD160S35=15,
|
||||
RIPEMD160S36=9,
|
||||
RIPEMD160S37=8,
|
||||
RIPEMD160S38=9,
|
||||
RIPEMD160S39=14,
|
||||
RIPEMD160S3A=5,
|
||||
RIPEMD160S3B=6,
|
||||
RIPEMD160S3C=8,
|
||||
RIPEMD160S3D=6,
|
||||
RIPEMD160S3E=5,
|
||||
RIPEMD160S3F=12,
|
||||
|
||||
RIPEMD160S40=9,
|
||||
RIPEMD160S41=15,
|
||||
RIPEMD160S42=5,
|
||||
RIPEMD160S43=11,
|
||||
RIPEMD160S44=6,
|
||||
RIPEMD160S45=8,
|
||||
RIPEMD160S46=13,
|
||||
RIPEMD160S47=12,
|
||||
RIPEMD160S48=5,
|
||||
RIPEMD160S49=12,
|
||||
RIPEMD160S4A=13,
|
||||
RIPEMD160S4B=14,
|
||||
RIPEMD160S4C=11,
|
||||
RIPEMD160S4D=8,
|
||||
RIPEMD160S4E=5,
|
||||
RIPEMD160S4F=6,
|
||||
|
||||
RIPEMD160S50=8,
|
||||
RIPEMD160S51=9,
|
||||
RIPEMD160S52=9,
|
||||
RIPEMD160S53=11,
|
||||
RIPEMD160S54=13,
|
||||
RIPEMD160S55=15,
|
||||
RIPEMD160S56=15,
|
||||
RIPEMD160S57=5,
|
||||
RIPEMD160S58=7,
|
||||
RIPEMD160S59=7,
|
||||
RIPEMD160S5A=8,
|
||||
RIPEMD160S5B=11,
|
||||
RIPEMD160S5C=14,
|
||||
RIPEMD160S5D=14,
|
||||
RIPEMD160S5E=12,
|
||||
RIPEMD160S5F=6,
|
||||
|
||||
RIPEMD160S60=9,
|
||||
RIPEMD160S61=13,
|
||||
RIPEMD160S62=15,
|
||||
RIPEMD160S63=7,
|
||||
RIPEMD160S64=12,
|
||||
RIPEMD160S65=8,
|
||||
RIPEMD160S66=9,
|
||||
RIPEMD160S67=11,
|
||||
RIPEMD160S68=7,
|
||||
RIPEMD160S69=7,
|
||||
RIPEMD160S6A=12,
|
||||
RIPEMD160S6B=7,
|
||||
RIPEMD160S6C=6,
|
||||
RIPEMD160S6D=15,
|
||||
RIPEMD160S6E=13,
|
||||
RIPEMD160S6F=11,
|
||||
|
||||
RIPEMD160S70=9,
|
||||
RIPEMD160S71=7,
|
||||
RIPEMD160S72=15,
|
||||
RIPEMD160S73=11,
|
||||
RIPEMD160S74=8,
|
||||
RIPEMD160S75=6,
|
||||
RIPEMD160S76=6,
|
||||
RIPEMD160S77=14,
|
||||
RIPEMD160S78=12,
|
||||
RIPEMD160S79=13,
|
||||
RIPEMD160S7A=5,
|
||||
RIPEMD160S7B=14,
|
||||
RIPEMD160S7C=13,
|
||||
RIPEMD160S7D=13,
|
||||
RIPEMD160S7E=7,
|
||||
RIPEMD160S7F=5,
|
||||
|
||||
RIPEMD160S80=15,
|
||||
RIPEMD160S81=5,
|
||||
RIPEMD160S82=8,
|
||||
RIPEMD160S83=11,
|
||||
RIPEMD160S84=14,
|
||||
RIPEMD160S85=14,
|
||||
RIPEMD160S86=6,
|
||||
RIPEMD160S87=14,
|
||||
RIPEMD160S88=6,
|
||||
RIPEMD160S89=9,
|
||||
RIPEMD160S8A=12,
|
||||
RIPEMD160S8B=9,
|
||||
RIPEMD160S8C=12,
|
||||
RIPEMD160S8D=5,
|
||||
RIPEMD160S8E=15,
|
||||
RIPEMD160S8F=8,
|
||||
|
||||
RIPEMD160S90=8,
|
||||
RIPEMD160S91=5,
|
||||
RIPEMD160S92=12,
|
||||
RIPEMD160S93=9,
|
||||
RIPEMD160S94=12,
|
||||
RIPEMD160S95=5,
|
||||
RIPEMD160S96=14,
|
||||
RIPEMD160S97=6,
|
||||
RIPEMD160S98=8,
|
||||
RIPEMD160S99=13,
|
||||
RIPEMD160S9A=6,
|
||||
RIPEMD160S9B=5,
|
||||
RIPEMD160S9C=15,
|
||||
RIPEMD160S9D=13,
|
||||
RIPEMD160S9E=11,
|
||||
RIPEMD160S9F=11u
|
||||
|
||||
} ripemd160_constants_t;
|
||||
|
||||
typedef enum keccak_constants
|
||||
{
|
||||
KECCAK_RNDC_00=0x0000000000000001,
|
||||
KECCAK_RNDC_01=0x0000000000008082,
|
||||
KECCAK_RNDC_02=0x000000000000808a,
|
||||
KECCAK_RNDC_03=0x0000000080008000,
|
||||
KECCAK_RNDC_04=0x000000000000808b,
|
||||
KECCAK_RNDC_05=0x0000000080000001,
|
||||
KECCAK_RNDC_06=0x0000000080008081,
|
||||
KECCAK_RNDC_07=0x0000000000008009,
|
||||
KECCAK_RNDC_08=0x000000000000008a,
|
||||
KECCAK_RNDC_09=0x0000000000000088,
|
||||
KECCAK_RNDC_10=0x0000000080008009,
|
||||
KECCAK_RNDC_11=0x000000008000000a,
|
||||
KECCAK_RNDC_12=0x000000008000808b,
|
||||
KECCAK_RNDC_13=0x000000000000008b,
|
||||
KECCAK_RNDC_14=0x0000000000008089,
|
||||
KECCAK_RNDC_15=0x0000000000008003,
|
||||
KECCAK_RNDC_16=0x0000000000008002,
|
||||
KECCAK_RNDC_17=0x0000000000000080,
|
||||
KECCAK_RNDC_18=0x000000000000800a,
|
||||
KECCAK_RNDC_19=0x000000008000000a,
|
||||
KECCAK_RNDC_20=0x0000000080008081,
|
||||
KECCAK_RNDC_21=0x0000000000008080,
|
||||
KECCAK_RNDC_22=0x0000000080000001,
|
||||
KECCAK_RNDC_23=0x0000000080008008,
|
||||
|
||||
KECCAK_PILN_00=10,
|
||||
KECCAK_PILN_01=7,
|
||||
KECCAK_PILN_02=11,
|
||||
KECCAK_PILN_03=17,
|
||||
KECCAK_PILN_04=18,
|
||||
KECCAK_PILN_05=3,
|
||||
KECCAK_PILN_06=5,
|
||||
KECCAK_PILN_07=16,
|
||||
KECCAK_PILN_08=8,
|
||||
KECCAK_PILN_09=21,
|
||||
KECCAK_PILN_10=24,
|
||||
KECCAK_PILN_11=4,
|
||||
KECCAK_PILN_12=15,
|
||||
KECCAK_PILN_13=23,
|
||||
KECCAK_PILN_14=19,
|
||||
KECCAK_PILN_15=13,
|
||||
KECCAK_PILN_16=12,
|
||||
KECCAK_PILN_17=2,
|
||||
KECCAK_PILN_18=20,
|
||||
KECCAK_PILN_19=14,
|
||||
KECCAK_PILN_20=22,
|
||||
KECCAK_PILN_21=9,
|
||||
KECCAK_PILN_22=6,
|
||||
KECCAK_PILN_23=1,
|
||||
|
||||
KECCAK_ROTC_00=1,
|
||||
KECCAK_ROTC_01=3,
|
||||
KECCAK_ROTC_02=6,
|
||||
KECCAK_ROTC_03=10,
|
||||
KECCAK_ROTC_04=15,
|
||||
KECCAK_ROTC_05=21,
|
||||
KECCAK_ROTC_06=28,
|
||||
KECCAK_ROTC_07=36,
|
||||
KECCAK_ROTC_08=45,
|
||||
KECCAK_ROTC_09=55,
|
||||
KECCAK_ROTC_10=2,
|
||||
KECCAK_ROTC_11=14,
|
||||
KECCAK_ROTC_12=27,
|
||||
KECCAK_ROTC_13=41,
|
||||
KECCAK_ROTC_14=56,
|
||||
KECCAK_ROTC_15=8,
|
||||
KECCAK_ROTC_16=25,
|
||||
KECCAK_ROTC_17=43,
|
||||
KECCAK_ROTC_18=62,
|
||||
KECCAK_ROTC_19=18,
|
||||
KECCAK_ROTC_20=39,
|
||||
KECCAK_ROTC_21=61,
|
||||
KECCAK_ROTC_22=20,
|
||||
KECCAK_ROTC_23=44,
|
||||
|
||||
} keccak_constants_t;
|
||||
|
||||
typedef enum mysql323_constants
|
||||
{
|
||||
MYSQL323_A=0x50305735,
|
||||
MYSQL323_B=0x12345671u
|
||||
|
||||
} mysql323_constants_t;
|
||||
|
||||
typedef enum fortigate_constants
|
||||
{
|
||||
FORTIGATE_A=0x2eba88a3,
|
||||
FORTIGATE_B=0x4ab04c42,
|
||||
FORTIGATE_C=0xc1307953,
|
||||
FORTIGATE_D=0x3fcc0731,
|
||||
FORTIGATE_E=0x299032a1,
|
||||
FORTIGATE_F=0x705b81a9
|
||||
|
||||
} fortigate_constants_t;
|
||||
|
||||
typedef enum blake2b_constants
|
||||
{
|
||||
BLAKE2B_IV_00=0x6a09e667f3bcc908,
|
||||
BLAKE2B_IV_01=0xbb67ae8584caa73b,
|
||||
BLAKE2B_IV_02=0x3c6ef372fe94f82b,
|
||||
BLAKE2B_IV_03=0xa54ff53a5f1d36f1,
|
||||
BLAKE2B_IV_04=0x510e527fade682d1,
|
||||
BLAKE2B_IV_05=0x9b05688c2b3e6c1f,
|
||||
BLAKE2B_IV_06=0x1f83d9abfb41bd6b,
|
||||
BLAKE2B_IV_07=0x5be0cd19137e2179
|
||||
|
||||
} blake2b_constants_t;
|
||||
|
||||
406
yt/OpenCL/inc_hash_functions.cl
Normal file
406
yt/OpenCL/inc_hash_functions.cl
Normal file
@@ -0,0 +1,406 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define MD4_F_S(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
|
||||
#define MD4_G_S(x,y,z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
|
||||
#define MD4_H_S(x,y,z) ((x) ^ (y) ^ (z))
|
||||
|
||||
#ifdef IS_NV
|
||||
#define MD4_F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
|
||||
#define MD4_G(x,y,z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
|
||||
#define MD4_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD4_Fo(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define MD4_Go(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define MD4_F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
|
||||
#define MD4_G(x,y,z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
|
||||
#define MD4_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD4_Fo(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define MD4_Go(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define MD4_F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
|
||||
#define MD4_G(x,y,z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
|
||||
#define MD4_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD4_Fo(x,y,z) (MD4_F((x), (y), (z)))
|
||||
#define MD4_Go(x,y,z) (MD4_G((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define MD4_STEP_S(f,a,b,c,d,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a = hc_add3_S (a, x, f (b, c, d)); \
|
||||
a = rotl32_S (a, s); \
|
||||
}
|
||||
|
||||
#define MD4_STEP(f,a,b,c,d,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a = hc_add3 (a, x, f (b, c, d)); \
|
||||
a = rotl32 (a, s); \
|
||||
}
|
||||
|
||||
#define MD4_STEP0(f,a,b,c,d,K,s) \
|
||||
{ \
|
||||
a = hc_add3 (a, K, f (b, c, d)); \
|
||||
a = rotl32 (a, s); \
|
||||
}
|
||||
|
||||
#define MD5_F_S(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define MD5_G_S(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))
|
||||
#define MD5_H_S(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD5_I_S(x,y,z) ((y) ^ ((x) | ~(z)))
|
||||
|
||||
#ifdef IS_NV
|
||||
#define MD5_F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define MD5_G(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))
|
||||
#define MD5_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD5_H1(x,y,z) ((t = (x) ^ (y)) ^ (z))
|
||||
#define MD5_H2(x,y,z) ((x) ^ t)
|
||||
#define MD5_I(x,y,z) ((y) ^ ((x) | ~(z)))
|
||||
#define MD5_Fo(x,y,z) (MD5_F((x), (y), (z)))
|
||||
#define MD5_Go(x,y,z) (MD5_G((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define MD5_F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define MD5_G(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))
|
||||
#define MD5_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD5_H1(x,y,z) ((t = (x) ^ (y)) ^ (z))
|
||||
#define MD5_H2(x,y,z) ((x) ^ t)
|
||||
#define MD5_I(x,y,z) ((y) ^ ((x) | ~(z)))
|
||||
#define MD5_Fo(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define MD5_Go(x,y,z) (bitselect ((y), (x), (z)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define MD5_F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define MD5_G(x,y,z) ((y) ^ ((z) & ((x) ^ (y))))
|
||||
#define MD5_H(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define MD5_H1(x,y,z) ((t = (x) ^ (y)) ^ (z))
|
||||
#define MD5_H2(x,y,z) ((x) ^ t)
|
||||
#define MD5_I(x,y,z) ((y) ^ ((x) | ~(z)))
|
||||
#define MD5_Fo(x,y,z) (MD5_F((x), (y), (z)))
|
||||
#define MD5_Go(x,y,z) (MD5_G((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define MD5_STEP_S(f,a,b,c,d,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a = hc_add3_S (a, x, f (b, c, d)); \
|
||||
a = rotl32_S (a, s); \
|
||||
a += b; \
|
||||
}
|
||||
|
||||
#define MD5_STEP(f,a,b,c,d,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a = hc_add3 (a, x, f (b, c, d)); \
|
||||
a = rotl32 (a, s); \
|
||||
a += b; \
|
||||
}
|
||||
|
||||
#define MD5_STEP0(f,a,b,c,d,K,s) \
|
||||
{ \
|
||||
a = hc_add3 (a, K, f (b, c, d)); \
|
||||
a = rotl32 (a, s); \
|
||||
a += b; \
|
||||
}
|
||||
|
||||
#ifdef IS_NV
|
||||
#define SHA1_F0(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA1_F1(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define SHA1_F2(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA1_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA1_F2o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define SHA1_F0(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA1_F1(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define SHA1_F2(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA1_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA1_F2o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define SHA1_F0(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA1_F1(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define SHA1_F2(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA1_F0o(x,y,z) (SHA1_F0 ((x), (y), (z)))
|
||||
#define SHA1_F2o(x,y,z) (SHA1_F2 ((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define SHA1_STEP_S(f,a,b,c,d,e,x) \
|
||||
{ \
|
||||
e += K; \
|
||||
e = hc_add3_S (e, x, f (b, c, d)); \
|
||||
e += rotl32_S (a, 5u); \
|
||||
b = rotl32_S (b, 30u); \
|
||||
}
|
||||
|
||||
#define SHA1_STEP(f,a,b,c,d,e,x) \
|
||||
{ \
|
||||
e += K; \
|
||||
e = hc_add3 (e, x, f (b, c, d)); \
|
||||
e += rotl32 (a, 5u); \
|
||||
b = rotl32 (b, 30u); \
|
||||
}
|
||||
|
||||
/*
|
||||
#define SHA1_STEP0(f,a,b,c,d,e,x) \
|
||||
{ \
|
||||
e = hc_add3 (e, K, f (b, c, d)); \
|
||||
e += rotl32 (a, 5u); \
|
||||
b = rotl32 (b, 30u); \
|
||||
}
|
||||
*/
|
||||
|
||||
#define SHA1_STEPX(f,a,b,c,d,e,x) \
|
||||
{ \
|
||||
e = hc_add3 (e, x, f (b, c, d)); \
|
||||
e += rotl32 (a, 5u); \
|
||||
b = rotl32 (b, 30u); \
|
||||
}
|
||||
|
||||
#define SHIFT_RIGHT_32(x,n) ((x) >> (n))
|
||||
|
||||
#define SHA256_S0_S(x) (rotl32_S ((x), 25u) ^ rotl32_S ((x), 14u) ^ SHIFT_RIGHT_32 ((x), 3u))
|
||||
#define SHA256_S1_S(x) (rotl32_S ((x), 15u) ^ rotl32_S ((x), 13u) ^ SHIFT_RIGHT_32 ((x), 10u))
|
||||
#define SHA256_S2_S(x) (rotl32_S ((x), 30u) ^ rotl32_S ((x), 19u) ^ rotl32_S ((x), 10u))
|
||||
#define SHA256_S3_S(x) (rotl32_S ((x), 26u) ^ rotl32_S ((x), 21u) ^ rotl32_S ((x), 7u))
|
||||
|
||||
#define SHA256_S0(x) (rotl32 ((x), 25u) ^ rotl32 ((x), 14u) ^ SHIFT_RIGHT_32 ((x), 3u))
|
||||
#define SHA256_S1(x) (rotl32 ((x), 15u) ^ rotl32 ((x), 13u) ^ SHIFT_RIGHT_32 ((x), 10u))
|
||||
#define SHA256_S2(x) (rotl32 ((x), 30u) ^ rotl32 ((x), 19u) ^ rotl32 ((x), 10u))
|
||||
#define SHA256_S3(x) (rotl32 ((x), 26u) ^ rotl32 ((x), 21u) ^ rotl32 ((x), 7u))
|
||||
|
||||
#ifdef IS_NV
|
||||
#define SHA256_F0(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA256_F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA256_F0o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#define SHA256_F1o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define SHA256_F0(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA256_F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA256_F0o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#define SHA256_F1o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define SHA256_F0(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
#define SHA256_F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA256_F0o(x,y,z) (SHA256_F0 ((x), (y), (z)))
|
||||
#define SHA256_F1o(x,y,z) (SHA256_F1 ((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define SHA256_STEP_S(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h = hc_add3_S (h, K, x); \
|
||||
h = hc_add3_S (h, SHA256_S3_S (e), F1 (e,f,g)); \
|
||||
d += h; \
|
||||
h = hc_add3_S (h, SHA256_S2_S (a), F0 (a,b,c)); \
|
||||
}
|
||||
|
||||
#define SHA256_EXPAND_S(x,y,z,w) (SHA256_S1_S (x) + y + SHA256_S0_S (z) + w)
|
||||
|
||||
#define SHA256_STEP(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h = hc_add3 (h, K, x); \
|
||||
h = hc_add3 (h, SHA256_S3 (e), F1 (e,f,g)); \
|
||||
d += h; \
|
||||
h = hc_add3 (h, SHA256_S2 (a), F0 (a,b,c)); \
|
||||
}
|
||||
|
||||
#define SHA256_EXPAND(x,y,z,w) (SHA256_S1 (x) + y + SHA256_S0 (z) + w)
|
||||
|
||||
#define SHIFT_RIGHT_64(x,n) ((x) >> (n))
|
||||
|
||||
#define SHA384_S0_S(x) (rotr64_S ((x), 28) ^ rotr64_S ((x), 34) ^ rotr64_S ((x), 39))
|
||||
#define SHA384_S1_S(x) (rotr64_S ((x), 14) ^ rotr64_S ((x), 18) ^ rotr64_S ((x), 41))
|
||||
#define SHA384_S2_S(x) (rotr64_S ((x), 1) ^ rotr64_S ((x), 8) ^ SHIFT_RIGHT_64 ((x), 7))
|
||||
#define SHA384_S3_S(x) (rotr64_S ((x), 19) ^ rotr64_S ((x), 61) ^ SHIFT_RIGHT_64 ((x), 6))
|
||||
|
||||
#define SHA384_S0(x) (rotr64 ((x), 28) ^ rotr64 ((x), 34) ^ rotr64 ((x), 39))
|
||||
#define SHA384_S1(x) (rotr64 ((x), 14) ^ rotr64 ((x), 18) ^ rotr64 ((x), 41))
|
||||
#define SHA384_S2(x) (rotr64 ((x), 1) ^ rotr64 ((x), 8) ^ SHIFT_RIGHT_64 ((x), 7))
|
||||
#define SHA384_S3(x) (rotr64 ((x), 19) ^ rotr64 ((x), 61) ^ SHIFT_RIGHT_64 ((x), 6))
|
||||
|
||||
#define SHA384_F0(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA384_F1(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
|
||||
#ifdef IS_NV
|
||||
#define SHA384_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA384_F1o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define SHA384_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA384_F1o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define SHA384_F0o(x,y,z) (SHA384_F0 ((x), (y), (z)))
|
||||
#define SHA384_F1o(x,y,z) (SHA384_F1 ((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define SHA384_STEP_S(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h += K; \
|
||||
h += x; \
|
||||
h += SHA384_S1_S (e); \
|
||||
h += F0 (e, f, g); \
|
||||
d += h; \
|
||||
h += SHA384_S0_S (a); \
|
||||
h += F1 (a, b, c); \
|
||||
}
|
||||
|
||||
#define SHA384_EXPAND_S(x,y,z,w) (SHA384_S3_S (x) + y + SHA384_S2_S (z) + w)
|
||||
|
||||
#define SHA384_STEP(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h += K; \
|
||||
h += x; \
|
||||
h += SHA384_S1 (e); \
|
||||
h += F0 (e, f, g); \
|
||||
d += h; \
|
||||
h += SHA384_S0 (a); \
|
||||
h += F1 (a, b, c); \
|
||||
}
|
||||
|
||||
#define SHA384_EXPAND(x,y,z,w) (SHA384_S3 (x) + y + SHA384_S2 (z) + w)
|
||||
|
||||
#define SHIFT_RIGHT_64(x,n) ((x) >> (n))
|
||||
|
||||
#define SHA512_S0_S(x) (rotr64_S ((x), 28) ^ rotr64_S ((x), 34) ^ rotr64_S ((x), 39))
|
||||
#define SHA512_S1_S(x) (rotr64_S ((x), 14) ^ rotr64_S ((x), 18) ^ rotr64_S ((x), 41))
|
||||
#define SHA512_S2_S(x) (rotr64_S ((x), 1) ^ rotr64_S ((x), 8) ^ SHIFT_RIGHT_64 ((x), 7))
|
||||
#define SHA512_S3_S(x) (rotr64_S ((x), 19) ^ rotr64_S ((x), 61) ^ SHIFT_RIGHT_64 ((x), 6))
|
||||
|
||||
#define SHA512_S0(x) (rotr64 ((x), 28) ^ rotr64 ((x), 34) ^ rotr64 ((x), 39))
|
||||
#define SHA512_S1(x) (rotr64 ((x), 14) ^ rotr64 ((x), 18) ^ rotr64 ((x), 41))
|
||||
#define SHA512_S2(x) (rotr64 ((x), 1) ^ rotr64 ((x), 8) ^ SHIFT_RIGHT_64 ((x), 7))
|
||||
#define SHA512_S3(x) (rotr64 ((x), 19) ^ rotr64 ((x), 61) ^ SHIFT_RIGHT_64 ((x), 6))
|
||||
|
||||
#define SHA512_F0(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
||||
#define SHA512_F1(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
|
||||
|
||||
#ifdef IS_NV
|
||||
#define SHA512_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA512_F1o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define SHA512_F0o(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define SHA512_F1o(x,y,z) (bitselect ((x), (y), ((x) ^ (z))))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define SHA512_F0o(x,y,z) (SHA512_F0 ((x), (y), (z)))
|
||||
#define SHA512_F1o(x,y,z) (SHA512_F1 ((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define SHA512_STEP_S(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h += K; \
|
||||
h += x; \
|
||||
h += SHA512_S1_S (e); \
|
||||
h += F0 (e, f, g); \
|
||||
d += h; \
|
||||
h += SHA512_S0_S (a); \
|
||||
h += F1 (a, b, c); \
|
||||
}
|
||||
|
||||
#define SHA512_EXPAND_S(x,y,z,w) (SHA512_S3_S (x) + y + SHA512_S2_S (z) + w)
|
||||
|
||||
#define SHA512_STEP(F0,F1,a,b,c,d,e,f,g,h,x,K) \
|
||||
{ \
|
||||
h += K; \
|
||||
h += x; \
|
||||
h += SHA512_S1 (e); \
|
||||
h += F0 (e, f, g); \
|
||||
d += h; \
|
||||
h += SHA512_S0 (a); \
|
||||
h += F1 (a, b, c); \
|
||||
}
|
||||
|
||||
#define SHA512_EXPAND(x,y,z,w) (SHA512_S3 (x) + y + SHA512_S2 (z) + w)
|
||||
|
||||
#ifdef IS_NV
|
||||
#define RIPEMD160_F(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define RIPEMD160_G(x,y,z) ((z) ^ ((x) & ((y) ^ (z)))) /* x ? y : z */
|
||||
#define RIPEMD160_H(x,y,z) (((x) | ~(y)) ^ (z))
|
||||
#define RIPEMD160_I(x,y,z) ((y) ^ ((z) & ((x) ^ (y)))) /* z ? x : y */
|
||||
#define RIPEMD160_J(x,y,z) ((x) ^ ((y) | ~(z)))
|
||||
#define RIPEMD160_Go(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define RIPEMD160_Io(x,y,z) (bitselect ((y), (x), (z)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_AMD
|
||||
#define RIPEMD160_F(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define RIPEMD160_G(x,y,z) ((z) ^ ((x) & ((y) ^ (z)))) /* x ? y : z */
|
||||
#define RIPEMD160_H(x,y,z) (((x) | ~(y)) ^ (z))
|
||||
#define RIPEMD160_I(x,y,z) ((y) ^ ((z) & ((x) ^ (y)))) /* z ? x : y */
|
||||
#define RIPEMD160_J(x,y,z) ((x) ^ ((y) | ~(z)))
|
||||
#define RIPEMD160_Go(x,y,z) (bitselect ((z), (y), (x)))
|
||||
#define RIPEMD160_Io(x,y,z) (bitselect ((y), (x), (z)))
|
||||
#endif
|
||||
|
||||
#ifdef IS_GENERIC
|
||||
#define RIPEMD160_F(x,y,z) ((x) ^ (y) ^ (z))
|
||||
#define RIPEMD160_G(x,y,z) ((z) ^ ((x) & ((y) ^ (z)))) /* x ? y : z */
|
||||
#define RIPEMD160_H(x,y,z) (((x) | ~(y)) ^ (z))
|
||||
#define RIPEMD160_I(x,y,z) ((y) ^ ((z) & ((x) ^ (y)))) /* z ? x : y */
|
||||
#define RIPEMD160_J(x,y,z) ((x) ^ ((y) | ~(z)))
|
||||
#define RIPEMD160_Go(x,y,z) (RIPEMD160_G ((x), (y), (z)))
|
||||
#define RIPEMD160_Io(x,y,z) (RIPEMD160_I ((x), (y), (z)))
|
||||
#endif
|
||||
|
||||
#define RIPEMD160_STEP_S(f,a,b,c,d,e,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a += x; \
|
||||
a += f (b, c, d); \
|
||||
a = rotl32_S (a, s); \
|
||||
a += e; \
|
||||
c = rotl32_S (c, 10u); \
|
||||
}
|
||||
|
||||
#define RIPEMD160_STEP(f,a,b,c,d,e,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a += x; \
|
||||
a += f (b, c, d); \
|
||||
a = rotl32 (a, s); \
|
||||
a += e; \
|
||||
c = rotl32 (c, 10u); \
|
||||
}
|
||||
|
||||
#define ROTATE_LEFT_WORKAROUND_BUG(a,n) ((a << n) | (a >> (32 - n)))
|
||||
|
||||
#define RIPEMD160_STEP_S_WORKAROUND_BUG(f,a,b,c,d,e,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a += x; \
|
||||
a += f (b, c, d); \
|
||||
a = ROTATE_LEFT_WORKAROUND_BUG (a, s); \
|
||||
a += e; \
|
||||
c = rotl32_S (c, 10u); \
|
||||
}
|
||||
|
||||
#define RIPEMD160_STEP_WORKAROUND_BUG(f,a,b,c,d,e,x,K,s) \
|
||||
{ \
|
||||
a += K; \
|
||||
a += x; \
|
||||
a += f (b, c, d); \
|
||||
a = ROTATE_LEFT_WORKAROUND_BUG (a, s); \
|
||||
a += e; \
|
||||
c = rotl32 (c, 10u); \
|
||||
}
|
||||
1754
yt/OpenCL/inc_hash_md4.cl
Normal file
1754
yt/OpenCL/inc_hash_md4.cl
Normal file
File diff suppressed because it is too large
Load Diff
1826
yt/OpenCL/inc_hash_md5.cl
Normal file
1826
yt/OpenCL/inc_hash_md5.cl
Normal file
File diff suppressed because it is too large
Load Diff
2023
yt/OpenCL/inc_hash_ripemd160.cl
Normal file
2023
yt/OpenCL/inc_hash_ripemd160.cl
Normal file
File diff suppressed because it is too large
Load Diff
2207
yt/OpenCL/inc_hash_sha1.cl
Normal file
2207
yt/OpenCL/inc_hash_sha1.cl
Normal file
File diff suppressed because it is too large
Load Diff
1882
yt/OpenCL/inc_hash_sha224.cl
Normal file
1882
yt/OpenCL/inc_hash_sha224.cl
Normal file
File diff suppressed because it is too large
Load Diff
1882
yt/OpenCL/inc_hash_sha256.cl
Normal file
1882
yt/OpenCL/inc_hash_sha256.cl
Normal file
File diff suppressed because it is too large
Load Diff
2946
yt/OpenCL/inc_hash_sha384.cl
Normal file
2946
yt/OpenCL/inc_hash_sha384.cl
Normal file
File diff suppressed because it is too large
Load Diff
2946
yt/OpenCL/inc_hash_sha512.cl
Normal file
2946
yt/OpenCL/inc_hash_sha512.cl
Normal file
File diff suppressed because it is too large
Load Diff
3131
yt/OpenCL/inc_hash_whirlpool.cl
Normal file
3131
yt/OpenCL/inc_hash_whirlpool.cl
Normal file
File diff suppressed because it is too large
Load Diff
4029
yt/OpenCL/inc_luks_aes.cl
Normal file
4029
yt/OpenCL/inc_luks_aes.cl
Normal file
File diff suppressed because it is too large
Load Diff
1407
yt/OpenCL/inc_luks_af.cl
Normal file
1407
yt/OpenCL/inc_luks_af.cl
Normal file
File diff suppressed because it is too large
Load Diff
198
yt/OpenCL/inc_luks_essiv.cl
Normal file
198
yt/OpenCL/inc_luks_essiv.cl
Normal file
@@ -0,0 +1,198 @@
|
||||
__constant u32a ESSIV_k_sha256[64] =
|
||||
{
|
||||
SHA256C00, SHA256C01, SHA256C02, SHA256C03,
|
||||
SHA256C04, SHA256C05, SHA256C06, SHA256C07,
|
||||
SHA256C08, SHA256C09, SHA256C0a, SHA256C0b,
|
||||
SHA256C0c, SHA256C0d, SHA256C0e, SHA256C0f,
|
||||
SHA256C10, SHA256C11, SHA256C12, SHA256C13,
|
||||
SHA256C14, SHA256C15, SHA256C16, SHA256C17,
|
||||
SHA256C18, SHA256C19, SHA256C1a, SHA256C1b,
|
||||
SHA256C1c, SHA256C1d, SHA256C1e, SHA256C1f,
|
||||
SHA256C20, SHA256C21, SHA256C22, SHA256C23,
|
||||
SHA256C24, SHA256C25, SHA256C26, SHA256C27,
|
||||
SHA256C28, SHA256C29, SHA256C2a, SHA256C2b,
|
||||
SHA256C2c, SHA256C2d, SHA256C2e, SHA256C2f,
|
||||
SHA256C30, SHA256C31, SHA256C32, SHA256C33,
|
||||
SHA256C34, SHA256C35, SHA256C36, SHA256C37,
|
||||
SHA256C38, SHA256C39, SHA256C3a, SHA256C3b,
|
||||
SHA256C3c, SHA256C3d, SHA256C3e, SHA256C3f,
|
||||
};
|
||||
|
||||
// basically a normal sha256_transform() but with a different name to avoid collisions with function nameing
|
||||
DECLSPEC void ESSIV_sha256_transform_S (const u32 *w0, const u32 *w1, const u32 *w2, const u32 *w3, u32 *digest)
|
||||
{
|
||||
u32 a = digest[0];
|
||||
u32 b = digest[1];
|
||||
u32 c = digest[2];
|
||||
u32 d = digest[3];
|
||||
u32 e = digest[4];
|
||||
u32 f = digest[5];
|
||||
u32 g = digest[6];
|
||||
u32 h = digest[7];
|
||||
|
||||
u32 w0_t = w0[0];
|
||||
u32 w1_t = w0[1];
|
||||
u32 w2_t = w0[2];
|
||||
u32 w3_t = w0[3];
|
||||
u32 w4_t = w1[0];
|
||||
u32 w5_t = w1[1];
|
||||
u32 w6_t = w1[2];
|
||||
u32 w7_t = w1[3];
|
||||
u32 w8_t = w2[0];
|
||||
u32 w9_t = w2[1];
|
||||
u32 wa_t = w2[2];
|
||||
u32 wb_t = w2[3];
|
||||
u32 wc_t = w3[0];
|
||||
u32 wd_t = w3[1];
|
||||
u32 we_t = w3[2];
|
||||
u32 wf_t = w3[3];
|
||||
|
||||
#define ESSIV_ROUND_EXPAND_S() \
|
||||
{ \
|
||||
w0_t = SHA256_EXPAND_S (we_t, w9_t, w1_t, w0_t); \
|
||||
w1_t = SHA256_EXPAND_S (wf_t, wa_t, w2_t, w1_t); \
|
||||
w2_t = SHA256_EXPAND_S (w0_t, wb_t, w3_t, w2_t); \
|
||||
w3_t = SHA256_EXPAND_S (w1_t, wc_t, w4_t, w3_t); \
|
||||
w4_t = SHA256_EXPAND_S (w2_t, wd_t, w5_t, w4_t); \
|
||||
w5_t = SHA256_EXPAND_S (w3_t, we_t, w6_t, w5_t); \
|
||||
w6_t = SHA256_EXPAND_S (w4_t, wf_t, w7_t, w6_t); \
|
||||
w7_t = SHA256_EXPAND_S (w5_t, w0_t, w8_t, w7_t); \
|
||||
w8_t = SHA256_EXPAND_S (w6_t, w1_t, w9_t, w8_t); \
|
||||
w9_t = SHA256_EXPAND_S (w7_t, w2_t, wa_t, w9_t); \
|
||||
wa_t = SHA256_EXPAND_S (w8_t, w3_t, wb_t, wa_t); \
|
||||
wb_t = SHA256_EXPAND_S (w9_t, w4_t, wc_t, wb_t); \
|
||||
wc_t = SHA256_EXPAND_S (wa_t, w5_t, wd_t, wc_t); \
|
||||
wd_t = SHA256_EXPAND_S (wb_t, w6_t, we_t, wd_t); \
|
||||
we_t = SHA256_EXPAND_S (wc_t, w7_t, wf_t, we_t); \
|
||||
wf_t = SHA256_EXPAND_S (wd_t, w8_t, w0_t, wf_t); \
|
||||
}
|
||||
|
||||
#define ESSIV_ROUND_STEP_S(i) \
|
||||
{ \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, ESSIV_k_sha256[i + 0]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, ESSIV_k_sha256[i + 1]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, ESSIV_k_sha256[i + 2]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, ESSIV_k_sha256[i + 3]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, ESSIV_k_sha256[i + 4]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, ESSIV_k_sha256[i + 5]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, ESSIV_k_sha256[i + 6]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, ESSIV_k_sha256[i + 7]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, ESSIV_k_sha256[i + 8]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, ESSIV_k_sha256[i + 9]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, ESSIV_k_sha256[i + 10]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, ESSIV_k_sha256[i + 11]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, ESSIV_k_sha256[i + 12]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, ESSIV_k_sha256[i + 13]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, ESSIV_k_sha256[i + 14]); \
|
||||
SHA256_STEP_S (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, ESSIV_k_sha256[i + 15]); \
|
||||
}
|
||||
|
||||
ESSIV_ROUND_STEP_S (0);
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 16; i < 64; i += 16)
|
||||
{
|
||||
ESSIV_ROUND_EXPAND_S (); ESSIV_ROUND_STEP_S (i);
|
||||
}
|
||||
|
||||
digest[0] += a;
|
||||
digest[1] += b;
|
||||
digest[2] += c;
|
||||
digest[3] += d;
|
||||
digest[4] += e;
|
||||
digest[5] += f;
|
||||
digest[6] += g;
|
||||
digest[7] += h;
|
||||
}
|
||||
|
||||
DECLSPEC void ESSIV_sha256_init128 (u32 *key, u32 *essivhash)
|
||||
{
|
||||
essivhash[0] = SHA256M_A;
|
||||
essivhash[1] = SHA256M_B;
|
||||
essivhash[2] = SHA256M_C;
|
||||
essivhash[3] = SHA256M_D;
|
||||
essivhash[4] = SHA256M_E;
|
||||
essivhash[5] = SHA256M_F;
|
||||
essivhash[6] = SHA256M_G;
|
||||
essivhash[7] = SHA256M_H;
|
||||
|
||||
u32 w0[4];
|
||||
u32 w1[4];
|
||||
u32 w2[4];
|
||||
u32 w3[4];
|
||||
|
||||
w0[0] = swap32_S (key[0]);
|
||||
w0[1] = swap32_S (key[1]);
|
||||
w0[2] = swap32_S (key[2]);
|
||||
w0[3] = swap32_S (key[3]);
|
||||
w1[0] = 0x80000000;
|
||||
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] = 16 * 8;
|
||||
|
||||
ESSIV_sha256_transform_S (w0, w1, w2, w3, essivhash);
|
||||
|
||||
essivhash[0] = swap32_S (essivhash[0]);
|
||||
essivhash[1] = swap32_S (essivhash[1]);
|
||||
essivhash[2] = swap32_S (essivhash[2]);
|
||||
essivhash[3] = swap32_S (essivhash[3]);
|
||||
essivhash[4] = swap32_S (essivhash[4]);
|
||||
essivhash[5] = swap32_S (essivhash[5]);
|
||||
essivhash[6] = swap32_S (essivhash[6]);
|
||||
essivhash[7] = swap32_S (essivhash[7]);
|
||||
}
|
||||
|
||||
DECLSPEC void ESSIV_sha256_init256 (u32 *key, u32 *essivhash)
|
||||
{
|
||||
essivhash[0] = SHA256M_A;
|
||||
essivhash[1] = SHA256M_B;
|
||||
essivhash[2] = SHA256M_C;
|
||||
essivhash[3] = SHA256M_D;
|
||||
essivhash[4] = SHA256M_E;
|
||||
essivhash[5] = SHA256M_F;
|
||||
essivhash[6] = SHA256M_G;
|
||||
essivhash[7] = SHA256M_H;
|
||||
|
||||
u32 w0[4];
|
||||
u32 w1[4];
|
||||
u32 w2[4];
|
||||
u32 w3[4];
|
||||
|
||||
w0[0] = swap32_S (key[0]);
|
||||
w0[1] = swap32_S (key[1]);
|
||||
w0[2] = swap32_S (key[2]);
|
||||
w0[3] = swap32_S (key[3]);
|
||||
w1[0] = swap32_S (key[4]);
|
||||
w1[1] = swap32_S (key[5]);
|
||||
w1[2] = swap32_S (key[6]);
|
||||
w1[3] = swap32_S (key[7]);
|
||||
w2[0] = 0x80000000;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 32 * 8;
|
||||
|
||||
ESSIV_sha256_transform_S (w0, w1, w2, w3, essivhash);
|
||||
|
||||
essivhash[0] = swap32_S (essivhash[0]);
|
||||
essivhash[1] = swap32_S (essivhash[1]);
|
||||
essivhash[2] = swap32_S (essivhash[2]);
|
||||
essivhash[3] = swap32_S (essivhash[3]);
|
||||
essivhash[4] = swap32_S (essivhash[4]);
|
||||
essivhash[5] = swap32_S (essivhash[5]);
|
||||
essivhash[6] = swap32_S (essivhash[6]);
|
||||
essivhash[7] = swap32_S (essivhash[7]);
|
||||
}
|
||||
3997
yt/OpenCL/inc_luks_serpent.cl
Normal file
3997
yt/OpenCL/inc_luks_serpent.cl
Normal file
File diff suppressed because it is too large
Load Diff
3997
yt/OpenCL/inc_luks_twofish.cl
Normal file
3997
yt/OpenCL/inc_luks_twofish.cl
Normal file
File diff suppressed because it is too large
Load Diff
11
yt/OpenCL/inc_luks_xts.cl
Normal file
11
yt/OpenCL/inc_luks_xts.cl
Normal file
@@ -0,0 +1,11 @@
|
||||
DECLSPEC void xts_mul2 (u32 *in, u32 *out)
|
||||
{
|
||||
const u32 c = in[3] >> 31;
|
||||
|
||||
out[3] = (in[3] << 1) | (in[2] >> 31);
|
||||
out[2] = (in[2] << 1) | (in[1] >> 31);
|
||||
out[1] = (in[1] << 1) | (in[0] >> 31);
|
||||
out[0] = (in[0] << 1);
|
||||
|
||||
out[0] ^= c * 0x87;
|
||||
}
|
||||
749
yt/OpenCL/inc_rp.cl
Normal file
749
yt/OpenCL/inc_rp.cl
Normal file
@@ -0,0 +1,749 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define MAYBE_UNUSED
|
||||
|
||||
u32 generate_cmask (const u32 value)
|
||||
{
|
||||
const u32 rmask = ((value & 0x40404040u) >> 1u)
|
||||
& ~((value & 0x80808080u) >> 2u);
|
||||
|
||||
const u32 hmask = (value & 0x1f1f1f1fu) + 0x05050505u;
|
||||
const u32 lmask = (value & 0x1f1f1f1fu) + 0x1f1f1f1fu;
|
||||
|
||||
return rmask & ~hmask & lmask;
|
||||
}
|
||||
|
||||
void append_four_byte (const u32 *buf_src, const int off_src, u32 *buf_dst, const int off_dst)
|
||||
{
|
||||
const int sd = off_src / 4;
|
||||
const int sm = off_src & 3;
|
||||
const int sm8 = sm * 8;
|
||||
|
||||
const int dd = off_dst / 4;
|
||||
const int dm = off_dst & 3;
|
||||
const int dm8 = dm * 8;
|
||||
|
||||
u64 t64 = hl32_to_64_S (buf_src[sd + 1], buf_src[sd + 0]);
|
||||
|
||||
t64 >>= sm8;
|
||||
t64 &= 0xffffffff;
|
||||
t64 <<= dm8;
|
||||
|
||||
const u32 t0 = l32_from_64_S (t64);
|
||||
const u32 t1 = h32_from_64_S (t64);
|
||||
|
||||
buf_dst[dd + 0] |= t0;
|
||||
buf_dst[dd + 1] |= t1;
|
||||
}
|
||||
|
||||
void append_three_byte (const u32 *buf_src, const int off_src, u32 *buf_dst, const int off_dst)
|
||||
{
|
||||
const int sd = off_src / 4;
|
||||
const int sm = off_src & 3;
|
||||
const int sm8 = sm * 8;
|
||||
|
||||
const int dd = off_dst / 4;
|
||||
const int dm = off_dst & 3;
|
||||
const int dm8 = dm * 8;
|
||||
|
||||
u64 t64 = hl32_to_64_S (buf_src[sd + 1], buf_src[sd + 0]);
|
||||
|
||||
t64 >>= sm8;
|
||||
t64 &= 0x00ffffff;
|
||||
t64 <<= dm8;
|
||||
|
||||
const u32 t0 = l32_from_64_S (t64);
|
||||
const u32 t1 = h32_from_64_S (t64);
|
||||
|
||||
buf_dst[dd + 0] |= t0;
|
||||
buf_dst[dd + 1] |= t1;
|
||||
}
|
||||
|
||||
void append_two_byte (const u32 *buf_src, const int off_src, u32 *buf_dst, const int off_dst)
|
||||
{
|
||||
const int sd = off_src / 4;
|
||||
const int sm = off_src & 3;
|
||||
const int sm8 = sm * 8;
|
||||
|
||||
const int dd = off_dst / 4;
|
||||
const int dm = off_dst & 3;
|
||||
const int dm8 = dm * 8;
|
||||
|
||||
u64 t64 = hl32_to_64_S (buf_src[sd + 1], buf_src[sd + 0]);
|
||||
|
||||
t64 >>= sm8;
|
||||
t64 &= 0x0000ffff;
|
||||
t64 <<= dm8;
|
||||
|
||||
const u32 t0 = l32_from_64_S (t64);
|
||||
const u32 t1 = h32_from_64_S (t64);
|
||||
|
||||
buf_dst[dd + 0] |= t0;
|
||||
buf_dst[dd + 1] |= t1;
|
||||
}
|
||||
|
||||
void append_one_byte (const u32 *buf_src, const int off_src, u32 *buf_dst, const int off_dst)
|
||||
{
|
||||
const int sd = off_src / 4;
|
||||
const int sm = off_src & 3;
|
||||
const int sm8 = sm * 8;
|
||||
|
||||
const int dd = off_dst / 4;
|
||||
const int dm = off_dst & 3;
|
||||
const int dm8 = dm * 8;
|
||||
|
||||
u32 t = buf_src[sd];
|
||||
|
||||
t >>= sm8;
|
||||
t &= 0xff;
|
||||
t <<= dm8;
|
||||
|
||||
buf_dst[dd] |= t;
|
||||
}
|
||||
|
||||
void append_block (const u32 *buf_src, const int off_src, u32 *buf_dst, const int off_dst, const int len)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len - 3; i += 4)
|
||||
{
|
||||
append_four_byte (buf_src, off_src + i, buf_dst, off_dst + i);
|
||||
}
|
||||
|
||||
const int left = len - i;
|
||||
|
||||
switch (left)
|
||||
{
|
||||
case 3: append_three_byte (buf_src, off_src + i, buf_dst, off_dst + i); break;
|
||||
case 2: append_two_byte (buf_src, off_src + i, buf_dst, off_dst + i); break;
|
||||
case 1: append_one_byte (buf_src, off_src + i, buf_dst, off_dst + i); break;
|
||||
}
|
||||
}
|
||||
|
||||
void exchange_byte (u32 *buf, const int off_src, const int off_dst)
|
||||
{
|
||||
u8 *ptr = (u8 *) buf;
|
||||
|
||||
const u8 tmp = ptr[off_src];
|
||||
|
||||
ptr[off_src] = ptr[off_dst];
|
||||
ptr[off_dst] = tmp;
|
||||
|
||||
/*
|
||||
something tells me we do this faster
|
||||
|
||||
const int sd = off_src / 4;
|
||||
const int sm = off_src & 3;
|
||||
const int sm8 = sm * 8;
|
||||
|
||||
const int dd = off_dst / 4;
|
||||
const int dm = off_dst & 3;
|
||||
const int dm8 = dm * 8;
|
||||
|
||||
u32 ts = buf[sd];
|
||||
u32 td = buf[dd];
|
||||
|
||||
ts >>= sm8;
|
||||
td >>= dm8;
|
||||
|
||||
ts &= 0xff;
|
||||
td &= 0xff;
|
||||
|
||||
const u32 x = ts ^ td;
|
||||
|
||||
const u32 xs = x << sm8;
|
||||
const u32 xd = x << dm8;
|
||||
|
||||
buf[sd] ^= xs;
|
||||
buf[dd] ^= xd;
|
||||
*/
|
||||
}
|
||||
|
||||
int mangle_lrest (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 t = buf[idx];
|
||||
|
||||
buf[idx] = t | generate_cmask (t);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_lrest_ufirst (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 t = buf[idx];
|
||||
|
||||
buf[idx] = t | generate_cmask (t);
|
||||
}
|
||||
|
||||
const u32 t = buf[0];
|
||||
|
||||
buf[0] = t & ~(0x00000020 & generate_cmask (t));
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_urest (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 t = buf[idx];
|
||||
|
||||
buf[idx] = t & ~(generate_cmask (t));
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_urest_lfirst (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 t = buf[idx];
|
||||
|
||||
buf[idx] = t & ~(generate_cmask (t));
|
||||
}
|
||||
|
||||
const u32 t = buf[0];
|
||||
|
||||
buf[0] = t | (0x00000020 & generate_cmask (t));
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_trest (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 t = buf[idx];
|
||||
|
||||
buf[idx] = t ^ generate_cmask (t);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_toggle_at (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
const u8 p0d = p0 / 4;
|
||||
const u8 p0m = p0 & 3;
|
||||
|
||||
const u32 tmp = 0x20u << (p0m * 8);
|
||||
|
||||
const u32 t = buf[p0d];
|
||||
|
||||
buf[p0d] = t ^ (generate_cmask (t) & tmp);
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_reverse (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int l = 0; l < len / 2; l++)
|
||||
{
|
||||
const int r = len - 1 - l;
|
||||
|
||||
exchange_byte (buf, l, r);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_dupeword (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
const int out_len = len * 2;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
append_block (buf, 0, buf, len, len);
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_dupeword_times (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = (len * p0) + len;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
u8 *out = buf + len;
|
||||
|
||||
for (int t = 0; t < p0; t++) for (int i = 0; i < len; i++) *out++ = *buf++;
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_reflect (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
const int out_len = len * 2;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
append_block (buf, 0, buf, len, len);
|
||||
|
||||
for (int l = 0; l < len / 2; l++)
|
||||
{
|
||||
const int r = len - 1 - l;
|
||||
|
||||
exchange_byte (buf, len + l, len + r);
|
||||
}
|
||||
|
||||
return out_len;
|
||||
}
|
||||
|
||||
int mangle_append (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = len + 1;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
buf[len] = p0;
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_prepend (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = len + 1;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
for (int pos = len - 1; pos >= 0; pos--)
|
||||
{
|
||||
buf[pos + 1] = buf[pos];
|
||||
}
|
||||
|
||||
buf[0] = p0;
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_rotate_left (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int l = 0, r = len - 1; r > l; r--)
|
||||
{
|
||||
exchange_byte (buf, l, r);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_rotate_right (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
for (int l = 0, r = len - 1; l < r; l++)
|
||||
{
|
||||
exchange_byte (buf, l, r);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_delete_at (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
for (int pos = p0; pos < len - 1; pos++)
|
||||
{
|
||||
buf[pos] = buf[pos + 1];
|
||||
}
|
||||
|
||||
buf[len - 1] = 0;
|
||||
|
||||
return (len - 1);
|
||||
}
|
||||
|
||||
int mangle_delete_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
return mangle_delete_at (0, p1, buf, len);
|
||||
}
|
||||
|
||||
int mangle_delete_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (len == 0) return 0;
|
||||
|
||||
return mangle_delete_at (len - 1, p1, buf, len);
|
||||
}
|
||||
|
||||
int mangle_extract (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
if ((p0 + p1) > len) return (len);
|
||||
|
||||
for (int pos = 0; pos < p1; pos++)
|
||||
{
|
||||
buf[pos] = buf[p0 + pos];
|
||||
}
|
||||
|
||||
for (int pos = p1; pos < len; pos++)
|
||||
{
|
||||
buf[pos] = 0;
|
||||
}
|
||||
|
||||
return (p1);
|
||||
}
|
||||
|
||||
int mangle_omit (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
if ((p0 + p1) > len) return (len);
|
||||
|
||||
for (int pos = p0; pos < len - p1; pos++)
|
||||
{
|
||||
buf[pos] = buf[pos + p1];
|
||||
}
|
||||
|
||||
for (int pos = len - p1; pos < len; pos++)
|
||||
{
|
||||
buf[pos] = 0;
|
||||
}
|
||||
|
||||
return (len - p1);
|
||||
}
|
||||
|
||||
int mangle_insert (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len + 1) return (len);
|
||||
|
||||
const int out_len = len + 1;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
for (int pos = len - 1; pos > p0 - 1; pos--)
|
||||
{
|
||||
buf[pos + 1] = buf[pos];
|
||||
}
|
||||
|
||||
buf[p0] = p1;
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_overstrike (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0] = p1;
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_truncate_at (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
for (int pos = p0; pos < len; pos++)
|
||||
{
|
||||
buf[pos] = 0;
|
||||
}
|
||||
|
||||
return (p0);
|
||||
}
|
||||
|
||||
int mangle_replace (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
for (int pos = 0; pos < len; pos++)
|
||||
{
|
||||
if (buf[pos] != p0) continue;
|
||||
|
||||
buf[pos] = p1;
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_purgechar (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
int out_len = 0;
|
||||
|
||||
for (int pos = 0; pos < len; pos++)
|
||||
{
|
||||
if (buf[pos] == p0) continue;
|
||||
|
||||
buf[out_len] = buf[pos];
|
||||
|
||||
out_len++;
|
||||
}
|
||||
|
||||
for (int pos = out_len; pos < len; pos++)
|
||||
{
|
||||
buf[pos] = 0;
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_dupechar_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = len + p0;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
const u8 c = buf[0];
|
||||
|
||||
for (int i = 0; i < p0; i++)
|
||||
{
|
||||
mangle_prepend (c, 0, buf, len + i);
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_dupechar_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = len + p0;
|
||||
|
||||
if (len == 0) return (len);
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
const u8 c = buf[len - 1];
|
||||
|
||||
for (int i = 0; i < p0; i++)
|
||||
{
|
||||
mangle_append (c, 0, buf, len + i);
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_dupechar_all (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
const int out_len = len + len;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
for (int pos = len - 1; pos >= 0; pos--)
|
||||
{
|
||||
int new_pos = pos * 2;
|
||||
|
||||
buf[new_pos] = buf[pos];
|
||||
|
||||
buf[new_pos + 1] = buf[pos];
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_switch_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
if (len < 2) return (len);
|
||||
|
||||
exchange_byte (buf, 0, 1);
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_switch_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
if (len < 2) return (len);
|
||||
|
||||
exchange_byte (buf, len - 2, len - 1);
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_switch_at (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
if (p1 >= len) return (len);
|
||||
|
||||
exchange_byte (buf, p0, p1);
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_chr_shiftl (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0] <<= 1;
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_chr_shiftr (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0] >>= 1;
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_chr_incr (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0]++;
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_chr_decr (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0]--;
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_replace_np1 (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if ((p0 + 1) >= len) return (len);
|
||||
|
||||
buf[p0] = buf[p0 + 1];
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_replace_nm1 (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 == 0) return (len);
|
||||
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
buf[p0] = buf[p0 - 1];
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int mangle_dupeblock_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
const int out_len = len + p0;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
for (int i = 0; i < p0; i++)
|
||||
{
|
||||
const u8 c = buf[i * 2];
|
||||
|
||||
mangle_insert (i, c, buf, len + i);
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_dupeblock_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
|
||||
{
|
||||
if (p0 >= len) return (len);
|
||||
|
||||
const int out_len = len + p0;
|
||||
|
||||
if (out_len >= RP_PASSWORD_SIZE) return (len);
|
||||
|
||||
for (int i = 0; i < p0; i++)
|
||||
{
|
||||
const u8 c = buf[len - p0 + i];
|
||||
|
||||
mangle_append (c, 0, buf, len + i);
|
||||
}
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
int mangle_title_sep (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int len)
|
||||
{
|
||||
if ((len + 4) >= RP_PASSWORD_SIZE) return (len); // cheap way to not need to check for overflow of i + 1
|
||||
|
||||
mangle_lrest_ufirst (0, 0, buf, len);
|
||||
|
||||
for (int i = 0, idx = 0; i < len; i += 4, idx += 1)
|
||||
{
|
||||
const u32 v = buf[idx];
|
||||
|
||||
u32 out0 = 0;
|
||||
u32 out1 = 0;
|
||||
|
||||
if (((v >> 0) & 0xff) == p0) out0 |= 0x0000ff00;
|
||||
if (((v >> 8) & 0xff) == p0) out0 |= 0x00ff0000;
|
||||
if (((v >> 16) & 0xff) == p0) out0 |= 0xff000000;
|
||||
if (((v >> 24) & 0xff) == p0) out1 |= 0x000000ff;
|
||||
|
||||
buf[idx + 0] &= ~(generate_cmask (buf[idx + 0]) & out0);
|
||||
buf[idx + 1] &= ~(generate_cmask (buf[idx + 1]) & out1);
|
||||
}
|
||||
|
||||
return (len);
|
||||
}
|
||||
|
||||
int apply_rule (const u32 name, MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u32 *buf, const int in_len)
|
||||
{
|
||||
int out_len = in_len;
|
||||
|
||||
switch (name)
|
||||
{
|
||||
case RULE_OP_MANGLE_LREST: out_len = mangle_lrest (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_LREST_UFIRST: out_len = mangle_lrest_ufirst (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_UREST: out_len = mangle_urest (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_UREST_LFIRST: out_len = mangle_urest_lfirst (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_TREST: out_len = mangle_trest (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_TOGGLE_AT: out_len = mangle_toggle_at (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_REVERSE: out_len = mangle_reverse (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPEWORD: out_len = mangle_dupeword (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPEWORD_TIMES: out_len = mangle_dupeword_times (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_REFLECT: out_len = mangle_reflect (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_APPEND: out_len = mangle_append (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_PREPEND: out_len = mangle_prepend (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_ROTATE_LEFT: out_len = mangle_rotate_left (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_ROTATE_RIGHT: out_len = mangle_rotate_right (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DELETE_FIRST: out_len = mangle_delete_first (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DELETE_LAST: out_len = mangle_delete_last (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DELETE_AT: out_len = mangle_delete_at (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_EXTRACT: out_len = mangle_extract (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_OMIT: out_len = mangle_omit (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_INSERT: out_len = mangle_insert (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_OVERSTRIKE: out_len = mangle_overstrike (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_TRUNCATE_AT: out_len = mangle_truncate_at (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_REPLACE: out_len = mangle_replace (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_PURGECHAR: out_len = mangle_purgechar (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPECHAR_FIRST: out_len = mangle_dupechar_first (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPECHAR_LAST: out_len = mangle_dupechar_last (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPECHAR_ALL: out_len = mangle_dupechar_all (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_SWITCH_FIRST: out_len = mangle_switch_first (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_SWITCH_LAST: out_len = mangle_switch_last (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_SWITCH_AT: out_len = mangle_switch_at (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_CHR_SHIFTL: out_len = mangle_chr_shiftl (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_CHR_SHIFTR: out_len = mangle_chr_shiftr (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_CHR_INCR: out_len = mangle_chr_incr (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_CHR_DECR: out_len = mangle_chr_decr (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_REPLACE_NP1: out_len = mangle_replace_np1 (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_REPLACE_NM1: out_len = mangle_replace_nm1 (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPEBLOCK_FIRST: out_len = mangle_dupeblock_first (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_DUPEBLOCK_LAST: out_len = mangle_dupeblock_last (p0, p1, (u8 *) buf, out_len); break;
|
||||
case RULE_OP_MANGLE_TITLE_SEP: out_len = mangle_title_sep (p0, p1, buf, out_len); break;
|
||||
case RULE_OP_MANGLE_TITLE: out_len = mangle_title_sep (' ', p1, buf, out_len); break;
|
||||
}
|
||||
|
||||
return out_len;
|
||||
}
|
||||
|
||||
int apply_rules (__constant const u32 *cmds, u32 *buf, const int in_len)
|
||||
{
|
||||
int out_len = in_len;
|
||||
|
||||
for (u32 i = 0; cmds[i] != 0; i++)
|
||||
{
|
||||
const u32 cmd = cmds[i];
|
||||
|
||||
const u8 name = (cmd >> 0) & 0xff;
|
||||
const u8 p0 = (cmd >> 8) & 0xff;
|
||||
const u8 p1 = (cmd >> 16) & 0xff;
|
||||
|
||||
out_len = apply_rule (name, p0, p1, buf, out_len);
|
||||
}
|
||||
|
||||
return out_len;
|
||||
}
|
||||
75
yt/OpenCL/inc_rp.h
Normal file
75
yt/OpenCL/inc_rp.h
Normal file
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define RULE_OP_MANGLE_NOOP ':'
|
||||
#define RULE_OP_MANGLE_LREST 'l'
|
||||
#define RULE_OP_MANGLE_UREST 'u'
|
||||
#define RULE_OP_MANGLE_LREST_UFIRST 'c'
|
||||
#define RULE_OP_MANGLE_UREST_LFIRST 'C'
|
||||
#define RULE_OP_MANGLE_TREST 't'
|
||||
#define RULE_OP_MANGLE_TOGGLE_AT 'T'
|
||||
#define RULE_OP_MANGLE_REVERSE 'r'
|
||||
#define RULE_OP_MANGLE_DUPEWORD 'd'
|
||||
#define RULE_OP_MANGLE_DUPEWORD_TIMES 'p'
|
||||
#define RULE_OP_MANGLE_REFLECT 'f'
|
||||
#define RULE_OP_MANGLE_ROTATE_LEFT '{'
|
||||
#define RULE_OP_MANGLE_ROTATE_RIGHT '}'
|
||||
#define RULE_OP_MANGLE_APPEND '$'
|
||||
#define RULE_OP_MANGLE_PREPEND '^'
|
||||
#define RULE_OP_MANGLE_DELETE_FIRST '['
|
||||
#define RULE_OP_MANGLE_DELETE_LAST ']'
|
||||
#define RULE_OP_MANGLE_DELETE_AT 'D'
|
||||
#define RULE_OP_MANGLE_EXTRACT 'x'
|
||||
#define RULE_OP_MANGLE_OMIT 'O'
|
||||
#define RULE_OP_MANGLE_INSERT 'i'
|
||||
#define RULE_OP_MANGLE_OVERSTRIKE 'o'
|
||||
#define RULE_OP_MANGLE_TRUNCATE_AT '\''
|
||||
#define RULE_OP_MANGLE_REPLACE 's'
|
||||
#define RULE_OP_MANGLE_PURGECHAR '@'
|
||||
#define RULE_OP_MANGLE_TOGGLECASE_REC 'a'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_FIRST 'z'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_LAST 'Z'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_ALL 'q'
|
||||
#define RULE_OP_MANGLE_TITLE_SEP 'e'
|
||||
|
||||
#define RULE_OP_REJECT_LESS '<'
|
||||
#define RULE_OP_REJECT_GREATER '>'
|
||||
#define RULE_OP_REJECT_CONTAIN '!'
|
||||
#define RULE_OP_REJECT_NOT_CONTAIN '/'
|
||||
#define RULE_OP_REJECT_EQUAL_FIRST '('
|
||||
#define RULE_OP_REJECT_EQUAL_LAST ')'
|
||||
#define RULE_OP_REJECT_EQUAL_AT '='
|
||||
#define RULE_OP_REJECT_CONTAINS '%'
|
||||
|
||||
/* hashcat only */
|
||||
#define RULE_OP_MANGLE_SWITCH_FIRST 'k'
|
||||
#define RULE_OP_MANGLE_SWITCH_LAST 'K'
|
||||
#define RULE_OP_MANGLE_SWITCH_AT '*'
|
||||
#define RULE_OP_MANGLE_CHR_SHIFTL 'L'
|
||||
#define RULE_OP_MANGLE_CHR_SHIFTR 'R'
|
||||
#define RULE_OP_MANGLE_CHR_INCR '+'
|
||||
#define RULE_OP_MANGLE_CHR_DECR '-'
|
||||
#define RULE_OP_MANGLE_REPLACE_NP1 '.'
|
||||
#define RULE_OP_MANGLE_REPLACE_NM1 ','
|
||||
#define RULE_OP_MANGLE_DUPEBLOCK_FIRST 'y'
|
||||
#define RULE_OP_MANGLE_DUPEBLOCK_LAST 'Y'
|
||||
#define RULE_OP_MANGLE_TITLE 'E'
|
||||
|
||||
#define RP_PASSWORD_SIZE 256
|
||||
|
||||
#ifdef IS_NV
|
||||
#define COPY_PW(x) \
|
||||
pw_t pw = (x);
|
||||
#else
|
||||
#define COPY_PW(x) \
|
||||
__local pw_t s_pws[64]; \
|
||||
s_pws[get_local_id(0)] = (x);
|
||||
#endif
|
||||
|
||||
#ifdef IS_NV
|
||||
#define PASTE_PW pw;
|
||||
#else
|
||||
#define PASTE_PW s_pws[get_local_id(0)];
|
||||
#endif
|
||||
2617
yt/OpenCL/inc_rp_optimized.cl
Normal file
2617
yt/OpenCL/inc_rp_optimized.cl
Normal file
File diff suppressed because it is too large
Load Diff
58
yt/OpenCL/inc_rp_optimized.h
Normal file
58
yt/OpenCL/inc_rp_optimized.h
Normal file
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define RULE_OP_MANGLE_NOOP ':'
|
||||
#define RULE_OP_MANGLE_LREST 'l'
|
||||
#define RULE_OP_MANGLE_UREST 'u'
|
||||
#define RULE_OP_MANGLE_LREST_UFIRST 'c'
|
||||
#define RULE_OP_MANGLE_UREST_LFIRST 'C'
|
||||
#define RULE_OP_MANGLE_TREST 't'
|
||||
#define RULE_OP_MANGLE_TOGGLE_AT 'T'
|
||||
#define RULE_OP_MANGLE_REVERSE 'r'
|
||||
#define RULE_OP_MANGLE_DUPEWORD 'd'
|
||||
#define RULE_OP_MANGLE_DUPEWORD_TIMES 'p'
|
||||
#define RULE_OP_MANGLE_REFLECT 'f'
|
||||
#define RULE_OP_MANGLE_ROTATE_LEFT '{'
|
||||
#define RULE_OP_MANGLE_ROTATE_RIGHT '}'
|
||||
#define RULE_OP_MANGLE_APPEND '$'
|
||||
#define RULE_OP_MANGLE_PREPEND '^'
|
||||
#define RULE_OP_MANGLE_DELETE_FIRST '['
|
||||
#define RULE_OP_MANGLE_DELETE_LAST ']'
|
||||
#define RULE_OP_MANGLE_DELETE_AT 'D'
|
||||
#define RULE_OP_MANGLE_EXTRACT 'x'
|
||||
#define RULE_OP_MANGLE_OMIT 'O'
|
||||
#define RULE_OP_MANGLE_INSERT 'i'
|
||||
#define RULE_OP_MANGLE_OVERSTRIKE 'o'
|
||||
#define RULE_OP_MANGLE_TRUNCATE_AT '\''
|
||||
#define RULE_OP_MANGLE_REPLACE 's'
|
||||
#define RULE_OP_MANGLE_PURGECHAR '@'
|
||||
#define RULE_OP_MANGLE_TOGGLECASE_REC 'a'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_FIRST 'z'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_LAST 'Z'
|
||||
#define RULE_OP_MANGLE_DUPECHAR_ALL 'q'
|
||||
#define RULE_OP_MANGLE_TITLE_SEP 'e'
|
||||
|
||||
#define RULE_OP_REJECT_LESS '<'
|
||||
#define RULE_OP_REJECT_GREATER '>'
|
||||
#define RULE_OP_REJECT_CONTAIN '!'
|
||||
#define RULE_OP_REJECT_NOT_CONTAIN '/'
|
||||
#define RULE_OP_REJECT_EQUAL_FIRST '('
|
||||
#define RULE_OP_REJECT_EQUAL_LAST ')'
|
||||
#define RULE_OP_REJECT_EQUAL_AT '='
|
||||
#define RULE_OP_REJECT_CONTAINS '%'
|
||||
|
||||
/* hashcat only */
|
||||
#define RULE_OP_MANGLE_SWITCH_FIRST 'k'
|
||||
#define RULE_OP_MANGLE_SWITCH_LAST 'K'
|
||||
#define RULE_OP_MANGLE_SWITCH_AT '*'
|
||||
#define RULE_OP_MANGLE_CHR_SHIFTL 'L'
|
||||
#define RULE_OP_MANGLE_CHR_SHIFTR 'R'
|
||||
#define RULE_OP_MANGLE_CHR_INCR '+'
|
||||
#define RULE_OP_MANGLE_CHR_DECR '-'
|
||||
#define RULE_OP_MANGLE_REPLACE_NP1 '.'
|
||||
#define RULE_OP_MANGLE_REPLACE_NM1 ','
|
||||
#define RULE_OP_MANGLE_DUPEBLOCK_FIRST 'y'
|
||||
#define RULE_OP_MANGLE_DUPEBLOCK_LAST 'Y'
|
||||
#define RULE_OP_MANGLE_TITLE 'E'
|
||||
42
yt/OpenCL/inc_scalar.cl
Normal file
42
yt/OpenCL/inc_scalar.cl
Normal file
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define COMPARE_S_SCALAR(h0,h1,h2,h3) \
|
||||
{ \
|
||||
if (((h0) == search[0]) && ((h1) == search[1]) && ((h2) == search[2]) && ((h3) == search[3])) \
|
||||
{ \
|
||||
const u32 final_hash_pos = digests_offset + 0; \
|
||||
\
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0) \
|
||||
{ \
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, 0, final_hash_pos, gid, il_pos); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define COMPARE_M_SCALAR(h0,h1,h2,h3) \
|
||||
{ \
|
||||
const u32 digest_tp0[4] = { h0, h1, h2, h3 }; \
|
||||
\
|
||||
if (check (digest_tp0, \
|
||||
bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, \
|
||||
bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, \
|
||||
bitmap_mask, \
|
||||
bitmap_shift1, \
|
||||
bitmap_shift2)) \
|
||||
{ \
|
||||
int digest_pos = find_hash (digest_tp0, digests_cnt, &digests_buf[digests_offset]); \
|
||||
\
|
||||
if (digest_pos != -1) \
|
||||
{ \
|
||||
const u32 final_hash_pos = digests_offset + digest_pos; \
|
||||
\
|
||||
if (atomic_inc (&hashes_shown[final_hash_pos]) == 0) \
|
||||
{ \
|
||||
mark_hash (plains_buf, d_return_buf, salt_pos, digests_cnt, digest_pos, final_hash_pos, gid, il_pos); \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
1186
yt/OpenCL/inc_simd.cl
Normal file
1186
yt/OpenCL/inc_simd.cl
Normal file
File diff suppressed because it is too large
Load Diff
92
yt/OpenCL/inc_truecrypt_crc32.cl
Normal file
92
yt/OpenCL/inc_truecrypt_crc32.cl
Normal file
@@ -0,0 +1,92 @@
|
||||
__constant u32a crc32tab[0x100] =
|
||||
{
|
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
|
||||
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
|
||||
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
|
||||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
|
||||
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
|
||||
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
|
||||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
|
||||
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
|
||||
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
|
||||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
|
||||
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
|
||||
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
|
||||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
|
||||
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
|
||||
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
|
||||
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
|
||||
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
|
||||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
|
||||
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
|
||||
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
|
||||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
|
||||
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
|
||||
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
|
||||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
|
||||
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
|
||||
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
|
||||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
|
||||
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
|
||||
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
|
||||
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
|
||||
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
|
||||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
|
||||
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
|
||||
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
|
||||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
|
||||
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
|
||||
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
|
||||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
|
||||
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
|
||||
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
|
||||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
|
||||
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
|
||||
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
|
||||
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
|
||||
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
|
||||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
|
||||
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
|
||||
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
|
||||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
|
||||
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
|
||||
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
|
||||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
|
||||
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
|
||||
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
|
||||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
|
||||
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
|
||||
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
|
||||
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
|
||||
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
|
||||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
|
||||
};
|
||||
|
||||
DECLSPEC u32 round_crc32 (u32 a, const u32 v)
|
||||
{
|
||||
const u32 k = (a ^ v) & 0xff;
|
||||
|
||||
const u32 s = a >> 8;
|
||||
|
||||
a = crc32tab[k];
|
||||
|
||||
a ^= s;
|
||||
|
||||
return a;
|
||||
}
|
||||
|
||||
DECLSPEC u32 round_crc32_4 (const u32 w, const u32 iv)
|
||||
{
|
||||
u32 a = iv;
|
||||
|
||||
a = round_crc32 (a, w >> 0);
|
||||
a = round_crc32 (a, w >> 8);
|
||||
a = round_crc32 (a, w >> 16);
|
||||
a = round_crc32 (a, w >> 24);
|
||||
|
||||
return a;
|
||||
}
|
||||
649
yt/OpenCL/inc_truecrypt_xts.cl
Normal file
649
yt/OpenCL/inc_truecrypt_xts.cl
Normal file
@@ -0,0 +1,649 @@
|
||||
DECLSPEC void xts_mul2 (u32 *in, u32 *out)
|
||||
{
|
||||
const u32 c = in[3] >> 31;
|
||||
|
||||
out[3] = (in[3] << 1) | (in[2] >> 31);
|
||||
out[2] = (in[2] << 1) | (in[1] >> 31);
|
||||
out[1] = (in[1] << 1) | (in[0] >> 31);
|
||||
out[0] = (in[0] << 1);
|
||||
|
||||
out[0] ^= c * 0x87;
|
||||
}
|
||||
|
||||
DECLSPEC void aes256_decrypt_xts_first (const u32 *ukey1, const u32 *ukey2, const u32 *in, u32 *out, u32 *S, u32 *T, u32 *ks, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
aes256_set_encrypt_key (ks, ukey2, s_te0, s_te1, s_te2, s_te3, s_te4);
|
||||
aes256_encrypt (ks, S, T, s_te0, s_te1, s_te2, s_te3, s_te4);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
aes256_set_decrypt_key (ks, ukey1, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
aes256_decrypt (ks, out, out, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
DECLSPEC void aes256_decrypt_xts_next (const u32 *in, u32 *out, u32 *T, u32 *ks, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
xts_mul2 (T, T);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
aes256_decrypt (ks, out, out, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
DECLSPEC void serpent256_decrypt_xts_first (const u32 *ukey1, const u32 *ukey2, const u32 *in, u32 *out, u32 *S, u32 *T, u32 *ks)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
serpent256_set_key (ks, ukey2);
|
||||
serpent256_encrypt (ks, S, T);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
serpent256_set_key (ks, ukey1);
|
||||
serpent256_decrypt (ks, out, out);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
DECLSPEC void serpent256_decrypt_xts_next (const u32 *in, u32 *out, u32 *T, u32 *ks)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
xts_mul2 (T, T);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
serpent256_decrypt (ks, out, out);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
DECLSPEC void twofish256_decrypt_xts_first (const u32 *ukey1, const u32 *ukey2, const u32 *in, u32 *out, u32 *S, u32 *T, u32 *sk, u32 *lk)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
twofish256_set_key (sk, lk, ukey2);
|
||||
twofish256_encrypt (sk, lk, S, T);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
twofish256_set_key (sk, lk, ukey1);
|
||||
twofish256_decrypt (sk, lk, out, out);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
DECLSPEC void twofish256_decrypt_xts_next (const u32 *in, u32 *out, u32 *T, u32 *sk, u32 *lk)
|
||||
{
|
||||
out[0] = in[0];
|
||||
out[1] = in[1];
|
||||
out[2] = in[2];
|
||||
out[3] = in[3];
|
||||
|
||||
xts_mul2 (T, T);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
|
||||
twofish256_decrypt (sk, lk, out, out);
|
||||
|
||||
out[0] ^= T[0];
|
||||
out[1] ^= T[1];
|
||||
out[2] ^= T[2];
|
||||
out[3] ^= T[3];
|
||||
}
|
||||
|
||||
// 512 bit
|
||||
|
||||
DECLSPEC int verify_header_aes (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
u32 ks_aes[60];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_aes[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
aes256_decrypt_xts_first (ukey1, ukey2, data, tmp, S, T_aes, ks_aes, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_aes, T_aes);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
aes256_decrypt_xts_next (data, tmp, T_aes, ks_aes, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
DECLSPEC int verify_header_serpent (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2)
|
||||
{
|
||||
u32 ks_serpent[140];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_serpent[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
serpent256_decrypt_xts_first (ukey1, ukey2, data, tmp, S, T_serpent, ks_serpent);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_serpent, T_serpent);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
serpent256_decrypt_xts_next (data, tmp, T_serpent, ks_serpent);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
DECLSPEC int verify_header_twofish (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2)
|
||||
{
|
||||
u32 sk_twofish[4];
|
||||
u32 lk_twofish[40];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_twofish[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
twofish256_decrypt_xts_first (ukey1, ukey2, data, tmp, S, T_twofish, sk_twofish, lk_twofish);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_twofish, T_twofish);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
twofish256_decrypt_xts_next (data, tmp, T_twofish, sk_twofish, lk_twofish);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 1024 bit
|
||||
|
||||
DECLSPEC int verify_header_aes_twofish (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, const u32 *ukey3, const u32 *ukey4, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
u32 ks_aes[60];
|
||||
|
||||
u32 sk_twofish[4];
|
||||
u32 lk_twofish[40];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_aes[4] = { 0 };
|
||||
u32 T_twofish[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
aes256_decrypt_xts_first (ukey2, ukey4, data, tmp, S, T_aes, ks_aes, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
twofish256_decrypt_xts_first (ukey1, ukey3, tmp, tmp, S, T_twofish, sk_twofish, lk_twofish);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_aes, T_aes);
|
||||
xts_mul2 (T_twofish, T_twofish);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
aes256_decrypt_xts_next (data, tmp, T_aes, ks_aes, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
twofish256_decrypt_xts_next (tmp, tmp, T_twofish, sk_twofish, lk_twofish);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
DECLSPEC int verify_header_serpent_aes (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, const u32 *ukey3, const u32 *ukey4, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
u32 ks_serpent[140];
|
||||
u32 ks_aes[60];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_serpent[4] = { 0 };
|
||||
u32 T_aes[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
serpent256_decrypt_xts_first (ukey2, ukey4, data, tmp, S, T_serpent, ks_serpent);
|
||||
aes256_decrypt_xts_first (ukey1, ukey3, tmp, tmp, S, T_aes, ks_aes, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_serpent, T_serpent);
|
||||
xts_mul2 (T_aes, T_aes);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
serpent256_decrypt_xts_next (data, tmp, T_serpent, ks_serpent);
|
||||
aes256_decrypt_xts_next (tmp, tmp, T_aes, ks_aes, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
DECLSPEC int verify_header_twofish_serpent (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, const u32 *ukey3, const u32 *ukey4)
|
||||
{
|
||||
u32 sk_twofish[4];
|
||||
u32 lk_twofish[40];
|
||||
|
||||
u32 ks_serpent[140];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_twofish[4] = { 0 };
|
||||
u32 T_serpent[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
twofish256_decrypt_xts_first (ukey2, ukey4, data, tmp, S, T_twofish, sk_twofish, lk_twofish);
|
||||
serpent256_decrypt_xts_first (ukey1, ukey3, tmp, tmp, S, T_serpent, ks_serpent);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_twofish, T_twofish);
|
||||
xts_mul2 (T_serpent, T_serpent);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
twofish256_decrypt_xts_next (data, tmp, T_twofish, sk_twofish, lk_twofish);
|
||||
serpent256_decrypt_xts_next (tmp, tmp, T_serpent, ks_serpent);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 1536 bit
|
||||
|
||||
DECLSPEC int verify_header_aes_twofish_serpent (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, const u32 *ukey3, const u32 *ukey4, const u32 *ukey5, const u32 *ukey6, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
u32 ks_aes[60];
|
||||
|
||||
u32 sk_twofish[4];
|
||||
u32 lk_twofish[40];
|
||||
|
||||
u32 ks_serpent[140];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_aes[4] = { 0 };
|
||||
u32 T_twofish[4] = { 0 };
|
||||
u32 T_serpent[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
aes256_decrypt_xts_first (ukey3, ukey6, data, tmp, S, T_aes, ks_aes, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
twofish256_decrypt_xts_first (ukey2, ukey5, tmp, tmp, S, T_twofish, sk_twofish, lk_twofish);
|
||||
serpent256_decrypt_xts_first (ukey1, ukey4, tmp, tmp, S, T_serpent, ks_serpent);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_aes, T_aes);
|
||||
xts_mul2 (T_twofish, T_twofish);
|
||||
xts_mul2 (T_serpent, T_serpent);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
aes256_decrypt_xts_next (data, tmp, T_aes, ks_aes, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
twofish256_decrypt_xts_next (tmp, tmp, T_twofish, sk_twofish, lk_twofish);
|
||||
serpent256_decrypt_xts_next (tmp, tmp, T_serpent, ks_serpent);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
DECLSPEC int verify_header_serpent_twofish_aes (__global const tc_t *esalt_bufs, const u32 *ukey1, const u32 *ukey2, const u32 *ukey3, const u32 *ukey4, const u32 *ukey5, const u32 *ukey6, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4, SHM_TYPE u32 *s_td0, SHM_TYPE u32 *s_td1, SHM_TYPE u32 *s_td2, SHM_TYPE u32 *s_td3, SHM_TYPE u32 *s_td4)
|
||||
{
|
||||
u32 ks_serpent[140];
|
||||
|
||||
u32 sk_twofish[4];
|
||||
u32 lk_twofish[40];
|
||||
|
||||
u32 ks_aes[60];
|
||||
|
||||
u32 S[4] = { 0 };
|
||||
|
||||
u32 T_serpent[4] = { 0 };
|
||||
u32 T_twofish[4] = { 0 };
|
||||
u32 T_aes[4] = { 0 };
|
||||
|
||||
u32 data[4];
|
||||
|
||||
data[0] = esalt_bufs[0].data_buf[0];
|
||||
data[1] = esalt_bufs[0].data_buf[1];
|
||||
data[2] = esalt_bufs[0].data_buf[2];
|
||||
data[3] = esalt_bufs[0].data_buf[3];
|
||||
|
||||
u32 tmp[4];
|
||||
|
||||
serpent256_decrypt_xts_first (ukey3, ukey6, data, tmp, S, T_serpent, ks_serpent);
|
||||
twofish256_decrypt_xts_first (ukey2, ukey5, tmp, tmp, S, T_twofish, sk_twofish, lk_twofish);
|
||||
aes256_decrypt_xts_first (ukey1, ukey4, tmp, tmp, S, T_aes, ks_aes, s_te0, s_te1, s_te2, s_te3, s_te4, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
const u32 signature = esalt_bufs[0].signature;
|
||||
|
||||
if (tmp[0] != signature) return 0;
|
||||
|
||||
const u32 crc32_save = swap32_S (~tmp[2]);
|
||||
|
||||
// seek to byte 256
|
||||
|
||||
for (volatile int i = 4; i < 64 - 16; i += 4)
|
||||
{
|
||||
xts_mul2 (T_serpent, T_serpent);
|
||||
xts_mul2 (T_twofish, T_twofish);
|
||||
xts_mul2 (T_aes, T_aes);
|
||||
}
|
||||
|
||||
// calculate crc32 from here
|
||||
|
||||
u32 crc32 = ~0;
|
||||
|
||||
for (volatile int i = 64 - 16; i < 128 - 16; i += 4)
|
||||
{
|
||||
data[0] = esalt_bufs[0].data_buf[i + 0];
|
||||
data[1] = esalt_bufs[0].data_buf[i + 1];
|
||||
data[2] = esalt_bufs[0].data_buf[i + 2];
|
||||
data[3] = esalt_bufs[0].data_buf[i + 3];
|
||||
|
||||
serpent256_decrypt_xts_next (data, tmp, T_serpent, ks_serpent);
|
||||
twofish256_decrypt_xts_next (tmp, tmp, T_twofish, sk_twofish, lk_twofish);
|
||||
aes256_decrypt_xts_next (tmp, tmp, T_aes, ks_aes, s_td0, s_td1, s_td2, s_td3, s_td4);
|
||||
|
||||
crc32 = round_crc32_4 (tmp[0], crc32);
|
||||
crc32 = round_crc32_4 (tmp[1], crc32);
|
||||
crc32 = round_crc32_4 (tmp[2], crc32);
|
||||
crc32 = round_crc32_4 (tmp[3], crc32);
|
||||
}
|
||||
|
||||
if (crc32 != crc32_save) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
2036
yt/OpenCL/inc_types.cl
Normal file
2036
yt/OpenCL/inc_types.cl
Normal file
File diff suppressed because it is too large
Load Diff
247
yt/OpenCL/inc_vendor.cl
Normal file
247
yt/OpenCL/inc_vendor.cl
Normal file
@@ -0,0 +1,247 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
/**
|
||||
* device type
|
||||
*/
|
||||
|
||||
#define DEVICE_TYPE_CPU 2
|
||||
#define DEVICE_TYPE_GPU 4
|
||||
#define DEVICE_TYPE_ACCEL 8
|
||||
|
||||
#if DEVICE_TYPE == DEVICE_TYPE_CPU
|
||||
#define IS_CPU
|
||||
#elif DEVICE_TYPE == DEVICE_TYPE_GPU
|
||||
#define IS_GPU
|
||||
#elif DEVICE_TYPE == DEVICE_TYPE_ACCEL
|
||||
#define IS_ACCEL
|
||||
#endif
|
||||
|
||||
/**
|
||||
* vendor specific
|
||||
*/
|
||||
|
||||
#if VENDOR_ID == (1 << 0)
|
||||
#define IS_AMD
|
||||
#define AMD_GCN 0
|
||||
#if AMD_ROCM == 1
|
||||
#if defined __gfx600__ || defined __gfx601__
|
||||
#undef AMD_GCN
|
||||
#define AMD_GCN 1
|
||||
#endif
|
||||
#if defined __gfx700__ || defined __gfx701__ || defined __gfx702__ || defined __gfx703__
|
||||
#undef AMD_GCN
|
||||
#define AMD_GCN 2
|
||||
#endif
|
||||
#if defined __gfx800__ || defined __gfx801__ || defined __gfx802__ || defined __gfx803__ || defined __gfx804__ || defined __gfx810__
|
||||
#undef AMD_GCN
|
||||
#define AMD_GCN 3
|
||||
// According to AMD docs, GCN 3 and 4 are the same
|
||||
#endif
|
||||
#if defined __gfx900__ || defined __gfx901__ || defined __gfx902__ || defined __gfx903__
|
||||
#undef AMD_GCN
|
||||
#define AMD_GCN 5
|
||||
#endif
|
||||
#endif
|
||||
#elif VENDOR_ID == (1 << 1)
|
||||
#define IS_APPLE
|
||||
#define IS_GENERIC
|
||||
#elif VENDOR_ID == (1 << 2)
|
||||
#define IS_INTEL_BEIGNET
|
||||
#define IS_GENERIC
|
||||
#elif VENDOR_ID == (1 << 3)
|
||||
#define IS_INTEL_SDK
|
||||
#define IS_GENERIC
|
||||
#elif VENDOR_ID == (1 << 4)
|
||||
#define IS_MESA
|
||||
#define IS_GENERIC
|
||||
#elif VENDOR_ID == (1 << 5)
|
||||
#define IS_NV
|
||||
#elif VENDOR_ID == (1 << 6)
|
||||
#define IS_POCL
|
||||
#define IS_GENERIC
|
||||
#else
|
||||
#define IS_GENERIC
|
||||
#endif
|
||||
|
||||
#if DEVICE_TYPE == DEVICE_TYPE_CPU
|
||||
#elif DEVICE_TYPE == DEVICE_TYPE_GPU
|
||||
// AMD fails with mode 6211
|
||||
#ifdef IS_NV
|
||||
#define REAL_SHM
|
||||
#endif
|
||||
#elif DEVICE_TYPE == DEVICE_TYPE_ACCEL
|
||||
#endif
|
||||
|
||||
#ifdef REAL_SHM
|
||||
#define SHM_TYPE __local
|
||||
#else
|
||||
#define SHM_TYPE __constant
|
||||
#endif
|
||||
|
||||
/**
|
||||
* function declarations can have a large influence depending on the opencl runtime
|
||||
*/
|
||||
|
||||
#if defined IS_CPU
|
||||
#define DECLSPEC inline
|
||||
#elif defined IS_GPU
|
||||
#if defined IS_AMD
|
||||
#define DECLSPEC inline
|
||||
#else
|
||||
#define DECLSPEC
|
||||
#endif
|
||||
#else
|
||||
#define DECLSPEC
|
||||
#endif
|
||||
|
||||
#if (defined IS_AMD && AMD_GCN < 3)
|
||||
#define MAYBE_VOLATILE volatile
|
||||
#else
|
||||
#define MAYBE_VOLATILE
|
||||
#endif
|
||||
|
||||
/**
|
||||
* AMD specific
|
||||
*/
|
||||
|
||||
#ifdef IS_AMD
|
||||
#if defined(cl_amd_media_ops)
|
||||
#pragma OPENCL EXTENSION cl_amd_media_ops : enable
|
||||
#endif
|
||||
#if defined(cl_amd_media_ops2)
|
||||
#pragma OPENCL EXTENSION cl_amd_media_ops2 : enable
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Unrolling is generally enabled, for all device types and hash modes
|
||||
* There's a few exception when it's better not to unroll
|
||||
* Some algorithms run into too much register pressure due to loop unrolling
|
||||
*/
|
||||
|
||||
// generic vendors: those algos have shown that they produce better results on both amd and nv when not unrolled
|
||||
// so we can assume they will produce better results on other vendors as well
|
||||
|
||||
#if KERN_TYPE == 1420
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1450
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1460
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1720
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1750
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1760
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 1800
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 6221
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 6222
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 6223
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 6400
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 6500
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 7100
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 7400
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 7900
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 8900
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 10700
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13721
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13722
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13723
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13751
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13752
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13753
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 13800
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 15700
|
||||
#undef _unroll
|
||||
#endif
|
||||
|
||||
// nvidia specific
|
||||
|
||||
#ifdef IS_NV
|
||||
#ifdef IS_GPU
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// amd specific
|
||||
|
||||
#ifdef IS_AMD
|
||||
#ifdef IS_GPU
|
||||
|
||||
#if KERN_TYPE == 8000
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 8200
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 12300
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 14100
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 15300
|
||||
#undef _unroll
|
||||
#endif
|
||||
#if KERN_TYPE == 15900
|
||||
#undef _unroll
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// apple specific
|
||||
|
||||
#ifdef IS_APPLE
|
||||
|
||||
#if KERN_TYPE == 5000
|
||||
#undef _unroll
|
||||
#endif
|
||||
|
||||
#endif
|
||||
300
yt/OpenCL/m00000_a0-optimized.cl
Normal file
300
yt/OpenCL/m00000_a0-optimized.cl
Normal file
@@ -0,0 +1,300 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00000_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
w3[2] = out_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
w3[2] = out_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
116
yt/OpenCL/m00000_a0-pure.cl
Normal file
116
yt/OpenCL/m00000_a0-pure.cl
Normal file
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00000_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
418
yt/OpenCL/m00000_a1-optimized.cl
Normal file
418
yt/OpenCL/m00000_a1-optimized.cl
Normal file
@@ -0,0 +1,418 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00000_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = pw_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = pw_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00000_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
110
yt/OpenCL/m00000_a1-pure.cl
Normal file
110
yt/OpenCL/m00000_a1-pure.cl
Normal file
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00000_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
657
yt/OpenCL/m00000_a3-optimized.cl
Normal file
657
yt/OpenCL/m00000_a3-optimized.cl
Normal file
@@ -0,0 +1,657 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
#define MD5_STEP_REV(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= f (b, c, d); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
#define MD5_STEP_REV1(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
DECLSPEC void m00000m (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00000s (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
u32 a_rev = digests_buf[digests_offset].digest_buf[0];
|
||||
u32 b_rev = digests_buf[digests_offset].digest_buf[1];
|
||||
u32 c_rev = digests_buf[digests_offset].digest_buf[2];
|
||||
u32 d_rev = digests_buf[digests_offset].digest_buf[3];
|
||||
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 9], MD5C3f, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 2], MD5C3e, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[11], MD5C3d, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 4], MD5C3c, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[13], MD5C3b, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 6], MD5C3a, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[15], MD5C39, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 8], MD5C38, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 1], MD5C37, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[10], MD5C36, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 3], MD5C35, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[12], MD5C34, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 5], MD5C33, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[14], MD5C32, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 7], MD5C31, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, 0, MD5C30, MD5S30);
|
||||
|
||||
const u32 pre_cd = c_rev ^ d_rev;
|
||||
|
||||
MD5_STEP_REV1(MD5_H_S, b_rev, c_rev, d_rev, a_rev, w[ 2], MD5C2f, MD5S23);
|
||||
MD5_STEP_REV1(MD5_H_S, c_rev, d_rev, a_rev, b_rev, w[15], MD5C2e, MD5S22);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x pre_d = d_rev;
|
||||
const u32x pre_a = a_rev - w0;
|
||||
const u32x pre_b = b_rev - (pre_a ^ pre_cd);
|
||||
const u32x pre_c = c_rev - (pre_a ^ pre_b ^ pre_d);
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_c, c)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_d, d)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00000_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00000_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00000_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00000_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00000_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
136
yt/OpenCL/m00000_a3-pure.cl
Normal file
136
yt/OpenCL/m00000_a3-pure.cl
Normal file
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00000_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00000_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
448
yt/OpenCL/m00010_a0-optimized.cl
Normal file
448
yt/OpenCL/m00010_a0-optimized.cl
Normal file
@@ -0,0 +1,448 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00010_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len);
|
||||
|
||||
const u32x pw_salt_len = out_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len);
|
||||
|
||||
const u32x pw_salt_len = out_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
138
yt/OpenCL/m00010_a0-pure.cl
Normal file
138
yt/OpenCL/m00010_a0-pure.cl
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00010_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
566
yt/OpenCL/m00010_a1-optimized.cl
Normal file
566
yt/OpenCL/m00010_a1-optimized.cl
Normal file
@@ -0,0 +1,566 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00010_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00010_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
132
yt/OpenCL/m00010_a1-pure.cl
Normal file
132
yt/OpenCL/m00010_a1-pure.cl
Normal file
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00010_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
705
yt/OpenCL/m00010_a3-optimized.cl
Normal file
705
yt/OpenCL/m00010_a3-optimized.cl
Normal file
@@ -0,0 +1,705 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
#define MD5_STEP_REV(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= f (b, c, d); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
#define MD5_STEP_REV1(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
DECLSPEC void m00010m (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_S (salt_buf0, salt_buf1, salt_buf2, salt_buf3, pw_len);
|
||||
|
||||
w[ 0] |= salt_buf0[0];
|
||||
w[ 1] |= salt_buf0[1];
|
||||
w[ 2] |= salt_buf0[2];
|
||||
w[ 3] |= salt_buf0[3];
|
||||
w[ 4] |= salt_buf1[0];
|
||||
w[ 5] |= salt_buf1[1];
|
||||
w[ 6] |= salt_buf1[2];
|
||||
w[ 7] |= salt_buf1[3];
|
||||
w[ 8] |= salt_buf2[0];
|
||||
w[ 9] |= salt_buf2[1];
|
||||
w[10] |= salt_buf2[2];
|
||||
w[11] |= salt_buf2[3];
|
||||
w[12] |= salt_buf3[0];
|
||||
w[13] |= salt_buf3[1];
|
||||
w[14] = pw_salt_len * 8;
|
||||
w[15] = 0;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00010s (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
u32 a_rev = digests_buf[digests_offset].digest_buf[0];
|
||||
u32 b_rev = digests_buf[digests_offset].digest_buf[1];
|
||||
u32 c_rev = digests_buf[digests_offset].digest_buf[2];
|
||||
u32 d_rev = digests_buf[digests_offset].digest_buf[3];
|
||||
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 9], MD5C3f, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 2], MD5C3e, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[11], MD5C3d, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 4], MD5C3c, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[13], MD5C3b, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 6], MD5C3a, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[15], MD5C39, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 8], MD5C38, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 1], MD5C37, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[10], MD5C36, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 3], MD5C35, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[12], MD5C34, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 5], MD5C33, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[14], MD5C32, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 7], MD5C31, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, 0, MD5C30, MD5S30);
|
||||
|
||||
const u32 pre_cd = c_rev ^ d_rev;
|
||||
|
||||
MD5_STEP_REV1(MD5_H_S, b_rev, c_rev, d_rev, a_rev, w[ 2], MD5C2f, MD5S23);
|
||||
MD5_STEP_REV1(MD5_H_S, c_rev, d_rev, a_rev, b_rev, w[15], MD5C2e, MD5S22);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x pre_d = d_rev;
|
||||
const u32x pre_a = a_rev - w0;
|
||||
const u32x pre_b = b_rev - (pre_a ^ pre_cd);
|
||||
const u32x pre_c = c_rev - (pre_a ^ pre_b ^ pre_d);
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_c, c)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_d, d)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00010_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00010_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00010_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00010_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00010_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
158
yt/OpenCL/m00010_a3-pure.cl
Normal file
158
yt/OpenCL/m00010_a3-pure.cl
Normal file
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00010_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00010_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
408
yt/OpenCL/m00020_a0-optimized.cl
Normal file
408
yt/OpenCL/m00020_a0-optimized.cl
Normal file
@@ -0,0 +1,408 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00020_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = out_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = out_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
124
yt/OpenCL/m00020_a0-pure.cl
Normal file
124
yt/OpenCL/m00020_a0-pure.cl
Normal file
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00020_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
522
yt/OpenCL/m00020_a1-optimized.cl
Normal file
522
yt/OpenCL/m00020_a1-optimized.cl
Normal file
@@ -0,0 +1,522 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00020_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00020_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
114
yt/OpenCL/m00020_a1-pure.cl
Normal file
114
yt/OpenCL/m00020_a1-pure.cl
Normal file
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00020_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
660
yt/OpenCL/m00020_a3-optimized.cl
Normal file
660
yt/OpenCL/m00020_a3-optimized.cl
Normal file
@@ -0,0 +1,660 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
DECLSPEC void m00020m (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_le (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = pw_salt_len * 8;
|
||||
t3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, t0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00020s (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_le (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = pw_salt_len * 8;
|
||||
t3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, t0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, t2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00020_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00020_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00020_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00020_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00020_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00020s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
148
yt/OpenCL/m00020_a3-pure.cl
Normal file
148
yt/OpenCL/m00020_a3-pure.cl
Normal file
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00020_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00020_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
md5_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
458
yt/OpenCL/m00030_a0-optimized.cl
Normal file
458
yt/OpenCL/m00030_a0-optimized.cl
Normal file
@@ -0,0 +1,458 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00030_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len2);
|
||||
|
||||
const u32x pw_salt_len = out_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len2);
|
||||
|
||||
const u32x pw_salt_len = out_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
138
yt/OpenCL/m00030_a0-pure.cl
Normal file
138
yt/OpenCL/m00030_a0-pure.cl
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00030_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update_utf16le (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx;
|
||||
|
||||
md5_init (&ctx);
|
||||
|
||||
md5_update_utf16le (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
576
yt/OpenCL/m00030_a1-optimized.cl
Normal file
576
yt/OpenCL/m00030_a1-optimized.cl
Normal file
@@ -0,0 +1,576 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00030_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x pw_len2 = pw_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len2);
|
||||
|
||||
const u32x pw_salt_len = pw_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x pw_len2 = pw_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len2);
|
||||
|
||||
const u32x pw_salt_len = pw_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00030_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
132
yt/OpenCL/m00030_a1-pure.cl
Normal file
132
yt/OpenCL/m00030_a1-pure.cl
Normal file
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00030_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global_utf16le (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global_utf16le (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global_utf16le (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global_utf16le (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_update (&ctx, s, salt_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
705
yt/OpenCL/m00030_a3-optimized.cl
Normal file
705
yt/OpenCL/m00030_a3-optimized.cl
Normal file
@@ -0,0 +1,705 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
#define MD5_STEP_REV(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= f (b, c, d); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
#define MD5_STEP_REV1(f,a,b,c,d,x,t,s) \
|
||||
{ \
|
||||
a -= b; \
|
||||
a = rotr32_S (a, s); \
|
||||
a -= x; \
|
||||
a -= t; \
|
||||
}
|
||||
|
||||
DECLSPEC void m00030m (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_S (salt_buf0, salt_buf1, salt_buf2, salt_buf3, pw_len);
|
||||
|
||||
w[ 0] |= salt_buf0[0];
|
||||
w[ 1] |= salt_buf0[1];
|
||||
w[ 2] |= salt_buf0[2];
|
||||
w[ 3] |= salt_buf0[3];
|
||||
w[ 4] |= salt_buf1[0];
|
||||
w[ 5] |= salt_buf1[1];
|
||||
w[ 6] |= salt_buf1[2];
|
||||
w[ 7] |= salt_buf1[3];
|
||||
w[ 8] |= salt_buf2[0];
|
||||
w[ 9] |= salt_buf2[1];
|
||||
w[10] |= salt_buf2[2];
|
||||
w[11] |= salt_buf2[3];
|
||||
w[12] |= salt_buf3[0];
|
||||
w[13] |= salt_buf3[1];
|
||||
w[14] = pw_salt_len * 8;
|
||||
w[15] = 0;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00030s (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 F_w0c00 = 0u + MD5C00;
|
||||
const u32 F_w1c01 = w[ 1] + MD5C01;
|
||||
const u32 F_w2c02 = w[ 2] + MD5C02;
|
||||
const u32 F_w3c03 = w[ 3] + MD5C03;
|
||||
const u32 F_w4c04 = w[ 4] + MD5C04;
|
||||
const u32 F_w5c05 = w[ 5] + MD5C05;
|
||||
const u32 F_w6c06 = w[ 6] + MD5C06;
|
||||
const u32 F_w7c07 = w[ 7] + MD5C07;
|
||||
const u32 F_w8c08 = w[ 8] + MD5C08;
|
||||
const u32 F_w9c09 = w[ 9] + MD5C09;
|
||||
const u32 F_wac0a = w[10] + MD5C0a;
|
||||
const u32 F_wbc0b = w[11] + MD5C0b;
|
||||
const u32 F_wcc0c = w[12] + MD5C0c;
|
||||
const u32 F_wdc0d = w[13] + MD5C0d;
|
||||
const u32 F_wec0e = w[14] + MD5C0e;
|
||||
const u32 F_wfc0f = w[15] + MD5C0f;
|
||||
|
||||
const u32 G_w1c10 = w[ 1] + MD5C10;
|
||||
const u32 G_w6c11 = w[ 6] + MD5C11;
|
||||
const u32 G_wbc12 = w[11] + MD5C12;
|
||||
const u32 G_w0c13 = 0u + MD5C13;
|
||||
const u32 G_w5c14 = w[ 5] + MD5C14;
|
||||
const u32 G_wac15 = w[10] + MD5C15;
|
||||
const u32 G_wfc16 = w[15] + MD5C16;
|
||||
const u32 G_w4c17 = w[ 4] + MD5C17;
|
||||
const u32 G_w9c18 = w[ 9] + MD5C18;
|
||||
const u32 G_wec19 = w[14] + MD5C19;
|
||||
const u32 G_w3c1a = w[ 3] + MD5C1a;
|
||||
const u32 G_w8c1b = w[ 8] + MD5C1b;
|
||||
const u32 G_wdc1c = w[13] + MD5C1c;
|
||||
const u32 G_w2c1d = w[ 2] + MD5C1d;
|
||||
const u32 G_w7c1e = w[ 7] + MD5C1e;
|
||||
const u32 G_wcc1f = w[12] + MD5C1f;
|
||||
|
||||
const u32 H_w5c20 = w[ 5] + MD5C20;
|
||||
const u32 H_w8c21 = w[ 8] + MD5C21;
|
||||
const u32 H_wbc22 = w[11] + MD5C22;
|
||||
const u32 H_wec23 = w[14] + MD5C23;
|
||||
const u32 H_w1c24 = w[ 1] + MD5C24;
|
||||
const u32 H_w4c25 = w[ 4] + MD5C25;
|
||||
const u32 H_w7c26 = w[ 7] + MD5C26;
|
||||
const u32 H_wac27 = w[10] + MD5C27;
|
||||
const u32 H_wdc28 = w[13] + MD5C28;
|
||||
const u32 H_w0c29 = 0u + MD5C29;
|
||||
const u32 H_w3c2a = w[ 3] + MD5C2a;
|
||||
const u32 H_w6c2b = w[ 6] + MD5C2b;
|
||||
const u32 H_w9c2c = w[ 9] + MD5C2c;
|
||||
const u32 H_wcc2d = w[12] + MD5C2d;
|
||||
const u32 H_wfc2e = w[15] + MD5C2e;
|
||||
const u32 H_w2c2f = w[ 2] + MD5C2f;
|
||||
|
||||
const u32 I_w0c30 = 0u + MD5C30;
|
||||
const u32 I_w7c31 = w[ 7] + MD5C31;
|
||||
const u32 I_wec32 = w[14] + MD5C32;
|
||||
const u32 I_w5c33 = w[ 5] + MD5C33;
|
||||
const u32 I_wcc34 = w[12] + MD5C34;
|
||||
const u32 I_w3c35 = w[ 3] + MD5C35;
|
||||
const u32 I_wac36 = w[10] + MD5C36;
|
||||
const u32 I_w1c37 = w[ 1] + MD5C37;
|
||||
const u32 I_w8c38 = w[ 8] + MD5C38;
|
||||
const u32 I_wfc39 = w[15] + MD5C39;
|
||||
const u32 I_w6c3a = w[ 6] + MD5C3a;
|
||||
const u32 I_wdc3b = w[13] + MD5C3b;
|
||||
const u32 I_w4c3c = w[ 4] + MD5C3c;
|
||||
const u32 I_wbc3d = w[11] + MD5C3d;
|
||||
const u32 I_w2c3e = w[ 2] + MD5C3e;
|
||||
const u32 I_w9c3f = w[ 9] + MD5C3f;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
u32 a_rev = digests_buf[digests_offset].digest_buf[0];
|
||||
u32 b_rev = digests_buf[digests_offset].digest_buf[1];
|
||||
u32 c_rev = digests_buf[digests_offset].digest_buf[2];
|
||||
u32 d_rev = digests_buf[digests_offset].digest_buf[3];
|
||||
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 9], MD5C3f, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 2], MD5C3e, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[11], MD5C3d, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 4], MD5C3c, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[13], MD5C3b, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[ 6], MD5C3a, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[15], MD5C39, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[ 8], MD5C38, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 1], MD5C37, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[10], MD5C36, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 3], MD5C35, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, w[12], MD5C34, MD5S30);
|
||||
MD5_STEP_REV (MD5_I_S, b_rev, c_rev, d_rev, a_rev, w[ 5], MD5C33, MD5S33);
|
||||
MD5_STEP_REV (MD5_I_S, c_rev, d_rev, a_rev, b_rev, w[14], MD5C32, MD5S32);
|
||||
MD5_STEP_REV (MD5_I_S, d_rev, a_rev, b_rev, c_rev, w[ 7], MD5C31, MD5S31);
|
||||
MD5_STEP_REV (MD5_I_S, a_rev, b_rev, c_rev, d_rev, 0, MD5C30, MD5S30);
|
||||
|
||||
const u32 pre_cd = c_rev ^ d_rev;
|
||||
|
||||
MD5_STEP_REV1(MD5_H_S, b_rev, c_rev, d_rev, a_rev, w[ 2], MD5C2f, MD5S23);
|
||||
MD5_STEP_REV1(MD5_H_S, c_rev, d_rev, a_rev, b_rev, w[15], MD5C2e, MD5S22);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x pre_d = d_rev;
|
||||
const u32x pre_a = a_rev - w0;
|
||||
const u32x pre_b = b_rev - (pre_a ^ pre_cd);
|
||||
const u32x pre_c = c_rev - (pre_a ^ pre_b ^ pre_d);
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0, F_w0c00, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w1c01, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w2c02, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w3c03, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w4c04, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w5c05, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_w6c06, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_w7c07, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_w8c08, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_w9c09, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wac0a, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wbc0b, MD5S03);
|
||||
MD5_STEP0(MD5_Fo, a, b, c, d, F_wcc0c, MD5S00);
|
||||
MD5_STEP0(MD5_Fo, d, a, b, c, F_wdc0d, MD5S01);
|
||||
MD5_STEP0(MD5_Fo, c, d, a, b, F_wec0e, MD5S02);
|
||||
MD5_STEP0(MD5_Fo, b, c, d, a, F_wfc0f, MD5S03);
|
||||
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w1c10, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w6c11, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wbc12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0, G_w0c13, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w5c14, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wac15, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_wfc16, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w4c17, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_w9c18, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_wec19, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w3c1a, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_w8c1b, MD5S13);
|
||||
MD5_STEP0(MD5_Go, a, b, c, d, G_wdc1c, MD5S10);
|
||||
MD5_STEP0(MD5_Go, d, a, b, c, G_w2c1d, MD5S11);
|
||||
MD5_STEP0(MD5_Go, c, d, a, b, G_w7c1e, MD5S12);
|
||||
MD5_STEP0(MD5_Go, b, c, d, a, G_wcc1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w5c20, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w8c21, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wbc22, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wec23, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w1c24, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_w4c25, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w7c26, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_wac27, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_wdc28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0, H_w0c29, MD5S21);
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_w3c2a, MD5S22);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_c, c)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w6c2b, MD5S23);
|
||||
MD5_STEP0(MD5_H1, a, b, c, d, H_w9c2c, MD5S20);
|
||||
MD5_STEP0(MD5_H2, d, a, b, c, H_wcc2d, MD5S21);
|
||||
|
||||
if (MATCHES_NONE_VV (pre_d, d)) continue;
|
||||
|
||||
MD5_STEP0(MD5_H1, c, d, a, b, H_wfc2e, MD5S22);
|
||||
MD5_STEP0(MD5_H2, b, c, d, a, H_w2c2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0, I_w0c30, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w7c31, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wec32, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w5c33, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_wcc34, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_w3c35, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_wac36, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w1c37, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w8c38, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wfc39, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w6c3a, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_wdc3b, MD5S33);
|
||||
MD5_STEP0(MD5_I , a, b, c, d, I_w4c3c, MD5S30);
|
||||
MD5_STEP0(MD5_I , d, a, b, c, I_wbc3d, MD5S31);
|
||||
MD5_STEP0(MD5_I , c, d, a, b, I_w2c3e, MD5S32);
|
||||
MD5_STEP0(MD5_I , b, c, d, a, I_w9c3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00030_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00030_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00030_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00030_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00030_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
158
yt/OpenCL/m00030_a3-pure.cl
Normal file
158
yt/OpenCL/m00030_a3-pure.cl
Normal file
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00030_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector_utf16le (&ctx, w, pw_len);
|
||||
|
||||
md5_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00030_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector (&ctx);
|
||||
|
||||
md5_update_vector_utf16le (&ctx, w, pw_len);
|
||||
|
||||
md5_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
418
yt/OpenCL/m00040_a0-optimized.cl
Normal file
418
yt/OpenCL/m00040_a0-optimized.cl
Normal file
@@ -0,0 +1,418 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00040_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len2 + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_VV (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = out_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len2 + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_VV (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = out_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
124
yt/OpenCL/m00040_a0-pure.cl
Normal file
124
yt/OpenCL/m00040_a0-pure.cl
Normal file
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00040_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_utf16le (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_utf16le (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
532
yt/OpenCL/m00040_a1-optimized.cl
Normal file
532
yt/OpenCL/m00040_a1-optimized.cl
Normal file
@@ -0,0 +1,532 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00040_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x pw_len2 = pw_len * 2;
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len2 + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x pw_len2 = pw_len * 2;
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len2 + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] = pw_salt_len * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00040_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
114
yt/OpenCL/m00040_a1-pure.cl
Normal file
114
yt/OpenCL/m00040_a1-pure.cl
Normal file
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00040_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
md5_update_global_utf16le (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global_utf16le (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
md5_update_global_utf16le (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
md5_ctx_t ctx = ctx0;
|
||||
|
||||
md5_update_global_utf16le (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
md5_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
660
yt/OpenCL/m00040_a3-optimized.cl
Normal file
660
yt/OpenCL/m00040_a3-optimized.cl
Normal file
@@ -0,0 +1,660 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
DECLSPEC void m00040m (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_le (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = pw_salt_len * 8;
|
||||
t3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, t0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t1[0], MD5C3c, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_M_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00040s (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_le (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = pw_salt_len * 8;
|
||||
t3[3] = 0;
|
||||
|
||||
/**
|
||||
* md5
|
||||
*/
|
||||
|
||||
u32x a = MD5M_A;
|
||||
u32x b = MD5M_B;
|
||||
u32x c = MD5M_C;
|
||||
u32x d = MD5M_D;
|
||||
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t0[0], MD5C00, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t0[1], MD5C01, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t0[2], MD5C02, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t0[3], MD5C03, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t1[0], MD5C04, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t1[1], MD5C05, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t1[2], MD5C06, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t1[3], MD5C07, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t2[0], MD5C08, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t2[1], MD5C09, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t2[2], MD5C0a, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t2[3], MD5C0b, MD5S03);
|
||||
MD5_STEP (MD5_Fo, a, b, c, d, t3[0], MD5C0c, MD5S00);
|
||||
MD5_STEP (MD5_Fo, d, a, b, c, t3[1], MD5C0d, MD5S01);
|
||||
MD5_STEP (MD5_Fo, c, d, a, b, t3[2], MD5C0e, MD5S02);
|
||||
MD5_STEP (MD5_Fo, b, c, d, a, t3[3], MD5C0f, MD5S03);
|
||||
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t0[1], MD5C10, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t1[2], MD5C11, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t2[3], MD5C12, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t0[0], MD5C13, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t1[1], MD5C14, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t2[2], MD5C15, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t3[3], MD5C16, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t1[0], MD5C17, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t2[1], MD5C18, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t3[2], MD5C19, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t0[3], MD5C1a, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t2[0], MD5C1b, MD5S13);
|
||||
MD5_STEP (MD5_Go, a, b, c, d, t3[1], MD5C1c, MD5S10);
|
||||
MD5_STEP (MD5_Go, d, a, b, c, t0[2], MD5C1d, MD5S11);
|
||||
MD5_STEP (MD5_Go, c, d, a, b, t1[3], MD5C1e, MD5S12);
|
||||
MD5_STEP (MD5_Go, b, c, d, a, t3[0], MD5C1f, MD5S13);
|
||||
|
||||
u32x t;
|
||||
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t1[1], MD5C20, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t2[0], MD5C21, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t2[3], MD5C22, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t3[2], MD5C23, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t0[1], MD5C24, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t1[0], MD5C25, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t1[3], MD5C26, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t2[2], MD5C27, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t3[1], MD5C28, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t0[0], MD5C29, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t0[3], MD5C2a, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t1[2], MD5C2b, MD5S23);
|
||||
MD5_STEP (MD5_H1, a, b, c, d, t2[1], MD5C2c, MD5S20);
|
||||
MD5_STEP (MD5_H2, d, a, b, c, t3[0], MD5C2d, MD5S21);
|
||||
MD5_STEP (MD5_H1, c, d, a, b, t3[3], MD5C2e, MD5S22);
|
||||
MD5_STEP (MD5_H2, b, c, d, a, t0[2], MD5C2f, MD5S23);
|
||||
|
||||
MD5_STEP (MD5_I , a, b, c, d, t0[0], MD5C30, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t1[3], MD5C31, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t3[2], MD5C32, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t1[1], MD5C33, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t3[0], MD5C34, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t0[3], MD5C35, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t2[2], MD5C36, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t0[1], MD5C37, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t2[0], MD5C38, MD5S30);
|
||||
MD5_STEP (MD5_I , d, a, b, c, t3[3], MD5C39, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t1[2], MD5C3a, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t3[1], MD5C3b, MD5S33);
|
||||
MD5_STEP (MD5_I , a, b, c, d, t1[0], MD5C3c, MD5S30);
|
||||
|
||||
if (MATCHES_NONE_VS (a, search[0])) continue;
|
||||
|
||||
MD5_STEP (MD5_I , d, a, b, c, t2[3], MD5C3d, MD5S31);
|
||||
MD5_STEP (MD5_I , c, d, a, b, t0[2], MD5C3e, MD5S32);
|
||||
MD5_STEP (MD5_I , b, c, d, a, t2[1], MD5C3f, MD5S33);
|
||||
|
||||
COMPARE_S_SIMD (a, d, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00040_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00040_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00040_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00040_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00040_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00040s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
148
yt/OpenCL/m00040_a3-pure.cl
Normal file
148
yt/OpenCL/m00040_a3-pure.cl
Normal file
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00040_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
md5_update_vector_utf16le (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00040_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
md5_ctx_t ctx0;
|
||||
|
||||
md5_init (&ctx0);
|
||||
|
||||
md5_update_global (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_ctx_vector_t ctx;
|
||||
|
||||
md5_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
md5_update_vector_utf16le (&ctx, w, pw_len);
|
||||
|
||||
md5_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
339
yt/OpenCL/m00050_a0-optimized.cl
Normal file
339
yt/OpenCL/m00050_a0-optimized.cl
Normal file
@@ -0,0 +1,339 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
__kernel void m00050_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0, w1, w2, w3, ipad, opad);
|
||||
|
||||
w0[0] = salt_buf0[0];
|
||||
w0[1] = salt_buf0[1];
|
||||
w0[2] = salt_buf0[2];
|
||||
w0[3] = salt_buf0[3];
|
||||
w1[0] = salt_buf1[0];
|
||||
w1[1] = salt_buf1[1];
|
||||
w1[2] = salt_buf1[2];
|
||||
w1[3] = salt_buf1[3];
|
||||
w2[0] = salt_buf2[0];
|
||||
w2[1] = salt_buf2[1];
|
||||
w2[2] = salt_buf2[2];
|
||||
w2[3] = salt_buf2[3];
|
||||
w3[0] = salt_buf3[0];
|
||||
w3[1] = salt_buf3[1];
|
||||
w3[2] = (64 + salt_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0, w1, w2, w3, ipad, opad);
|
||||
|
||||
w0[0] = salt_buf0[0];
|
||||
w0[1] = salt_buf0[1];
|
||||
w0[2] = salt_buf0[2];
|
||||
w0[3] = salt_buf0[3];
|
||||
w1[0] = salt_buf1[0];
|
||||
w1[1] = salt_buf1[1];
|
||||
w1[2] = salt_buf1[2];
|
||||
w1[3] = salt_buf1[3];
|
||||
w2[0] = salt_buf2[0];
|
||||
w2[1] = salt_buf2[1];
|
||||
w2[2] = salt_buf2[2];
|
||||
w2[3] = salt_buf2[3];
|
||||
w3[0] = salt_buf3[0];
|
||||
w3[1] = salt_buf3[1];
|
||||
w3[2] = (64 + salt_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
134
yt/OpenCL/m00050_a0-pure.cl
Normal file
134
yt/OpenCL/m00050_a0-pure.cl
Normal file
@@ -0,0 +1,134 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00050_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_ctx_t ctx;
|
||||
|
||||
md5_hmac_init (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_update (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_ctx_t ctx;
|
||||
|
||||
md5_hmac_init (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_update (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
457
yt/OpenCL/m00050_a1-optimized.cl
Normal file
457
yt/OpenCL/m00050_a1-optimized.cl
Normal file
@@ -0,0 +1,457 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
__kernel void m00050_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0, w1, w2, w3, ipad, opad);
|
||||
|
||||
w0[0] = salt_buf0[0];
|
||||
w0[1] = salt_buf0[1];
|
||||
w0[2] = salt_buf0[2];
|
||||
w0[3] = salt_buf0[3];
|
||||
w1[0] = salt_buf1[0];
|
||||
w1[1] = salt_buf1[1];
|
||||
w1[2] = salt_buf1[2];
|
||||
w1[3] = salt_buf1[3];
|
||||
w2[0] = salt_buf2[0];
|
||||
w2[1] = salt_buf2[1];
|
||||
w2[2] = salt_buf2[2];
|
||||
w2[3] = salt_buf2[3];
|
||||
w3[0] = salt_buf3[0];
|
||||
w3[1] = salt_buf3[1];
|
||||
w3[2] = (64 + salt_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0, w1, w2, w3, ipad, opad);
|
||||
|
||||
w0[0] = salt_buf0[0];
|
||||
w0[1] = salt_buf0[1];
|
||||
w0[2] = salt_buf0[2];
|
||||
w0[3] = salt_buf0[3];
|
||||
w1[0] = salt_buf1[0];
|
||||
w1[1] = salt_buf1[1];
|
||||
w1[2] = salt_buf1[2];
|
||||
w1[3] = salt_buf1[3];
|
||||
w2[0] = salt_buf2[0];
|
||||
w2[1] = salt_buf2[1];
|
||||
w2[2] = salt_buf2[2];
|
||||
w2[3] = salt_buf2[3];
|
||||
w3[0] = salt_buf3[0];
|
||||
w3[1] = salt_buf3[1];
|
||||
w3[2] = (64 + salt_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00050_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
182
yt/OpenCL/m00050_a1-pure.cl
Normal file
182
yt/OpenCL/m00050_a1-pure.cl
Normal file
@@ -0,0 +1,182 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00050_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32 w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
const u32 comb_len = combs_buf[il_pos].pw_len;
|
||||
|
||||
u32 c[64];
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int idx = 0; idx < 64; idx++)
|
||||
{
|
||||
c[idx] = combs_buf[il_pos].i[idx];
|
||||
}
|
||||
|
||||
switch_buffer_by_offset_1x64_le_S (c, pw_len);
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
c[i] |= w[i];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx;
|
||||
|
||||
md5_hmac_init (&ctx, c, pw_len + comb_len);
|
||||
|
||||
md5_hmac_update (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32 w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
const u32 comb_len = combs_buf[il_pos].pw_len;
|
||||
|
||||
u32 c[64];
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int idx = 0; idx < 64; idx++)
|
||||
{
|
||||
c[idx] = combs_buf[il_pos].i[idx];
|
||||
}
|
||||
|
||||
switch_buffer_by_offset_1x64_le_S (c, pw_len);
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
c[i] |= w[i];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx;
|
||||
|
||||
md5_hmac_init (&ctx, c, pw_len + comb_len);
|
||||
|
||||
md5_hmac_update (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
603
yt/OpenCL/m00050_a3-optimized.cl
Normal file
603
yt/OpenCL/m00050_a3-optimized.cl
Normal file
@@ -0,0 +1,603 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
DECLSPEC void m00050m (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = w0lr;
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = w2[0];
|
||||
w2_t[1] = w2[1];
|
||||
w2_t[2] = w2[2];
|
||||
w2_t[3] = w2[3];
|
||||
w3_t[0] = w3[0];
|
||||
w3_t[1] = w3[1];
|
||||
w3_t[2] = w3[2];
|
||||
w3_t[3] = w3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = (64 + salt_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00050s (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = w0lr;
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = w2[0];
|
||||
w2_t[1] = w2[1];
|
||||
w2_t[2] = w2[2];
|
||||
w2_t[3] = w2[3];
|
||||
w3_t[0] = w3[0];
|
||||
w3_t[1] = w3[1];
|
||||
w3_t[2] = w3[2];
|
||||
w3_t[3] = w3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = (64 + salt_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00050_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00050_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00050_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00050_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00050_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00050s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
154
yt/OpenCL/m00050_a3-pure.cl
Normal file
154
yt/OpenCL/m00050_a3-pure.cl
Normal file
@@ -0,0 +1,154 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00050_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_hmac_ctx_vector_t ctx;
|
||||
|
||||
md5_hmac_init_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_hmac_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.opad.h[DGST_R0];
|
||||
const u32x r1 = ctx.opad.h[DGST_R1];
|
||||
const u32x r2 = ctx.opad.h[DGST_R2];
|
||||
const u32x r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00050_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_hmac_ctx_vector_t ctx;
|
||||
|
||||
md5_hmac_init_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_hmac_update_vector (&ctx, s, salt_len);
|
||||
|
||||
md5_hmac_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.opad.h[DGST_R0];
|
||||
const u32x r1 = ctx.opad.h[DGST_R1];
|
||||
const u32x r2 = ctx.opad.h[DGST_R2];
|
||||
const u32x r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
387
yt/OpenCL/m00060_a0-optimized.cl
Normal file
387
yt/OpenCL/m00060_a0-optimized.cl
Normal file
@@ -0,0 +1,387 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
__kernel void m00060_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
w0_t[0] = w0[0];
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = 0;
|
||||
w2_t[1] = 0;
|
||||
w2_t[2] = 0;
|
||||
w2_t[3] = 0;
|
||||
w3_t[0] = 0;
|
||||
w3_t[1] = 0;
|
||||
w3_t[2] = (64 + out_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
w0_t[0] = w0[0];
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = 0;
|
||||
w2_t[1] = 0;
|
||||
w2_t[2] = 0;
|
||||
w2_t[3] = 0;
|
||||
w3_t[0] = 0;
|
||||
w3_t[1] = 0;
|
||||
w3_t[2] = (64 + out_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
138
yt/OpenCL/m00060_a0-pure.cl
Normal file
138
yt/OpenCL/m00060_a0-pure.cl
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00060_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx0;
|
||||
|
||||
md5_hmac_init (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_ctx_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx0;
|
||||
|
||||
md5_hmac_init (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_ctx_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
467
yt/OpenCL/m00060_a1-optimized.cl
Normal file
467
yt/OpenCL/m00060_a1-optimized.cl
Normal file
@@ -0,0 +1,467 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
__kernel void m00060_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = (64 + pw_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = (64 + pw_len) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0, w1, w2, w3, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00060_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
186
yt/OpenCL/m00060_a1-pure.cl
Normal file
186
yt/OpenCL/m00060_a1-pure.cl
Normal file
@@ -0,0 +1,186 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00060_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32 w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx0;
|
||||
|
||||
md5_hmac_init (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
const u32 comb_len = combs_buf[il_pos].pw_len;
|
||||
|
||||
u32 c[64];
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int idx = 0; idx < 64; idx++)
|
||||
{
|
||||
c[idx] = combs_buf[il_pos].i[idx];
|
||||
}
|
||||
|
||||
switch_buffer_by_offset_1x64_le_S (c, pw_len);
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
c[i] |= w[i];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update (&ctx, c, pw_len + comb_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32 w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx0;
|
||||
|
||||
md5_hmac_init (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
const u32 comb_len = combs_buf[il_pos].pw_len;
|
||||
|
||||
u32 c[64];
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int idx = 0; idx < 64; idx++)
|
||||
{
|
||||
c[idx] = combs_buf[il_pos].i[idx];
|
||||
}
|
||||
|
||||
switch_buffer_by_offset_1x64_le_S (c, pw_len);
|
||||
|
||||
#ifdef _unroll
|
||||
#pragma unroll
|
||||
#endif
|
||||
for (int i = 0; i < 64; i++)
|
||||
{
|
||||
c[i] |= w[i];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update (&ctx, c, pw_len + comb_len);
|
||||
|
||||
md5_hmac_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.opad.h[DGST_R0];
|
||||
const u32 r1 = ctx.opad.h[DGST_R1];
|
||||
const u32 r2 = ctx.opad.h[DGST_R2];
|
||||
const u32 r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
603
yt/OpenCL/m00060_a3-optimized.cl
Normal file
603
yt/OpenCL/m00060_a3-optimized.cl
Normal file
@@ -0,0 +1,603 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
DECLSPEC void hmac_md5_pad (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad)
|
||||
{
|
||||
w0[0] = w0[0] ^ 0x36363636;
|
||||
w0[1] = w0[1] ^ 0x36363636;
|
||||
w0[2] = w0[2] ^ 0x36363636;
|
||||
w0[3] = w0[3] ^ 0x36363636;
|
||||
w1[0] = w1[0] ^ 0x36363636;
|
||||
w1[1] = w1[1] ^ 0x36363636;
|
||||
w1[2] = w1[2] ^ 0x36363636;
|
||||
w1[3] = w1[3] ^ 0x36363636;
|
||||
w2[0] = w2[0] ^ 0x36363636;
|
||||
w2[1] = w2[1] ^ 0x36363636;
|
||||
w2[2] = w2[2] ^ 0x36363636;
|
||||
w2[3] = w2[3] ^ 0x36363636;
|
||||
w3[0] = w3[0] ^ 0x36363636;
|
||||
w3[1] = w3[1] ^ 0x36363636;
|
||||
w3[2] = w3[2] ^ 0x36363636;
|
||||
w3[3] = w3[3] ^ 0x36363636;
|
||||
|
||||
ipad[0] = MD5M_A;
|
||||
ipad[1] = MD5M_B;
|
||||
ipad[2] = MD5M_C;
|
||||
ipad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, ipad);
|
||||
|
||||
w0[0] = w0[0] ^ 0x6a6a6a6a;
|
||||
w0[1] = w0[1] ^ 0x6a6a6a6a;
|
||||
w0[2] = w0[2] ^ 0x6a6a6a6a;
|
||||
w0[3] = w0[3] ^ 0x6a6a6a6a;
|
||||
w1[0] = w1[0] ^ 0x6a6a6a6a;
|
||||
w1[1] = w1[1] ^ 0x6a6a6a6a;
|
||||
w1[2] = w1[2] ^ 0x6a6a6a6a;
|
||||
w1[3] = w1[3] ^ 0x6a6a6a6a;
|
||||
w2[0] = w2[0] ^ 0x6a6a6a6a;
|
||||
w2[1] = w2[1] ^ 0x6a6a6a6a;
|
||||
w2[2] = w2[2] ^ 0x6a6a6a6a;
|
||||
w2[3] = w2[3] ^ 0x6a6a6a6a;
|
||||
w3[0] = w3[0] ^ 0x6a6a6a6a;
|
||||
w3[1] = w3[1] ^ 0x6a6a6a6a;
|
||||
w3[2] = w3[2] ^ 0x6a6a6a6a;
|
||||
w3[3] = w3[3] ^ 0x6a6a6a6a;
|
||||
|
||||
opad[0] = MD5M_A;
|
||||
opad[1] = MD5M_B;
|
||||
opad[2] = MD5M_C;
|
||||
opad[3] = MD5M_D;
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, opad);
|
||||
}
|
||||
|
||||
DECLSPEC void hmac_md5_run (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
|
||||
{
|
||||
digest[0] = ipad[0];
|
||||
digest[1] = ipad[1];
|
||||
digest[2] = ipad[2];
|
||||
digest[3] = ipad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
|
||||
w0[0] = digest[0];
|
||||
w0[1] = digest[1];
|
||||
w0[2] = digest[2];
|
||||
w0[3] = digest[3];
|
||||
w1[0] = 0x80;
|
||||
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] = (64 + 16) * 8;
|
||||
w3[3] = 0;
|
||||
|
||||
digest[0] = opad[0];
|
||||
digest[1] = opad[1];
|
||||
digest[2] = opad[2];
|
||||
digest[3] = opad[3];
|
||||
|
||||
md5_transform_vector (w0, w1, w2, w3, digest);
|
||||
}
|
||||
|
||||
DECLSPEC void m00060m (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esal_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
w0_t[0] = w0lr;
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = w2[0];
|
||||
w2_t[1] = w2[1];
|
||||
w2_t[2] = w2[2];
|
||||
w2_t[3] = w2[3];
|
||||
w3_t[0] = w3[0];
|
||||
w3_t[1] = w3[1];
|
||||
w3_t[2] = (64 + pw_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_M_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00060s (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* pads
|
||||
*/
|
||||
|
||||
u32x w0_t[4];
|
||||
u32x w1_t[4];
|
||||
u32x w2_t[4];
|
||||
u32x w3_t[4];
|
||||
|
||||
w0_t[0] = salt_buf0[0];
|
||||
w0_t[1] = salt_buf0[1];
|
||||
w0_t[2] = salt_buf0[2];
|
||||
w0_t[3] = salt_buf0[3];
|
||||
w1_t[0] = salt_buf1[0];
|
||||
w1_t[1] = salt_buf1[1];
|
||||
w1_t[2] = salt_buf1[2];
|
||||
w1_t[3] = salt_buf1[3];
|
||||
w2_t[0] = salt_buf2[0];
|
||||
w2_t[1] = salt_buf2[1];
|
||||
w2_t[2] = salt_buf2[2];
|
||||
w2_t[3] = salt_buf2[3];
|
||||
w3_t[0] = salt_buf3[0];
|
||||
w3_t[1] = salt_buf3[1];
|
||||
w3_t[2] = salt_buf3[2];
|
||||
w3_t[3] = salt_buf3[3];
|
||||
|
||||
u32x ipad[4];
|
||||
u32x opad[4];
|
||||
|
||||
hmac_md5_pad (w0_t, w1_t, w2_t, w3_t, ipad, opad);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
w0_t[0] = w0lr;
|
||||
w0_t[1] = w0[1];
|
||||
w0_t[2] = w0[2];
|
||||
w0_t[3] = w0[3];
|
||||
w1_t[0] = w1[0];
|
||||
w1_t[1] = w1[1];
|
||||
w1_t[2] = w1[2];
|
||||
w1_t[3] = w1[3];
|
||||
w2_t[0] = w2[0];
|
||||
w2_t[1] = w2[1];
|
||||
w2_t[2] = w2[2];
|
||||
w2_t[3] = w2[3];
|
||||
w3_t[0] = w3[0];
|
||||
w3_t[1] = w3[1];
|
||||
w3_t[2] = (64 + pw_len) * 8;
|
||||
w3_t[3] = 0;
|
||||
|
||||
u32x digest[4];
|
||||
|
||||
hmac_md5_run (w0_t, w1_t, w2_t, w3_t, ipad, opad, digest);
|
||||
|
||||
COMPARE_S_SIMD (digest[0], digest[3], digest[2], digest[1]);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00060_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00060_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00060_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00060_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00060_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00060s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
158
yt/OpenCL/m00060_a3-pure.cl
Normal file
158
yt/OpenCL/m00060_a3-pure.cl
Normal file
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_md5.cl"
|
||||
|
||||
__kernel void m00060_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_vector_t ctx0;
|
||||
|
||||
md5_hmac_init_vector (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_hmac_ctx_vector_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_hmac_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.opad.h[DGST_R0];
|
||||
const u32x r1 = ctx.opad.h[DGST_R1];
|
||||
const u32x r2 = ctx.opad.h[DGST_R2];
|
||||
const u32x r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00060_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = salt_bufs[salt_pos].salt_buf[idx];
|
||||
}
|
||||
|
||||
md5_hmac_ctx_vector_t ctx0;
|
||||
|
||||
md5_hmac_init_vector (&ctx0, s, salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
md5_hmac_ctx_vector_t ctx = ctx0;
|
||||
|
||||
md5_hmac_update_vector (&ctx, w, pw_len);
|
||||
|
||||
md5_hmac_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.opad.h[DGST_R0];
|
||||
const u32x r1 = ctx.opad.h[DGST_R1];
|
||||
const u32x r2 = ctx.opad.h[DGST_R2];
|
||||
const u32x r3 = ctx.opad.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
396
yt/OpenCL/m00100_a0-optimized.cl
Normal file
396
yt/OpenCL/m00100_a0-optimized.cl
Normal file
@@ -0,0 +1,396 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00100_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = out_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
append_0x80_2x4_VV (w0, w1, out_len);
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = out_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
116
yt/OpenCL/m00100_a0-pure.cl
Normal file
116
yt/OpenCL/m00100_a0-pure.cl
Normal file
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00100_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
510
yt/OpenCL/m00100_a1-optimized.cl
Normal file
510
yt/OpenCL/m00100_a1-optimized.cl
Normal file
@@ -0,0 +1,510 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00100_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00100_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
110
yt/OpenCL/m00100_a1-pure.cl
Normal file
110
yt/OpenCL/m00100_a1-pure.cl
Normal file
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00100_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
749
yt/OpenCL/m00100_a3-optimized.cl
Normal file
749
yt/OpenCL/m00100_a3-optimized.cl
Normal file
@@ -0,0 +1,749 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
DECLSPEC void m00100m (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 c_16s = rotl32_S ((w[13] ^ w[ 8] ^ w[ 2] ), 1u);
|
||||
const u32 c_17s = rotl32_S ((w[14] ^ w[ 9] ^ w[ 3] ^ w[ 1]), 1u);
|
||||
const u32 c_18s = rotl32_S ((w[15] ^ w[10] ^ w[ 4] ^ w[ 2]), 1u);
|
||||
const u32 c_19s = rotl32_S ((c_16s ^ w[11] ^ w[ 5] ^ w[ 3]), 1u);
|
||||
const u32 c_20s = rotl32_S ((c_17s ^ w[12] ^ w[ 6] ^ w[ 4]), 1u);
|
||||
const u32 c_21s = rotl32_S ((c_18s ^ w[13] ^ w[ 7] ^ w[ 5]), 1u);
|
||||
const u32 c_22s = rotl32_S ((c_19s ^ w[14] ^ w[ 8] ^ w[ 6]), 1u);
|
||||
const u32 c_23s = rotl32_S ((c_20s ^ w[15] ^ w[ 9] ^ w[ 7]), 1u);
|
||||
const u32 c_24s = rotl32_S ((c_21s ^ c_16s ^ w[10] ^ w[ 8]), 1u);
|
||||
const u32 c_25s = rotl32_S ((c_22s ^ c_17s ^ w[11] ^ w[ 9]), 1u);
|
||||
const u32 c_26s = rotl32_S ((c_23s ^ c_18s ^ w[12] ^ w[10]), 1u);
|
||||
const u32 c_27s = rotl32_S ((c_24s ^ c_19s ^ w[13] ^ w[11]), 1u);
|
||||
const u32 c_28s = rotl32_S ((c_25s ^ c_20s ^ w[14] ^ w[12]), 1u);
|
||||
const u32 c_29s = rotl32_S ((c_26s ^ c_21s ^ w[15] ^ w[13]), 1u);
|
||||
const u32 c_30s = rotl32_S ((c_27s ^ c_22s ^ c_16s ^ w[14]), 1u);
|
||||
const u32 c_31s = rotl32_S ((c_28s ^ c_23s ^ c_17s ^ w[15]), 1u);
|
||||
const u32 c_32s = rotl32_S ((c_29s ^ c_24s ^ c_18s ^ c_16s), 1u);
|
||||
const u32 c_33s = rotl32_S ((c_30s ^ c_25s ^ c_19s ^ c_17s), 1u);
|
||||
const u32 c_34s = rotl32_S ((c_31s ^ c_26s ^ c_20s ^ c_18s), 1u);
|
||||
const u32 c_35s = rotl32_S ((c_32s ^ c_27s ^ c_21s ^ c_19s), 1u);
|
||||
const u32 c_36s = rotl32_S ((c_33s ^ c_28s ^ c_22s ^ c_20s), 1u);
|
||||
const u32 c_37s = rotl32_S ((c_34s ^ c_29s ^ c_23s ^ c_21s), 1u);
|
||||
const u32 c_38s = rotl32_S ((c_35s ^ c_30s ^ c_24s ^ c_22s), 1u);
|
||||
const u32 c_39s = rotl32_S ((c_36s ^ c_31s ^ c_25s ^ c_23s), 1u);
|
||||
const u32 c_40s = rotl32_S ((c_37s ^ c_32s ^ c_26s ^ c_24s), 1u);
|
||||
const u32 c_41s = rotl32_S ((c_38s ^ c_33s ^ c_27s ^ c_25s), 1u);
|
||||
const u32 c_42s = rotl32_S ((c_39s ^ c_34s ^ c_28s ^ c_26s), 1u);
|
||||
const u32 c_43s = rotl32_S ((c_40s ^ c_35s ^ c_29s ^ c_27s), 1u);
|
||||
const u32 c_44s = rotl32_S ((c_41s ^ c_36s ^ c_30s ^ c_28s), 1u);
|
||||
const u32 c_45s = rotl32_S ((c_42s ^ c_37s ^ c_31s ^ c_29s), 1u);
|
||||
const u32 c_46s = rotl32_S ((c_43s ^ c_38s ^ c_32s ^ c_30s), 1u);
|
||||
const u32 c_47s = rotl32_S ((c_44s ^ c_39s ^ c_33s ^ c_31s), 1u);
|
||||
const u32 c_48s = rotl32_S ((c_45s ^ c_40s ^ c_34s ^ c_32s), 1u);
|
||||
const u32 c_49s = rotl32_S ((c_46s ^ c_41s ^ c_35s ^ c_33s), 1u);
|
||||
const u32 c_50s = rotl32_S ((c_47s ^ c_42s ^ c_36s ^ c_34s), 1u);
|
||||
const u32 c_51s = rotl32_S ((c_48s ^ c_43s ^ c_37s ^ c_35s), 1u);
|
||||
const u32 c_52s = rotl32_S ((c_49s ^ c_44s ^ c_38s ^ c_36s), 1u);
|
||||
const u32 c_53s = rotl32_S ((c_50s ^ c_45s ^ c_39s ^ c_37s), 1u);
|
||||
const u32 c_54s = rotl32_S ((c_51s ^ c_46s ^ c_40s ^ c_38s), 1u);
|
||||
const u32 c_55s = rotl32_S ((c_52s ^ c_47s ^ c_41s ^ c_39s), 1u);
|
||||
const u32 c_56s = rotl32_S ((c_53s ^ c_48s ^ c_42s ^ c_40s), 1u);
|
||||
const u32 c_57s = rotl32_S ((c_54s ^ c_49s ^ c_43s ^ c_41s), 1u);
|
||||
const u32 c_58s = rotl32_S ((c_55s ^ c_50s ^ c_44s ^ c_42s), 1u);
|
||||
const u32 c_59s = rotl32_S ((c_56s ^ c_51s ^ c_45s ^ c_43s), 1u);
|
||||
const u32 c_60s = rotl32_S ((c_57s ^ c_52s ^ c_46s ^ c_44s), 1u);
|
||||
const u32 c_61s = rotl32_S ((c_58s ^ c_53s ^ c_47s ^ c_45s), 1u);
|
||||
const u32 c_62s = rotl32_S ((c_59s ^ c_54s ^ c_48s ^ c_46s), 1u);
|
||||
const u32 c_63s = rotl32_S ((c_60s ^ c_55s ^ c_49s ^ c_47s), 1u);
|
||||
const u32 c_64s = rotl32_S ((c_61s ^ c_56s ^ c_50s ^ c_48s), 1u);
|
||||
const u32 c_65s = rotl32_S ((c_62s ^ c_57s ^ c_51s ^ c_49s), 1u);
|
||||
const u32 c_66s = rotl32_S ((c_63s ^ c_58s ^ c_52s ^ c_50s), 1u);
|
||||
const u32 c_67s = rotl32_S ((c_64s ^ c_59s ^ c_53s ^ c_51s), 1u);
|
||||
const u32 c_68s = rotl32_S ((c_65s ^ c_60s ^ c_54s ^ c_52s), 1u);
|
||||
const u32 c_69s = rotl32_S ((c_66s ^ c_61s ^ c_55s ^ c_53s), 1u);
|
||||
const u32 c_70s = rotl32_S ((c_67s ^ c_62s ^ c_56s ^ c_54s), 1u);
|
||||
const u32 c_71s = rotl32_S ((c_68s ^ c_63s ^ c_57s ^ c_55s), 1u);
|
||||
const u32 c_72s = rotl32_S ((c_69s ^ c_64s ^ c_58s ^ c_56s), 1u);
|
||||
const u32 c_73s = rotl32_S ((c_70s ^ c_65s ^ c_59s ^ c_57s), 1u);
|
||||
const u32 c_74s = rotl32_S ((c_71s ^ c_66s ^ c_60s ^ c_58s), 1u);
|
||||
const u32 c_75s = rotl32_S ((c_72s ^ c_67s ^ c_61s ^ c_59s), 1u);
|
||||
|
||||
const u32 c_17sK = c_17s + SHA1C00;
|
||||
const u32 c_18sK = c_18s + SHA1C00;
|
||||
const u32 c_20sK = c_20s + SHA1C01;
|
||||
const u32 c_21sK = c_21s + SHA1C01;
|
||||
const u32 c_23sK = c_23s + SHA1C01;
|
||||
const u32 c_26sK = c_26s + SHA1C01;
|
||||
const u32 c_27sK = c_27s + SHA1C01;
|
||||
const u32 c_29sK = c_29s + SHA1C01;
|
||||
const u32 c_33sK = c_33s + SHA1C01;
|
||||
const u32 c_39sK = c_39s + SHA1C01;
|
||||
const u32 c_41sK = c_41s + SHA1C02;
|
||||
const u32 c_45sK = c_45s + SHA1C02;
|
||||
const u32 c_53sK = c_53s + SHA1C02;
|
||||
const u32 c_65sK = c_65s + SHA1C03;
|
||||
const u32 c_69sK = c_69s + SHA1C03;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x w0s01 = rotl32 (w0, 1u);
|
||||
const u32x w0s02 = rotl32 (w0, 2u);
|
||||
const u32x w0s03 = rotl32 (w0, 3u);
|
||||
const u32x w0s04 = rotl32 (w0, 4u);
|
||||
const u32x w0s05 = rotl32 (w0, 5u);
|
||||
const u32x w0s06 = rotl32 (w0, 6u);
|
||||
const u32x w0s07 = rotl32 (w0, 7u);
|
||||
const u32x w0s08 = rotl32 (w0, 8u);
|
||||
const u32x w0s09 = rotl32 (w0, 9u);
|
||||
const u32x w0s10 = rotl32 (w0, 10u);
|
||||
const u32x w0s11 = rotl32 (w0, 11u);
|
||||
const u32x w0s12 = rotl32 (w0, 12u);
|
||||
const u32x w0s13 = rotl32 (w0, 13u);
|
||||
const u32x w0s14 = rotl32 (w0, 14u);
|
||||
const u32x w0s15 = rotl32 (w0, 15u);
|
||||
const u32x w0s16 = rotl32 (w0, 16u);
|
||||
const u32x w0s17 = rotl32 (w0, 17u);
|
||||
const u32x w0s18 = rotl32 (w0, 18u);
|
||||
const u32x w0s19 = rotl32 (w0, 19u);
|
||||
const u32x w0s20 = rotl32 (w0, 20u);
|
||||
|
||||
const u32x w0s04___w0s06 = w0s04 ^ w0s06;
|
||||
const u32x w0s04___w0s08 = w0s04 ^ w0s08;
|
||||
const u32x w0s08___w0s12 = w0s08 ^ w0s12;
|
||||
const u32x w0s04___w0s06___w0s07 = w0s04___w0s06 ^ w0s07;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 1]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 2]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 3]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 4]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[ 5]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 6]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 7]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 8]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 9]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[10]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[11]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[12]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[13]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[14]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[15]);
|
||||
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, (c_16s ^ w0s01));
|
||||
SHA1_STEPX(SHA1_F0o, d, e, a, b, c, (c_17sK));
|
||||
SHA1_STEPX(SHA1_F0o, c, d, e, a, b, (c_18sK));
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, (c_19s ^ w0s02));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_20sK));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_21sK));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_22s ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_23sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_24s ^ w0s02));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_25s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_26sK));
|
||||
SHA1_STEPX(SHA1_F1 , d, e, a, b, c, (c_27sK));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_28s ^ w0s05));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_29sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_30s ^ w0s02 ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_31s ^ w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_32s ^ w0s02 ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_33sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_34s ^ w0s07));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_35s ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_36s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_37s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_38s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_39sK));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_40s ^ w0s04 ^ w0s09));
|
||||
SHA1_STEPX(SHA1_F2o, e, a, b, c, d, (c_41sK));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_42s ^ w0s06 ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_43s ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_44s ^ w0s03 ^ w0s06 ^ w0s07));
|
||||
SHA1_STEPX(SHA1_F2o, a, b, c, d, e, (c_45sK));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_46s ^ w0s04 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_47s ^ w0s04___w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_48s ^ w0s03 ^ w0s04___w0s08 ^ w0s05 ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_49s ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_50s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_51s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_52s ^ w0s04___w0s08 ^ w0s13));
|
||||
SHA1_STEPX(SHA1_F2o, c, d, e, a, b, (c_53sK));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_54s ^ w0s07 ^ w0s10 ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_55s ^ w0s14));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_56s ^ w0s04___w0s06___w0s07 ^ w0s10 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_57s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_58s ^ w0s04___w0s08 ^ w0s15));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_59s ^ w0s08___w0s12));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_60s ^ w0s04 ^ w0s08___w0s12 ^ w0s07 ^ w0s14));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_61s ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_62s ^ w0s04___w0s06 ^ w0s08___w0s12));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_63s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_64s ^ w0s04___w0s06___w0s07 ^ w0s08___w0s12 ^ w0s17));
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_65sK));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_66s ^ w0s14 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_67s ^ w0s08 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_68s ^ w0s11 ^ w0s14 ^ w0s15));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_69sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_70s ^ w0s12 ^ w0s19));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_71s ^ w0s12 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_72s ^ w0s05 ^ w0s11 ^ w0s12 ^ w0s13 ^ w0s16 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_73s ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_74s ^ w0s08 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_75s ^ w0s06 ^ w0s12 ^ w0s14));
|
||||
|
||||
const u32x c_76s = rotl32 ((c_73s ^ c_68s ^ c_62s ^ c_60s), 1u);
|
||||
const u32x c_77s = rotl32 ((c_74s ^ c_69s ^ c_63s ^ c_61s), 1u);
|
||||
const u32x c_78s = rotl32 ((c_75s ^ c_70s ^ c_64s ^ c_62s), 1u);
|
||||
const u32x c_79s = rotl32 ((c_76s ^ c_71s ^ c_65s ^ c_63s), 1u);
|
||||
|
||||
const u32x w0s21 = rotl32 (w0, 21u);
|
||||
const u32x w0s22 = rotl32 (w0, 22U);
|
||||
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_76s ^ w0s07 ^ w0s08___w0s12 ^ w0s16 ^ w0s21));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_77s));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_78s ^ w0s07 ^ w0s08 ^ w0s15 ^ w0s18 ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_79s ^ w0s08 ^ w0s22));
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00100s (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 c_16s = rotl32_S ((w[13] ^ w[ 8] ^ w[ 2] ), 1u);
|
||||
const u32 c_17s = rotl32_S ((w[14] ^ w[ 9] ^ w[ 3] ^ w[ 1]), 1u);
|
||||
const u32 c_18s = rotl32_S ((w[15] ^ w[10] ^ w[ 4] ^ w[ 2]), 1u);
|
||||
const u32 c_19s = rotl32_S ((c_16s ^ w[11] ^ w[ 5] ^ w[ 3]), 1u);
|
||||
const u32 c_20s = rotl32_S ((c_17s ^ w[12] ^ w[ 6] ^ w[ 4]), 1u);
|
||||
const u32 c_21s = rotl32_S ((c_18s ^ w[13] ^ w[ 7] ^ w[ 5]), 1u);
|
||||
const u32 c_22s = rotl32_S ((c_19s ^ w[14] ^ w[ 8] ^ w[ 6]), 1u);
|
||||
const u32 c_23s = rotl32_S ((c_20s ^ w[15] ^ w[ 9] ^ w[ 7]), 1u);
|
||||
const u32 c_24s = rotl32_S ((c_21s ^ c_16s ^ w[10] ^ w[ 8]), 1u);
|
||||
const u32 c_25s = rotl32_S ((c_22s ^ c_17s ^ w[11] ^ w[ 9]), 1u);
|
||||
const u32 c_26s = rotl32_S ((c_23s ^ c_18s ^ w[12] ^ w[10]), 1u);
|
||||
const u32 c_27s = rotl32_S ((c_24s ^ c_19s ^ w[13] ^ w[11]), 1u);
|
||||
const u32 c_28s = rotl32_S ((c_25s ^ c_20s ^ w[14] ^ w[12]), 1u);
|
||||
const u32 c_29s = rotl32_S ((c_26s ^ c_21s ^ w[15] ^ w[13]), 1u);
|
||||
const u32 c_30s = rotl32_S ((c_27s ^ c_22s ^ c_16s ^ w[14]), 1u);
|
||||
const u32 c_31s = rotl32_S ((c_28s ^ c_23s ^ c_17s ^ w[15]), 1u);
|
||||
const u32 c_32s = rotl32_S ((c_29s ^ c_24s ^ c_18s ^ c_16s), 1u);
|
||||
const u32 c_33s = rotl32_S ((c_30s ^ c_25s ^ c_19s ^ c_17s), 1u);
|
||||
const u32 c_34s = rotl32_S ((c_31s ^ c_26s ^ c_20s ^ c_18s), 1u);
|
||||
const u32 c_35s = rotl32_S ((c_32s ^ c_27s ^ c_21s ^ c_19s), 1u);
|
||||
const u32 c_36s = rotl32_S ((c_33s ^ c_28s ^ c_22s ^ c_20s), 1u);
|
||||
const u32 c_37s = rotl32_S ((c_34s ^ c_29s ^ c_23s ^ c_21s), 1u);
|
||||
const u32 c_38s = rotl32_S ((c_35s ^ c_30s ^ c_24s ^ c_22s), 1u);
|
||||
const u32 c_39s = rotl32_S ((c_36s ^ c_31s ^ c_25s ^ c_23s), 1u);
|
||||
const u32 c_40s = rotl32_S ((c_37s ^ c_32s ^ c_26s ^ c_24s), 1u);
|
||||
const u32 c_41s = rotl32_S ((c_38s ^ c_33s ^ c_27s ^ c_25s), 1u);
|
||||
const u32 c_42s = rotl32_S ((c_39s ^ c_34s ^ c_28s ^ c_26s), 1u);
|
||||
const u32 c_43s = rotl32_S ((c_40s ^ c_35s ^ c_29s ^ c_27s), 1u);
|
||||
const u32 c_44s = rotl32_S ((c_41s ^ c_36s ^ c_30s ^ c_28s), 1u);
|
||||
const u32 c_45s = rotl32_S ((c_42s ^ c_37s ^ c_31s ^ c_29s), 1u);
|
||||
const u32 c_46s = rotl32_S ((c_43s ^ c_38s ^ c_32s ^ c_30s), 1u);
|
||||
const u32 c_47s = rotl32_S ((c_44s ^ c_39s ^ c_33s ^ c_31s), 1u);
|
||||
const u32 c_48s = rotl32_S ((c_45s ^ c_40s ^ c_34s ^ c_32s), 1u);
|
||||
const u32 c_49s = rotl32_S ((c_46s ^ c_41s ^ c_35s ^ c_33s), 1u);
|
||||
const u32 c_50s = rotl32_S ((c_47s ^ c_42s ^ c_36s ^ c_34s), 1u);
|
||||
const u32 c_51s = rotl32_S ((c_48s ^ c_43s ^ c_37s ^ c_35s), 1u);
|
||||
const u32 c_52s = rotl32_S ((c_49s ^ c_44s ^ c_38s ^ c_36s), 1u);
|
||||
const u32 c_53s = rotl32_S ((c_50s ^ c_45s ^ c_39s ^ c_37s), 1u);
|
||||
const u32 c_54s = rotl32_S ((c_51s ^ c_46s ^ c_40s ^ c_38s), 1u);
|
||||
const u32 c_55s = rotl32_S ((c_52s ^ c_47s ^ c_41s ^ c_39s), 1u);
|
||||
const u32 c_56s = rotl32_S ((c_53s ^ c_48s ^ c_42s ^ c_40s), 1u);
|
||||
const u32 c_57s = rotl32_S ((c_54s ^ c_49s ^ c_43s ^ c_41s), 1u);
|
||||
const u32 c_58s = rotl32_S ((c_55s ^ c_50s ^ c_44s ^ c_42s), 1u);
|
||||
const u32 c_59s = rotl32_S ((c_56s ^ c_51s ^ c_45s ^ c_43s), 1u);
|
||||
const u32 c_60s = rotl32_S ((c_57s ^ c_52s ^ c_46s ^ c_44s), 1u);
|
||||
const u32 c_61s = rotl32_S ((c_58s ^ c_53s ^ c_47s ^ c_45s), 1u);
|
||||
const u32 c_62s = rotl32_S ((c_59s ^ c_54s ^ c_48s ^ c_46s), 1u);
|
||||
const u32 c_63s = rotl32_S ((c_60s ^ c_55s ^ c_49s ^ c_47s), 1u);
|
||||
const u32 c_64s = rotl32_S ((c_61s ^ c_56s ^ c_50s ^ c_48s), 1u);
|
||||
const u32 c_65s = rotl32_S ((c_62s ^ c_57s ^ c_51s ^ c_49s), 1u);
|
||||
const u32 c_66s = rotl32_S ((c_63s ^ c_58s ^ c_52s ^ c_50s), 1u);
|
||||
const u32 c_67s = rotl32_S ((c_64s ^ c_59s ^ c_53s ^ c_51s), 1u);
|
||||
const u32 c_68s = rotl32_S ((c_65s ^ c_60s ^ c_54s ^ c_52s), 1u);
|
||||
const u32 c_69s = rotl32_S ((c_66s ^ c_61s ^ c_55s ^ c_53s), 1u);
|
||||
const u32 c_70s = rotl32_S ((c_67s ^ c_62s ^ c_56s ^ c_54s), 1u);
|
||||
const u32 c_71s = rotl32_S ((c_68s ^ c_63s ^ c_57s ^ c_55s), 1u);
|
||||
const u32 c_72s = rotl32_S ((c_69s ^ c_64s ^ c_58s ^ c_56s), 1u);
|
||||
const u32 c_73s = rotl32_S ((c_70s ^ c_65s ^ c_59s ^ c_57s), 1u);
|
||||
const u32 c_74s = rotl32_S ((c_71s ^ c_66s ^ c_60s ^ c_58s), 1u);
|
||||
const u32 c_75s = rotl32_S ((c_72s ^ c_67s ^ c_61s ^ c_59s), 1u);
|
||||
|
||||
const u32 c_17sK = c_17s + SHA1C00;
|
||||
const u32 c_18sK = c_18s + SHA1C00;
|
||||
const u32 c_20sK = c_20s + SHA1C01;
|
||||
const u32 c_21sK = c_21s + SHA1C01;
|
||||
const u32 c_23sK = c_23s + SHA1C01;
|
||||
const u32 c_26sK = c_26s + SHA1C01;
|
||||
const u32 c_27sK = c_27s + SHA1C01;
|
||||
const u32 c_29sK = c_29s + SHA1C01;
|
||||
const u32 c_33sK = c_33s + SHA1C01;
|
||||
const u32 c_39sK = c_39s + SHA1C01;
|
||||
const u32 c_41sK = c_41s + SHA1C02;
|
||||
const u32 c_45sK = c_45s + SHA1C02;
|
||||
const u32 c_53sK = c_53s + SHA1C02;
|
||||
const u32 c_65sK = c_65s + SHA1C03;
|
||||
const u32 c_69sK = c_69s + SHA1C03;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x w0s01 = rotl32 (w0, 1u);
|
||||
const u32x w0s02 = rotl32 (w0, 2u);
|
||||
const u32x w0s03 = rotl32 (w0, 3u);
|
||||
const u32x w0s04 = rotl32 (w0, 4u);
|
||||
const u32x w0s05 = rotl32 (w0, 5u);
|
||||
const u32x w0s06 = rotl32 (w0, 6u);
|
||||
const u32x w0s07 = rotl32 (w0, 7u);
|
||||
const u32x w0s08 = rotl32 (w0, 8u);
|
||||
const u32x w0s09 = rotl32 (w0, 9u);
|
||||
const u32x w0s10 = rotl32 (w0, 10u);
|
||||
const u32x w0s11 = rotl32 (w0, 11u);
|
||||
const u32x w0s12 = rotl32 (w0, 12u);
|
||||
const u32x w0s13 = rotl32 (w0, 13u);
|
||||
const u32x w0s14 = rotl32 (w0, 14u);
|
||||
const u32x w0s15 = rotl32 (w0, 15u);
|
||||
const u32x w0s16 = rotl32 (w0, 16u);
|
||||
const u32x w0s17 = rotl32 (w0, 17u);
|
||||
const u32x w0s18 = rotl32 (w0, 18u);
|
||||
const u32x w0s19 = rotl32 (w0, 19u);
|
||||
const u32x w0s20 = rotl32 (w0, 20u);
|
||||
|
||||
const u32x w0s04___w0s06 = w0s04 ^ w0s06;
|
||||
const u32x w0s04___w0s08 = w0s04 ^ w0s08;
|
||||
const u32x w0s08___w0s12 = w0s08 ^ w0s12;
|
||||
const u32x w0s04___w0s06___w0s07 = w0s04___w0s06 ^ w0s07;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 1]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 2]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 3]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 4]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[ 5]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 6]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 7]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 8]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 9]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[10]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[11]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[12]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[13]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[14]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[15]);
|
||||
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, (c_16s ^ w0s01));
|
||||
SHA1_STEPX(SHA1_F0o, d, e, a, b, c, (c_17sK));
|
||||
SHA1_STEPX(SHA1_F0o, c, d, e, a, b, (c_18sK));
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, (c_19s ^ w0s02));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_20sK));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_21sK));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_22s ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_23sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_24s ^ w0s02));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_25s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_26sK));
|
||||
SHA1_STEPX(SHA1_F1 , d, e, a, b, c, (c_27sK));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_28s ^ w0s05));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_29sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_30s ^ w0s02 ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_31s ^ w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_32s ^ w0s02 ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_33sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_34s ^ w0s07));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_35s ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_36s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_37s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_38s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_39sK));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_40s ^ w0s04 ^ w0s09));
|
||||
SHA1_STEPX(SHA1_F2o, e, a, b, c, d, (c_41sK));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_42s ^ w0s06 ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_43s ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_44s ^ w0s03 ^ w0s06 ^ w0s07));
|
||||
SHA1_STEPX(SHA1_F2o, a, b, c, d, e, (c_45sK));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_46s ^ w0s04 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_47s ^ w0s04___w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_48s ^ w0s03 ^ w0s04___w0s08 ^ w0s05 ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_49s ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_50s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_51s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_52s ^ w0s04___w0s08 ^ w0s13));
|
||||
SHA1_STEPX(SHA1_F2o, c, d, e, a, b, (c_53sK));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_54s ^ w0s07 ^ w0s10 ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_55s ^ w0s14));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_56s ^ w0s04___w0s06___w0s07 ^ w0s10 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_57s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_58s ^ w0s04___w0s08 ^ w0s15));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_59s ^ w0s08___w0s12));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_60s ^ w0s04 ^ w0s08___w0s12 ^ w0s07 ^ w0s14));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_61s ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_62s ^ w0s04___w0s06 ^ w0s08___w0s12));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_63s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_64s ^ w0s04___w0s06___w0s07 ^ w0s08___w0s12 ^ w0s17));
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_65sK));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_66s ^ w0s14 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_67s ^ w0s08 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_68s ^ w0s11 ^ w0s14 ^ w0s15));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_69sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_70s ^ w0s12 ^ w0s19));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_71s ^ w0s12 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_72s ^ w0s05 ^ w0s11 ^ w0s12 ^ w0s13 ^ w0s16 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_73s ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_74s ^ w0s08 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_75s ^ w0s06 ^ w0s12 ^ w0s14));
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
const u32x c_76s = rotl32 ((c_73s ^ c_68s ^ c_62s ^ c_60s), 1u);
|
||||
const u32x c_77s = rotl32 ((c_74s ^ c_69s ^ c_63s ^ c_61s), 1u);
|
||||
const u32x c_78s = rotl32 ((c_75s ^ c_70s ^ c_64s ^ c_62s), 1u);
|
||||
const u32x c_79s = rotl32 ((c_76s ^ c_71s ^ c_65s ^ c_63s), 1u);
|
||||
|
||||
const u32x w0s21 = rotl32 (w0, 21u);
|
||||
const u32x w0s22 = rotl32 (w0, 22U);
|
||||
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_76s ^ w0s07 ^ w0s08___w0s12 ^ w0s16 ^ w0s21));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_77s));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_78s ^ w0s07 ^ w0s08 ^ w0s15 ^ w0s18 ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_79s ^ w0s08 ^ w0s22));
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00100_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00100_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00100_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00100_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00100_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00100s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
136
yt/OpenCL/m00100_a3-pure.cl
Normal file
136
yt/OpenCL/m00100_a3-pure.cl
Normal file
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00100_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector (&ctx);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00100_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector (&ctx);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
542
yt/OpenCL/m00110_a0-optimized.cl
Normal file
542
yt/OpenCL/m00110_a0-optimized.cl
Normal file
@@ -0,0 +1,542 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00110_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len);
|
||||
|
||||
const u32x pw_salt_len = out_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len);
|
||||
|
||||
const u32x pw_salt_len = out_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
138
yt/OpenCL/m00110_a0-pure.cl
Normal file
138
yt/OpenCL/m00110_a0-pure.cl
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00110_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
660
yt/OpenCL/m00110_a1-optimized.cl
Normal file
660
yt/OpenCL/m00110_a1-optimized.cl
Normal file
@@ -0,0 +1,660 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00110_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, pw_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00110_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
132
yt/OpenCL/m00110_a1-pure.cl
Normal file
132
yt/OpenCL/m00110_a1-pure.cl
Normal file
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00110_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
797
yt/OpenCL/m00110_a3-optimized.cl
Normal file
797
yt/OpenCL/m00110_a3-optimized.cl
Normal file
@@ -0,0 +1,797 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
DECLSPEC void m00110m (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
switch_buffer_by_offset_le_S (salt_buf0, salt_buf1, salt_buf2, salt_buf3, pw_len);
|
||||
|
||||
w[ 0] |= swap32_S (salt_buf0[0]);
|
||||
w[ 1] |= swap32_S (salt_buf0[1]);
|
||||
w[ 2] |= swap32_S (salt_buf0[2]);
|
||||
w[ 3] |= swap32_S (salt_buf0[3]);
|
||||
w[ 4] |= swap32_S (salt_buf1[0]);
|
||||
w[ 5] |= swap32_S (salt_buf1[1]);
|
||||
w[ 6] |= swap32_S (salt_buf1[2]);
|
||||
w[ 7] |= swap32_S (salt_buf1[3]);
|
||||
w[ 8] |= swap32_S (salt_buf2[0]);
|
||||
w[ 9] |= swap32_S (salt_buf2[1]);
|
||||
w[10] |= swap32_S (salt_buf2[2]);
|
||||
w[11] |= swap32_S (salt_buf2[3]);
|
||||
w[12] |= swap32_S (salt_buf3[0]);
|
||||
w[13] |= swap32_S (salt_buf3[1]);
|
||||
w[14] |= swap32_S (salt_buf3[2]);
|
||||
w[15] |= swap32_S (salt_buf3[3]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w[15] = pw_salt_len * 8;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 c_16s = rotl32_S ((w[13] ^ w[ 8] ^ w[ 2] ), 1u);
|
||||
const u32 c_17s = rotl32_S ((w[14] ^ w[ 9] ^ w[ 3] ^ w[ 1]), 1u);
|
||||
const u32 c_18s = rotl32_S ((w[15] ^ w[10] ^ w[ 4] ^ w[ 2]), 1u);
|
||||
const u32 c_19s = rotl32_S ((c_16s ^ w[11] ^ w[ 5] ^ w[ 3]), 1u);
|
||||
const u32 c_20s = rotl32_S ((c_17s ^ w[12] ^ w[ 6] ^ w[ 4]), 1u);
|
||||
const u32 c_21s = rotl32_S ((c_18s ^ w[13] ^ w[ 7] ^ w[ 5]), 1u);
|
||||
const u32 c_22s = rotl32_S ((c_19s ^ w[14] ^ w[ 8] ^ w[ 6]), 1u);
|
||||
const u32 c_23s = rotl32_S ((c_20s ^ w[15] ^ w[ 9] ^ w[ 7]), 1u);
|
||||
const u32 c_24s = rotl32_S ((c_21s ^ c_16s ^ w[10] ^ w[ 8]), 1u);
|
||||
const u32 c_25s = rotl32_S ((c_22s ^ c_17s ^ w[11] ^ w[ 9]), 1u);
|
||||
const u32 c_26s = rotl32_S ((c_23s ^ c_18s ^ w[12] ^ w[10]), 1u);
|
||||
const u32 c_27s = rotl32_S ((c_24s ^ c_19s ^ w[13] ^ w[11]), 1u);
|
||||
const u32 c_28s = rotl32_S ((c_25s ^ c_20s ^ w[14] ^ w[12]), 1u);
|
||||
const u32 c_29s = rotl32_S ((c_26s ^ c_21s ^ w[15] ^ w[13]), 1u);
|
||||
const u32 c_30s = rotl32_S ((c_27s ^ c_22s ^ c_16s ^ w[14]), 1u);
|
||||
const u32 c_31s = rotl32_S ((c_28s ^ c_23s ^ c_17s ^ w[15]), 1u);
|
||||
const u32 c_32s = rotl32_S ((c_29s ^ c_24s ^ c_18s ^ c_16s), 1u);
|
||||
const u32 c_33s = rotl32_S ((c_30s ^ c_25s ^ c_19s ^ c_17s), 1u);
|
||||
const u32 c_34s = rotl32_S ((c_31s ^ c_26s ^ c_20s ^ c_18s), 1u);
|
||||
const u32 c_35s = rotl32_S ((c_32s ^ c_27s ^ c_21s ^ c_19s), 1u);
|
||||
const u32 c_36s = rotl32_S ((c_33s ^ c_28s ^ c_22s ^ c_20s), 1u);
|
||||
const u32 c_37s = rotl32_S ((c_34s ^ c_29s ^ c_23s ^ c_21s), 1u);
|
||||
const u32 c_38s = rotl32_S ((c_35s ^ c_30s ^ c_24s ^ c_22s), 1u);
|
||||
const u32 c_39s = rotl32_S ((c_36s ^ c_31s ^ c_25s ^ c_23s), 1u);
|
||||
const u32 c_40s = rotl32_S ((c_37s ^ c_32s ^ c_26s ^ c_24s), 1u);
|
||||
const u32 c_41s = rotl32_S ((c_38s ^ c_33s ^ c_27s ^ c_25s), 1u);
|
||||
const u32 c_42s = rotl32_S ((c_39s ^ c_34s ^ c_28s ^ c_26s), 1u);
|
||||
const u32 c_43s = rotl32_S ((c_40s ^ c_35s ^ c_29s ^ c_27s), 1u);
|
||||
const u32 c_44s = rotl32_S ((c_41s ^ c_36s ^ c_30s ^ c_28s), 1u);
|
||||
const u32 c_45s = rotl32_S ((c_42s ^ c_37s ^ c_31s ^ c_29s), 1u);
|
||||
const u32 c_46s = rotl32_S ((c_43s ^ c_38s ^ c_32s ^ c_30s), 1u);
|
||||
const u32 c_47s = rotl32_S ((c_44s ^ c_39s ^ c_33s ^ c_31s), 1u);
|
||||
const u32 c_48s = rotl32_S ((c_45s ^ c_40s ^ c_34s ^ c_32s), 1u);
|
||||
const u32 c_49s = rotl32_S ((c_46s ^ c_41s ^ c_35s ^ c_33s), 1u);
|
||||
const u32 c_50s = rotl32_S ((c_47s ^ c_42s ^ c_36s ^ c_34s), 1u);
|
||||
const u32 c_51s = rotl32_S ((c_48s ^ c_43s ^ c_37s ^ c_35s), 1u);
|
||||
const u32 c_52s = rotl32_S ((c_49s ^ c_44s ^ c_38s ^ c_36s), 1u);
|
||||
const u32 c_53s = rotl32_S ((c_50s ^ c_45s ^ c_39s ^ c_37s), 1u);
|
||||
const u32 c_54s = rotl32_S ((c_51s ^ c_46s ^ c_40s ^ c_38s), 1u);
|
||||
const u32 c_55s = rotl32_S ((c_52s ^ c_47s ^ c_41s ^ c_39s), 1u);
|
||||
const u32 c_56s = rotl32_S ((c_53s ^ c_48s ^ c_42s ^ c_40s), 1u);
|
||||
const u32 c_57s = rotl32_S ((c_54s ^ c_49s ^ c_43s ^ c_41s), 1u);
|
||||
const u32 c_58s = rotl32_S ((c_55s ^ c_50s ^ c_44s ^ c_42s), 1u);
|
||||
const u32 c_59s = rotl32_S ((c_56s ^ c_51s ^ c_45s ^ c_43s), 1u);
|
||||
const u32 c_60s = rotl32_S ((c_57s ^ c_52s ^ c_46s ^ c_44s), 1u);
|
||||
const u32 c_61s = rotl32_S ((c_58s ^ c_53s ^ c_47s ^ c_45s), 1u);
|
||||
const u32 c_62s = rotl32_S ((c_59s ^ c_54s ^ c_48s ^ c_46s), 1u);
|
||||
const u32 c_63s = rotl32_S ((c_60s ^ c_55s ^ c_49s ^ c_47s), 1u);
|
||||
const u32 c_64s = rotl32_S ((c_61s ^ c_56s ^ c_50s ^ c_48s), 1u);
|
||||
const u32 c_65s = rotl32_S ((c_62s ^ c_57s ^ c_51s ^ c_49s), 1u);
|
||||
const u32 c_66s = rotl32_S ((c_63s ^ c_58s ^ c_52s ^ c_50s), 1u);
|
||||
const u32 c_67s = rotl32_S ((c_64s ^ c_59s ^ c_53s ^ c_51s), 1u);
|
||||
const u32 c_68s = rotl32_S ((c_65s ^ c_60s ^ c_54s ^ c_52s), 1u);
|
||||
const u32 c_69s = rotl32_S ((c_66s ^ c_61s ^ c_55s ^ c_53s), 1u);
|
||||
const u32 c_70s = rotl32_S ((c_67s ^ c_62s ^ c_56s ^ c_54s), 1u);
|
||||
const u32 c_71s = rotl32_S ((c_68s ^ c_63s ^ c_57s ^ c_55s), 1u);
|
||||
const u32 c_72s = rotl32_S ((c_69s ^ c_64s ^ c_58s ^ c_56s), 1u);
|
||||
const u32 c_73s = rotl32_S ((c_70s ^ c_65s ^ c_59s ^ c_57s), 1u);
|
||||
const u32 c_74s = rotl32_S ((c_71s ^ c_66s ^ c_60s ^ c_58s), 1u);
|
||||
const u32 c_75s = rotl32_S ((c_72s ^ c_67s ^ c_61s ^ c_59s), 1u);
|
||||
const u32 c_76s = rotl32_S ((c_73s ^ c_68s ^ c_62s ^ c_60s), 1u);
|
||||
const u32 c_77s = rotl32_S ((c_74s ^ c_69s ^ c_63s ^ c_61s), 1u);
|
||||
const u32 c_78s = rotl32_S ((c_75s ^ c_70s ^ c_64s ^ c_62s), 1u);
|
||||
const u32 c_79s = rotl32_S ((c_76s ^ c_71s ^ c_65s ^ c_63s), 1u);
|
||||
|
||||
const u32 c_17sK = c_17s + SHA1C00;
|
||||
const u32 c_18sK = c_18s + SHA1C00;
|
||||
const u32 c_20sK = c_20s + SHA1C01;
|
||||
const u32 c_21sK = c_21s + SHA1C01;
|
||||
const u32 c_23sK = c_23s + SHA1C01;
|
||||
const u32 c_26sK = c_26s + SHA1C01;
|
||||
const u32 c_27sK = c_27s + SHA1C01;
|
||||
const u32 c_29sK = c_29s + SHA1C01;
|
||||
const u32 c_33sK = c_33s + SHA1C01;
|
||||
const u32 c_39sK = c_39s + SHA1C01;
|
||||
const u32 c_41sK = c_41s + SHA1C02;
|
||||
const u32 c_45sK = c_45s + SHA1C02;
|
||||
const u32 c_53sK = c_53s + SHA1C02;
|
||||
const u32 c_65sK = c_65s + SHA1C03;
|
||||
const u32 c_69sK = c_69s + SHA1C03;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x w0s01 = rotl32 (w0, 1u);
|
||||
const u32x w0s02 = rotl32 (w0, 2u);
|
||||
const u32x w0s03 = rotl32 (w0, 3u);
|
||||
const u32x w0s04 = rotl32 (w0, 4u);
|
||||
const u32x w0s05 = rotl32 (w0, 5u);
|
||||
const u32x w0s06 = rotl32 (w0, 6u);
|
||||
const u32x w0s07 = rotl32 (w0, 7u);
|
||||
const u32x w0s08 = rotl32 (w0, 8u);
|
||||
const u32x w0s09 = rotl32 (w0, 9u);
|
||||
const u32x w0s10 = rotl32 (w0, 10u);
|
||||
const u32x w0s11 = rotl32 (w0, 11u);
|
||||
const u32x w0s12 = rotl32 (w0, 12u);
|
||||
const u32x w0s13 = rotl32 (w0, 13u);
|
||||
const u32x w0s14 = rotl32 (w0, 14u);
|
||||
const u32x w0s15 = rotl32 (w0, 15u);
|
||||
const u32x w0s16 = rotl32 (w0, 16u);
|
||||
const u32x w0s17 = rotl32 (w0, 17u);
|
||||
const u32x w0s18 = rotl32 (w0, 18u);
|
||||
const u32x w0s19 = rotl32 (w0, 19u);
|
||||
const u32x w0s20 = rotl32 (w0, 20u);
|
||||
const u32x w0s21 = rotl32 (w0, 21u);
|
||||
const u32x w0s22 = rotl32 (w0, 22U);
|
||||
|
||||
const u32x w0s04___w0s06 = w0s04 ^ w0s06;
|
||||
const u32x w0s04___w0s08 = w0s04 ^ w0s08;
|
||||
const u32x w0s08___w0s12 = w0s08 ^ w0s12;
|
||||
const u32x w0s04___w0s06___w0s07 = w0s04___w0s06 ^ w0s07;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 1]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 2]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 3]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 4]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[ 5]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 6]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 7]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 8]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 9]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[10]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[11]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[12]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[13]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[14]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[15]);
|
||||
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, (c_16s ^ w0s01));
|
||||
SHA1_STEPX(SHA1_F0o, d, e, a, b, c, (c_17sK));
|
||||
SHA1_STEPX(SHA1_F0o, c, d, e, a, b, (c_18sK));
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, (c_19s ^ w0s02));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_20sK));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_21sK));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_22s ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_23sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_24s ^ w0s02));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_25s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_26sK));
|
||||
SHA1_STEPX(SHA1_F1 , d, e, a, b, c, (c_27sK));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_28s ^ w0s05));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_29sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_30s ^ w0s02 ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_31s ^ w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_32s ^ w0s02 ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_33sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_34s ^ w0s07));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_35s ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_36s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_37s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_38s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_39sK));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_40s ^ w0s04 ^ w0s09));
|
||||
SHA1_STEPX(SHA1_F2o, e, a, b, c, d, (c_41sK));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_42s ^ w0s06 ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_43s ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_44s ^ w0s03 ^ w0s06 ^ w0s07));
|
||||
SHA1_STEPX(SHA1_F2o, a, b, c, d, e, (c_45sK));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_46s ^ w0s04 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_47s ^ w0s04___w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_48s ^ w0s03 ^ w0s04___w0s08 ^ w0s05 ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_49s ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_50s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_51s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_52s ^ w0s04___w0s08 ^ w0s13));
|
||||
SHA1_STEPX(SHA1_F2o, c, d, e, a, b, (c_53sK));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_54s ^ w0s07 ^ w0s10 ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_55s ^ w0s14));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_56s ^ w0s04___w0s06___w0s07 ^ w0s10 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_57s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_58s ^ w0s04___w0s08 ^ w0s15));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_59s ^ w0s08___w0s12));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_60s ^ w0s04 ^ w0s08___w0s12 ^ w0s07 ^ w0s14));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_61s ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_62s ^ w0s04___w0s06 ^ w0s08___w0s12));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_63s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_64s ^ w0s04___w0s06___w0s07 ^ w0s08___w0s12 ^ w0s17));
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_65sK));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_66s ^ w0s14 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_67s ^ w0s08 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_68s ^ w0s11 ^ w0s14 ^ w0s15));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_69sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_70s ^ w0s12 ^ w0s19));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_71s ^ w0s12 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_72s ^ w0s05 ^ w0s11 ^ w0s12 ^ w0s13 ^ w0s16 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_73s ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_74s ^ w0s08 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_75s ^ w0s06 ^ w0s12 ^ w0s14));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_76s ^ w0s07 ^ w0s08___w0s12 ^ w0s16 ^ w0s21));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_77s));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_78s ^ w0s07 ^ w0s08 ^ w0s15 ^ w0s18 ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_79s ^ w0s08 ^ w0s22));
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00110s (u32 *w, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 c_16s = rotl32_S ((w[13] ^ w[ 8] ^ w[ 2] ), 1u);
|
||||
const u32 c_17s = rotl32_S ((w[14] ^ w[ 9] ^ w[ 3] ^ w[ 1]), 1u);
|
||||
const u32 c_18s = rotl32_S ((w[15] ^ w[10] ^ w[ 4] ^ w[ 2]), 1u);
|
||||
const u32 c_19s = rotl32_S ((c_16s ^ w[11] ^ w[ 5] ^ w[ 3]), 1u);
|
||||
const u32 c_20s = rotl32_S ((c_17s ^ w[12] ^ w[ 6] ^ w[ 4]), 1u);
|
||||
const u32 c_21s = rotl32_S ((c_18s ^ w[13] ^ w[ 7] ^ w[ 5]), 1u);
|
||||
const u32 c_22s = rotl32_S ((c_19s ^ w[14] ^ w[ 8] ^ w[ 6]), 1u);
|
||||
const u32 c_23s = rotl32_S ((c_20s ^ w[15] ^ w[ 9] ^ w[ 7]), 1u);
|
||||
const u32 c_24s = rotl32_S ((c_21s ^ c_16s ^ w[10] ^ w[ 8]), 1u);
|
||||
const u32 c_25s = rotl32_S ((c_22s ^ c_17s ^ w[11] ^ w[ 9]), 1u);
|
||||
const u32 c_26s = rotl32_S ((c_23s ^ c_18s ^ w[12] ^ w[10]), 1u);
|
||||
const u32 c_27s = rotl32_S ((c_24s ^ c_19s ^ w[13] ^ w[11]), 1u);
|
||||
const u32 c_28s = rotl32_S ((c_25s ^ c_20s ^ w[14] ^ w[12]), 1u);
|
||||
const u32 c_29s = rotl32_S ((c_26s ^ c_21s ^ w[15] ^ w[13]), 1u);
|
||||
const u32 c_30s = rotl32_S ((c_27s ^ c_22s ^ c_16s ^ w[14]), 1u);
|
||||
const u32 c_31s = rotl32_S ((c_28s ^ c_23s ^ c_17s ^ w[15]), 1u);
|
||||
const u32 c_32s = rotl32_S ((c_29s ^ c_24s ^ c_18s ^ c_16s), 1u);
|
||||
const u32 c_33s = rotl32_S ((c_30s ^ c_25s ^ c_19s ^ c_17s), 1u);
|
||||
const u32 c_34s = rotl32_S ((c_31s ^ c_26s ^ c_20s ^ c_18s), 1u);
|
||||
const u32 c_35s = rotl32_S ((c_32s ^ c_27s ^ c_21s ^ c_19s), 1u);
|
||||
const u32 c_36s = rotl32_S ((c_33s ^ c_28s ^ c_22s ^ c_20s), 1u);
|
||||
const u32 c_37s = rotl32_S ((c_34s ^ c_29s ^ c_23s ^ c_21s), 1u);
|
||||
const u32 c_38s = rotl32_S ((c_35s ^ c_30s ^ c_24s ^ c_22s), 1u);
|
||||
const u32 c_39s = rotl32_S ((c_36s ^ c_31s ^ c_25s ^ c_23s), 1u);
|
||||
const u32 c_40s = rotl32_S ((c_37s ^ c_32s ^ c_26s ^ c_24s), 1u);
|
||||
const u32 c_41s = rotl32_S ((c_38s ^ c_33s ^ c_27s ^ c_25s), 1u);
|
||||
const u32 c_42s = rotl32_S ((c_39s ^ c_34s ^ c_28s ^ c_26s), 1u);
|
||||
const u32 c_43s = rotl32_S ((c_40s ^ c_35s ^ c_29s ^ c_27s), 1u);
|
||||
const u32 c_44s = rotl32_S ((c_41s ^ c_36s ^ c_30s ^ c_28s), 1u);
|
||||
const u32 c_45s = rotl32_S ((c_42s ^ c_37s ^ c_31s ^ c_29s), 1u);
|
||||
const u32 c_46s = rotl32_S ((c_43s ^ c_38s ^ c_32s ^ c_30s), 1u);
|
||||
const u32 c_47s = rotl32_S ((c_44s ^ c_39s ^ c_33s ^ c_31s), 1u);
|
||||
const u32 c_48s = rotl32_S ((c_45s ^ c_40s ^ c_34s ^ c_32s), 1u);
|
||||
const u32 c_49s = rotl32_S ((c_46s ^ c_41s ^ c_35s ^ c_33s), 1u);
|
||||
const u32 c_50s = rotl32_S ((c_47s ^ c_42s ^ c_36s ^ c_34s), 1u);
|
||||
const u32 c_51s = rotl32_S ((c_48s ^ c_43s ^ c_37s ^ c_35s), 1u);
|
||||
const u32 c_52s = rotl32_S ((c_49s ^ c_44s ^ c_38s ^ c_36s), 1u);
|
||||
const u32 c_53s = rotl32_S ((c_50s ^ c_45s ^ c_39s ^ c_37s), 1u);
|
||||
const u32 c_54s = rotl32_S ((c_51s ^ c_46s ^ c_40s ^ c_38s), 1u);
|
||||
const u32 c_55s = rotl32_S ((c_52s ^ c_47s ^ c_41s ^ c_39s), 1u);
|
||||
const u32 c_56s = rotl32_S ((c_53s ^ c_48s ^ c_42s ^ c_40s), 1u);
|
||||
const u32 c_57s = rotl32_S ((c_54s ^ c_49s ^ c_43s ^ c_41s), 1u);
|
||||
const u32 c_58s = rotl32_S ((c_55s ^ c_50s ^ c_44s ^ c_42s), 1u);
|
||||
const u32 c_59s = rotl32_S ((c_56s ^ c_51s ^ c_45s ^ c_43s), 1u);
|
||||
const u32 c_60s = rotl32_S ((c_57s ^ c_52s ^ c_46s ^ c_44s), 1u);
|
||||
const u32 c_61s = rotl32_S ((c_58s ^ c_53s ^ c_47s ^ c_45s), 1u);
|
||||
const u32 c_62s = rotl32_S ((c_59s ^ c_54s ^ c_48s ^ c_46s), 1u);
|
||||
const u32 c_63s = rotl32_S ((c_60s ^ c_55s ^ c_49s ^ c_47s), 1u);
|
||||
const u32 c_64s = rotl32_S ((c_61s ^ c_56s ^ c_50s ^ c_48s), 1u);
|
||||
const u32 c_65s = rotl32_S ((c_62s ^ c_57s ^ c_51s ^ c_49s), 1u);
|
||||
const u32 c_66s = rotl32_S ((c_63s ^ c_58s ^ c_52s ^ c_50s), 1u);
|
||||
const u32 c_67s = rotl32_S ((c_64s ^ c_59s ^ c_53s ^ c_51s), 1u);
|
||||
const u32 c_68s = rotl32_S ((c_65s ^ c_60s ^ c_54s ^ c_52s), 1u);
|
||||
const u32 c_69s = rotl32_S ((c_66s ^ c_61s ^ c_55s ^ c_53s), 1u);
|
||||
const u32 c_70s = rotl32_S ((c_67s ^ c_62s ^ c_56s ^ c_54s), 1u);
|
||||
const u32 c_71s = rotl32_S ((c_68s ^ c_63s ^ c_57s ^ c_55s), 1u);
|
||||
const u32 c_72s = rotl32_S ((c_69s ^ c_64s ^ c_58s ^ c_56s), 1u);
|
||||
const u32 c_73s = rotl32_S ((c_70s ^ c_65s ^ c_59s ^ c_57s), 1u);
|
||||
const u32 c_74s = rotl32_S ((c_71s ^ c_66s ^ c_60s ^ c_58s), 1u);
|
||||
const u32 c_75s = rotl32_S ((c_72s ^ c_67s ^ c_61s ^ c_59s), 1u);
|
||||
|
||||
const u32 c_17sK = c_17s + SHA1C00;
|
||||
const u32 c_18sK = c_18s + SHA1C00;
|
||||
const u32 c_20sK = c_20s + SHA1C01;
|
||||
const u32 c_21sK = c_21s + SHA1C01;
|
||||
const u32 c_23sK = c_23s + SHA1C01;
|
||||
const u32 c_26sK = c_26s + SHA1C01;
|
||||
const u32 c_27sK = c_27s + SHA1C01;
|
||||
const u32 c_29sK = c_29s + SHA1C01;
|
||||
const u32 c_33sK = c_33s + SHA1C01;
|
||||
const u32 c_39sK = c_39s + SHA1C01;
|
||||
const u32 c_41sK = c_41s + SHA1C02;
|
||||
const u32 c_45sK = c_45s + SHA1C02;
|
||||
const u32 c_53sK = c_53s + SHA1C02;
|
||||
const u32 c_65sK = c_65s + SHA1C03;
|
||||
const u32 c_69sK = c_69s + SHA1C03;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32 w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
const u32x w0s01 = rotl32 (w0, 1u);
|
||||
const u32x w0s02 = rotl32 (w0, 2u);
|
||||
const u32x w0s03 = rotl32 (w0, 3u);
|
||||
const u32x w0s04 = rotl32 (w0, 4u);
|
||||
const u32x w0s05 = rotl32 (w0, 5u);
|
||||
const u32x w0s06 = rotl32 (w0, 6u);
|
||||
const u32x w0s07 = rotl32 (w0, 7u);
|
||||
const u32x w0s08 = rotl32 (w0, 8u);
|
||||
const u32x w0s09 = rotl32 (w0, 9u);
|
||||
const u32x w0s10 = rotl32 (w0, 10u);
|
||||
const u32x w0s11 = rotl32 (w0, 11u);
|
||||
const u32x w0s12 = rotl32 (w0, 12u);
|
||||
const u32x w0s13 = rotl32 (w0, 13u);
|
||||
const u32x w0s14 = rotl32 (w0, 14u);
|
||||
const u32x w0s15 = rotl32 (w0, 15u);
|
||||
const u32x w0s16 = rotl32 (w0, 16u);
|
||||
const u32x w0s17 = rotl32 (w0, 17u);
|
||||
const u32x w0s18 = rotl32 (w0, 18u);
|
||||
const u32x w0s19 = rotl32 (w0, 19u);
|
||||
const u32x w0s20 = rotl32 (w0, 20u);
|
||||
|
||||
const u32x w0s04___w0s06 = w0s04 ^ w0s06;
|
||||
const u32x w0s04___w0s08 = w0s04 ^ w0s08;
|
||||
const u32x w0s08___w0s12 = w0s08 ^ w0s12;
|
||||
const u32x w0s04___w0s06___w0s07 = w0s04___w0s06 ^ w0s07;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 1]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 2]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 3]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 4]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[ 5]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[ 6]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[ 7]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[ 8]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[ 9]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[10]);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w[11]);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w[12]);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w[13]);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w[14]);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w[15]);
|
||||
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, (c_16s ^ w0s01));
|
||||
SHA1_STEPX(SHA1_F0o, d, e, a, b, c, (c_17sK));
|
||||
SHA1_STEPX(SHA1_F0o, c, d, e, a, b, (c_18sK));
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, (c_19s ^ w0s02));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_20sK));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_21sK));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_22s ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_23sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_24s ^ w0s02));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_25s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , e, a, b, c, d, (c_26sK));
|
||||
SHA1_STEPX(SHA1_F1 , d, e, a, b, c, (c_27sK));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_28s ^ w0s05));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_29sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_30s ^ w0s02 ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_31s ^ w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_32s ^ w0s02 ^ w0s03));
|
||||
SHA1_STEPX(SHA1_F1 , c, d, e, a, b, (c_33sK));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_34s ^ w0s07));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_35s ^ w0s04));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_36s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_37s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_38s ^ w0s04));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_39sK));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_40s ^ w0s04 ^ w0s09));
|
||||
SHA1_STEPX(SHA1_F2o, e, a, b, c, d, (c_41sK));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_42s ^ w0s06 ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_43s ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_44s ^ w0s03 ^ w0s06 ^ w0s07));
|
||||
SHA1_STEPX(SHA1_F2o, a, b, c, d, e, (c_45sK));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_46s ^ w0s04 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_47s ^ w0s04___w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_48s ^ w0s03 ^ w0s04___w0s08 ^ w0s05 ^ w0s10));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_49s ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_50s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_51s ^ w0s04___w0s06));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_52s ^ w0s04___w0s08 ^ w0s13));
|
||||
SHA1_STEPX(SHA1_F2o, c, d, e, a, b, (c_53sK));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_54s ^ w0s07 ^ w0s10 ^ w0s12));
|
||||
SHA1_STEP (SHA1_F2o, a, b, c, d, e, (c_55s ^ w0s14));
|
||||
SHA1_STEP (SHA1_F2o, e, a, b, c, d, (c_56s ^ w0s04___w0s06___w0s07 ^ w0s10 ^ w0s11));
|
||||
SHA1_STEP (SHA1_F2o, d, e, a, b, c, (c_57s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F2o, c, d, e, a, b, (c_58s ^ w0s04___w0s08 ^ w0s15));
|
||||
SHA1_STEP (SHA1_F2o, b, c, d, e, a, (c_59s ^ w0s08___w0s12));
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_60s ^ w0s04 ^ w0s08___w0s12 ^ w0s07 ^ w0s14));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_61s ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_62s ^ w0s04___w0s06 ^ w0s08___w0s12));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_63s ^ w0s08));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_64s ^ w0s04___w0s06___w0s07 ^ w0s08___w0s12 ^ w0s17));
|
||||
SHA1_STEPX(SHA1_F1 , a, b, c, d, e, (c_65sK));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_66s ^ w0s14 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_67s ^ w0s08 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_68s ^ w0s11 ^ w0s14 ^ w0s15));
|
||||
SHA1_STEPX(SHA1_F1 , b, c, d, e, a, (c_69sK));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_70s ^ w0s12 ^ w0s19));
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_71s ^ w0s12 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_72s ^ w0s05 ^ w0s11 ^ w0s12 ^ w0s13 ^ w0s16 ^ w0s18));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_73s ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_74s ^ w0s08 ^ w0s16));
|
||||
SHA1_STEP (SHA1_F1 , a, b, c, d, e, (c_75s ^ w0s06 ^ w0s12 ^ w0s14));
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
const u32x c_76s = rotl32 ((c_73s ^ c_68s ^ c_62s ^ c_60s), 1u);
|
||||
const u32x c_77s = rotl32 ((c_74s ^ c_69s ^ c_63s ^ c_61s), 1u);
|
||||
const u32x c_78s = rotl32 ((c_75s ^ c_70s ^ c_64s ^ c_62s), 1u);
|
||||
const u32x c_79s = rotl32 ((c_76s ^ c_71s ^ c_65s ^ c_63s), 1u);
|
||||
|
||||
const u32x w0s21 = rotl32 (w0, 21u);
|
||||
const u32x w0s22 = rotl32 (w0, 22U);
|
||||
|
||||
SHA1_STEP (SHA1_F1 , e, a, b, c, d, (c_76s ^ w0s07 ^ w0s08___w0s12 ^ w0s16 ^ w0s21));
|
||||
SHA1_STEP (SHA1_F1 , d, e, a, b, c, (c_77s));
|
||||
SHA1_STEP (SHA1_F1 , c, d, e, a, b, (c_78s ^ w0s07 ^ w0s08 ^ w0s15 ^ w0s18 ^ w0s20));
|
||||
SHA1_STEP (SHA1_F1 , b, c, d, e, a, (c_79s ^ w0s08 ^ w0s22));
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00110_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00110_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00110_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = 0;
|
||||
w[ 5] = 0;
|
||||
w[ 6] = 0;
|
||||
w[ 7] = 0;
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00110_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = 0;
|
||||
w[ 9] = 0;
|
||||
w[10] = 0;
|
||||
w[11] = 0;
|
||||
w[12] = 0;
|
||||
w[13] = 0;
|
||||
w[14] = 0;
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00110_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w[16];
|
||||
|
||||
w[ 0] = pws[gid].i[ 0];
|
||||
w[ 1] = pws[gid].i[ 1];
|
||||
w[ 2] = pws[gid].i[ 2];
|
||||
w[ 3] = pws[gid].i[ 3];
|
||||
w[ 4] = pws[gid].i[ 4];
|
||||
w[ 5] = pws[gid].i[ 5];
|
||||
w[ 6] = pws[gid].i[ 6];
|
||||
w[ 7] = pws[gid].i[ 7];
|
||||
w[ 8] = pws[gid].i[ 8];
|
||||
w[ 9] = pws[gid].i[ 9];
|
||||
w[10] = pws[gid].i[10];
|
||||
w[11] = pws[gid].i[11];
|
||||
w[12] = pws[gid].i[12];
|
||||
w[13] = pws[gid].i[13];
|
||||
w[14] = pws[gid].i[14];
|
||||
w[15] = pws[gid].i[15];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00110s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
158
yt/OpenCL/m00110_a3-pure.cl
Normal file
158
yt/OpenCL/m00110_a3-pure.cl
Normal file
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00110_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector (&ctx);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_update_vector (&ctx, s, salt_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00110_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32x s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector (&ctx);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_update_vector (&ctx, s, salt_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
514
yt/OpenCL/m00120_a0-optimized.cl
Normal file
514
yt/OpenCL/m00120_a0-optimized.cl
Normal file
@@ -0,0 +1,514 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00120_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_VV (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] |= salt_buf3[2];
|
||||
w3[3] |= salt_buf3[3];
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = out_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
const u32x out_salt_len = out_len + salt_len;
|
||||
|
||||
switch_buffer_by_offset_le_VV (w0, w1, w2, w3, salt_len);
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] |= salt_buf3[2];
|
||||
w3[3] |= salt_buf3[3];
|
||||
|
||||
append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len);
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = out_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
124
yt/OpenCL/m00120_a0-pure.cl
Normal file
124
yt/OpenCL/m00120_a0-pure.cl
Normal file
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00120_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
628
yt/OpenCL/m00120_a1-optimized.cl
Normal file
628
yt/OpenCL/m00120_a1-optimized.cl
Normal file
@@ -0,0 +1,628 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00120_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] |= salt_buf3[2];
|
||||
w3[3] |= salt_buf3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_l_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos);
|
||||
|
||||
const u32x pw_len = pw_l_len + pw_r_len;
|
||||
|
||||
/**
|
||||
* concat password candidate
|
||||
*/
|
||||
|
||||
u32x wordl0[4] = { 0 };
|
||||
u32x wordl1[4] = { 0 };
|
||||
u32x wordl2[4] = { 0 };
|
||||
u32x wordl3[4] = { 0 };
|
||||
|
||||
wordl0[0] = pw_buf0[0];
|
||||
wordl0[1] = pw_buf0[1];
|
||||
wordl0[2] = pw_buf0[2];
|
||||
wordl0[3] = pw_buf0[3];
|
||||
wordl1[0] = pw_buf1[0];
|
||||
wordl1[1] = pw_buf1[1];
|
||||
wordl1[2] = pw_buf1[2];
|
||||
wordl1[3] = pw_buf1[3];
|
||||
|
||||
u32x wordr0[4] = { 0 };
|
||||
u32x wordr1[4] = { 0 };
|
||||
u32x wordr2[4] = { 0 };
|
||||
u32x wordr3[4] = { 0 };
|
||||
|
||||
wordr0[0] = ix_create_combt (combs_buf, il_pos, 0);
|
||||
wordr0[1] = ix_create_combt (combs_buf, il_pos, 1);
|
||||
wordr0[2] = ix_create_combt (combs_buf, il_pos, 2);
|
||||
wordr0[3] = ix_create_combt (combs_buf, il_pos, 3);
|
||||
wordr1[0] = ix_create_combt (combs_buf, il_pos, 4);
|
||||
wordr1[1] = ix_create_combt (combs_buf, il_pos, 5);
|
||||
wordr1[2] = ix_create_combt (combs_buf, il_pos, 6);
|
||||
wordr1[3] = ix_create_combt (combs_buf, il_pos, 7);
|
||||
|
||||
if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len);
|
||||
}
|
||||
|
||||
u32x w0[4];
|
||||
u32x w1[4];
|
||||
u32x w2[4];
|
||||
u32x w3[4];
|
||||
|
||||
w0[0] = wordl0[0] | wordr0[0];
|
||||
w0[1] = wordl0[1] | wordr0[1];
|
||||
w0[2] = wordl0[2] | wordr0[2];
|
||||
w0[3] = wordl0[3] | wordr0[3];
|
||||
w1[0] = wordl1[0] | wordr1[0];
|
||||
w1[1] = wordl1[1] | wordr1[1];
|
||||
w1[2] = wordl1[2] | wordr1[2];
|
||||
w1[3] = wordl1[3] | wordr1[3];
|
||||
w2[0] = wordl2[0] | wordr2[0];
|
||||
w2[1] = wordl2[1] | wordr2[1];
|
||||
w2[2] = wordl2[2] | wordr2[2];
|
||||
w2[3] = wordl2[3] | wordr2[3];
|
||||
w3[0] = wordl3[0] | wordr3[0];
|
||||
w3[1] = wordl3[1] | wordr3[1];
|
||||
w3[2] = wordl3[2] | wordr3[2];
|
||||
w3[3] = wordl3[3] | wordr3[3];
|
||||
|
||||
/**
|
||||
* prepend salt
|
||||
*/
|
||||
|
||||
switch_buffer_by_offset_le (w0, w1, w2, w3, salt_len);
|
||||
|
||||
const u32x pw_salt_len = pw_len + salt_len;
|
||||
|
||||
w0[0] |= salt_buf0[0];
|
||||
w0[1] |= salt_buf0[1];
|
||||
w0[2] |= salt_buf0[2];
|
||||
w0[3] |= salt_buf0[3];
|
||||
w1[0] |= salt_buf1[0];
|
||||
w1[1] |= salt_buf1[1];
|
||||
w1[2] |= salt_buf1[2];
|
||||
w1[3] |= salt_buf1[3];
|
||||
w2[0] |= salt_buf2[0];
|
||||
w2[1] |= salt_buf2[1];
|
||||
w2[2] |= salt_buf2[2];
|
||||
w2[3] |= salt_buf2[3];
|
||||
w3[0] |= salt_buf3[0];
|
||||
w3[1] |= salt_buf3[1];
|
||||
w3[2] |= salt_buf3[2];
|
||||
w3[3] |= salt_buf3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00120_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
114
yt/OpenCL/m00120_a1-pure.cl
Normal file
114
yt/OpenCL/m00120_a1-pure.cl
Normal file
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00120_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
sha1_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
sha1_ctx_t ctx = ctx0;
|
||||
|
||||
sha1_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
754
yt/OpenCL/m00120_a3-optimized.cl
Normal file
754
yt/OpenCL/m00120_a3-optimized.cl
Normal file
@@ -0,0 +1,754 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
DECLSPEC void m00120m (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 0]);
|
||||
salt_buf0[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 1]);
|
||||
salt_buf0[2] = swap32_S (salt_bufs[salt_pos].salt_buf[ 2]);
|
||||
salt_buf0[3] = swap32_S (salt_bufs[salt_pos].salt_buf[ 3]);
|
||||
salt_buf1[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 4]);
|
||||
salt_buf1[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 5]);
|
||||
salt_buf1[2] = swap32_S (salt_bufs[salt_pos].salt_buf[ 6]);
|
||||
salt_buf1[3] = swap32_S (salt_bufs[salt_pos].salt_buf[ 7]);
|
||||
salt_buf2[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 8]);
|
||||
salt_buf2[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 9]);
|
||||
salt_buf2[2] = swap32_S (salt_bufs[salt_pos].salt_buf[10]);
|
||||
salt_buf2[3] = swap32_S (salt_bufs[salt_pos].salt_buf[11]);
|
||||
salt_buf3[0] = swap32_S (salt_bufs[salt_pos].salt_buf[12]);
|
||||
salt_buf3[1] = swap32_S (salt_bufs[salt_pos].salt_buf[13]);
|
||||
salt_buf3[2] = swap32_S (salt_bufs[salt_pos].salt_buf[14]);
|
||||
salt_buf3[3] = swap32_S (salt_bufs[salt_pos].salt_buf[15]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_be (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = 0;
|
||||
t3[3] = pw_salt_len * 8;
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = t0[0];
|
||||
u32x w1_t = t0[1];
|
||||
u32x w2_t = t0[2];
|
||||
u32x w3_t = t0[3];
|
||||
u32x w4_t = t1[0];
|
||||
u32x w5_t = t1[1];
|
||||
u32x w6_t = t1[2];
|
||||
u32x w7_t = t1[3];
|
||||
u32x w8_t = t2[0];
|
||||
u32x w9_t = t2[1];
|
||||
u32x wa_t = t2[2];
|
||||
u32x wb_t = t2[3];
|
||||
u32x wc_t = t3[0];
|
||||
u32x wd_t = t3[1];
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
DECLSPEC void m00120s (u32 *w0, u32 *w1, u32 *w2, u32 *w3, const u32 pw_len, __global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 0]);
|
||||
salt_buf0[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 1]);
|
||||
salt_buf0[2] = swap32_S (salt_bufs[salt_pos].salt_buf[ 2]);
|
||||
salt_buf0[3] = swap32_S (salt_bufs[salt_pos].salt_buf[ 3]);
|
||||
salt_buf1[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 4]);
|
||||
salt_buf1[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 5]);
|
||||
salt_buf1[2] = swap32_S (salt_bufs[salt_pos].salt_buf[ 6]);
|
||||
salt_buf1[3] = swap32_S (salt_bufs[salt_pos].salt_buf[ 7]);
|
||||
salt_buf2[0] = swap32_S (salt_bufs[salt_pos].salt_buf[ 8]);
|
||||
salt_buf2[1] = swap32_S (salt_bufs[salt_pos].salt_buf[ 9]);
|
||||
salt_buf2[2] = swap32_S (salt_bufs[salt_pos].salt_buf[10]);
|
||||
salt_buf2[3] = swap32_S (salt_bufs[salt_pos].salt_buf[11]);
|
||||
salt_buf3[0] = swap32_S (salt_bufs[salt_pos].salt_buf[12]);
|
||||
salt_buf3[1] = swap32_S (salt_bufs[salt_pos].salt_buf[13]);
|
||||
salt_buf3[2] = swap32_S (salt_bufs[salt_pos].salt_buf[14]);
|
||||
salt_buf3[3] = swap32_S (salt_bufs[salt_pos].salt_buf[15]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
const u32 pw_salt_len = pw_len + salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
const u32 w0l = w0[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = ix_create_bft (bfs_buf, il_pos);
|
||||
|
||||
const u32x w0lr = w0l | w0r;
|
||||
|
||||
u32x t0[4];
|
||||
u32x t1[4];
|
||||
u32x t2[4];
|
||||
u32x t3[4];
|
||||
|
||||
t0[0] = w0lr;
|
||||
t0[1] = w0[1];
|
||||
t0[2] = w0[2];
|
||||
t0[3] = w0[3];
|
||||
t1[0] = w1[0];
|
||||
t1[1] = w1[1];
|
||||
t1[2] = w1[2];
|
||||
t1[3] = w1[3];
|
||||
t2[0] = w2[0];
|
||||
t2[1] = w2[1];
|
||||
t2[2] = w2[2];
|
||||
t2[3] = w2[3];
|
||||
t3[0] = w3[0];
|
||||
t3[1] = w3[1];
|
||||
t3[2] = w3[2];
|
||||
t3[3] = w3[3];
|
||||
|
||||
switch_buffer_by_offset_be (t0, t1, t2, t3, salt_len);
|
||||
|
||||
t0[0] |= salt_buf0[0];
|
||||
t0[1] |= salt_buf0[1];
|
||||
t0[2] |= salt_buf0[2];
|
||||
t0[3] |= salt_buf0[3];
|
||||
t1[0] |= salt_buf1[0];
|
||||
t1[1] |= salt_buf1[1];
|
||||
t1[2] |= salt_buf1[2];
|
||||
t1[3] |= salt_buf1[3];
|
||||
t2[0] |= salt_buf2[0];
|
||||
t2[1] |= salt_buf2[1];
|
||||
t2[2] |= salt_buf2[2];
|
||||
t2[3] |= salt_buf2[3];
|
||||
t3[0] |= salt_buf3[0];
|
||||
t3[1] |= salt_buf3[1];
|
||||
t3[2] = 0;
|
||||
t3[3] = pw_salt_len * 8;
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = t0[0];
|
||||
u32x w1_t = t0[1];
|
||||
u32x w2_t = t0[2];
|
||||
u32x w3_t = t0[3];
|
||||
u32x w4_t = t1[0];
|
||||
u32x w5_t = t1[1];
|
||||
u32x w6_t = t1[2];
|
||||
u32x w7_t = t1[3];
|
||||
u32x w8_t = t2[0];
|
||||
u32x w9_t = t2[1];
|
||||
u32x wa_t = t2[2];
|
||||
u32x wb_t = t2[3];
|
||||
u32x wc_t = t3[0];
|
||||
u32x wd_t = t3[1];
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_m04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00120_m08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00120_m16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00120_s04 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = 0;
|
||||
w1[1] = 0;
|
||||
w1[2] = 0;
|
||||
w1[3] = 0;
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00120_s08 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = 0;
|
||||
w2[1] = 0;
|
||||
w2[2] = 0;
|
||||
w2[3] = 0;
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = 0;
|
||||
w3[1] = 0;
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
|
||||
__kernel void m00120_s16 (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 w0[4];
|
||||
|
||||
w0[0] = pws[gid].i[ 0];
|
||||
w0[1] = pws[gid].i[ 1];
|
||||
w0[2] = pws[gid].i[ 2];
|
||||
w0[3] = pws[gid].i[ 3];
|
||||
|
||||
u32 w1[4];
|
||||
|
||||
w1[0] = pws[gid].i[ 4];
|
||||
w1[1] = pws[gid].i[ 5];
|
||||
w1[2] = pws[gid].i[ 6];
|
||||
w1[3] = pws[gid].i[ 7];
|
||||
|
||||
u32 w2[4];
|
||||
|
||||
w2[0] = pws[gid].i[ 8];
|
||||
w2[1] = pws[gid].i[ 9];
|
||||
w2[2] = pws[gid].i[10];
|
||||
w2[3] = pws[gid].i[11];
|
||||
|
||||
u32 w3[4];
|
||||
|
||||
w3[0] = pws[gid].i[12];
|
||||
w3[1] = pws[gid].i[13];
|
||||
w3[2] = 0;
|
||||
w3[3] = 0;
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* main
|
||||
*/
|
||||
|
||||
m00120s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_scryptV0_buf, d_scryptV1_buf, d_scryptV2_buf, d_scryptV3_buf, bitmap_mask, bitmap_shift1, bitmap_shift2, salt_pos, loop_pos, loop_cnt, il_cnt, digests_cnt, digests_offset);
|
||||
}
|
||||
148
yt/OpenCL/m00120_a3-pure.cl
Normal file
148
yt/OpenCL/m00120_a3-pure.cl
Normal file
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_simd.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00120_mxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00120_sxx (__global pw_t *pws, __global const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __constant const u32x *words_buf_r, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
u32x w[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
|
||||
{
|
||||
w[idx] = pws[gid].i[idx];
|
||||
}
|
||||
|
||||
sha1_ctx_t ctx0;
|
||||
|
||||
sha1_init (&ctx0);
|
||||
|
||||
sha1_update_global_swap (&ctx0, salt_bufs[salt_pos].salt_buf, salt_bufs[salt_pos].salt_len);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
u32x w0l = w[0];
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
|
||||
|
||||
const u32x w0 = w0l | w0r;
|
||||
|
||||
w[0] = w0;
|
||||
|
||||
sha1_ctx_vector_t ctx;
|
||||
|
||||
sha1_init_vector_from_scalar (&ctx, &ctx0);
|
||||
|
||||
sha1_update_vector (&ctx, w, pw_len);
|
||||
|
||||
sha1_final_vector (&ctx);
|
||||
|
||||
const u32x r0 = ctx.h[DGST_R0];
|
||||
const u32x r1 = ctx.h[DGST_R1];
|
||||
const u32x r2 = ctx.h[DGST_R2];
|
||||
const u32x r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SIMD (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
552
yt/OpenCL/m00130_a0-optimized.cl
Normal file
552
yt/OpenCL/m00130_a0-optimized.cl
Normal file
@@ -0,0 +1,552 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp_optimized.h"
|
||||
#include "inc_rp_optimized.cl"
|
||||
#include "inc_simd.cl"
|
||||
|
||||
__kernel void m00130_m04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len2);
|
||||
|
||||
const u32x pw_salt_len = out_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_M_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00130_m08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00130_m16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00130_s04 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
u32 pw_buf0[4];
|
||||
u32 pw_buf1[4];
|
||||
|
||||
pw_buf0[0] = pws[gid].i[0];
|
||||
pw_buf0[1] = pws[gid].i[1];
|
||||
pw_buf0[2] = pws[gid].i[2];
|
||||
pw_buf0[3] = pws[gid].i[3];
|
||||
pw_buf1[0] = pws[gid].i[4];
|
||||
pw_buf1[1] = pws[gid].i[5];
|
||||
pw_buf1[2] = pws[gid].i[6];
|
||||
pw_buf1[3] = pws[gid].i[7];
|
||||
|
||||
const u32 pw_len = pws[gid].pw_len;
|
||||
|
||||
/**
|
||||
* salt
|
||||
*/
|
||||
|
||||
u32 salt_buf0[4];
|
||||
u32 salt_buf1[4];
|
||||
u32 salt_buf2[4];
|
||||
u32 salt_buf3[4];
|
||||
|
||||
salt_buf0[0] = salt_bufs[salt_pos].salt_buf[ 0];
|
||||
salt_buf0[1] = salt_bufs[salt_pos].salt_buf[ 1];
|
||||
salt_buf0[2] = salt_bufs[salt_pos].salt_buf[ 2];
|
||||
salt_buf0[3] = salt_bufs[salt_pos].salt_buf[ 3];
|
||||
salt_buf1[0] = salt_bufs[salt_pos].salt_buf[ 4];
|
||||
salt_buf1[1] = salt_bufs[salt_pos].salt_buf[ 5];
|
||||
salt_buf1[2] = salt_bufs[salt_pos].salt_buf[ 6];
|
||||
salt_buf1[3] = salt_bufs[salt_pos].salt_buf[ 7];
|
||||
salt_buf2[0] = salt_bufs[salt_pos].salt_buf[ 8];
|
||||
salt_buf2[1] = salt_bufs[salt_pos].salt_buf[ 9];
|
||||
salt_buf2[2] = salt_bufs[salt_pos].salt_buf[10];
|
||||
salt_buf2[3] = salt_bufs[salt_pos].salt_buf[11];
|
||||
salt_buf3[0] = salt_bufs[salt_pos].salt_buf[12];
|
||||
salt_buf3[1] = salt_bufs[salt_pos].salt_buf[13];
|
||||
salt_buf3[2] = salt_bufs[salt_pos].salt_buf[14];
|
||||
salt_buf3[3] = salt_bufs[salt_pos].salt_buf[15];
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* reverse
|
||||
*/
|
||||
|
||||
const u32 e_rev = rotl32_S (search[1], 2u);
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
|
||||
{
|
||||
u32x w0[4] = { 0 };
|
||||
u32x w1[4] = { 0 };
|
||||
u32x w2[4] = { 0 };
|
||||
u32x w3[4] = { 0 };
|
||||
|
||||
const u32x out_len = apply_rules_vect (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1);
|
||||
|
||||
make_utf16le (w1, w2, w3);
|
||||
make_utf16le (w0, w0, w1);
|
||||
|
||||
const u32x out_len2 = out_len * 2;
|
||||
|
||||
/**
|
||||
* append salt
|
||||
*/
|
||||
|
||||
u32x s0[4];
|
||||
u32x s1[4];
|
||||
u32x s2[4];
|
||||
u32x s3[4];
|
||||
|
||||
s0[0] = salt_buf0[0];
|
||||
s0[1] = salt_buf0[1];
|
||||
s0[2] = salt_buf0[2];
|
||||
s0[3] = salt_buf0[3];
|
||||
s1[0] = salt_buf1[0];
|
||||
s1[1] = salt_buf1[1];
|
||||
s1[2] = salt_buf1[2];
|
||||
s1[3] = salt_buf1[3];
|
||||
s2[0] = salt_buf2[0];
|
||||
s2[1] = salt_buf2[1];
|
||||
s2[2] = salt_buf2[2];
|
||||
s2[3] = salt_buf2[3];
|
||||
s3[0] = salt_buf3[0];
|
||||
s3[1] = salt_buf3[1];
|
||||
s3[2] = salt_buf3[2];
|
||||
s3[3] = salt_buf3[3];
|
||||
|
||||
switch_buffer_by_offset_le_VV (s0, s1, s2, s3, out_len2);
|
||||
|
||||
const u32x pw_salt_len = out_len2 + salt_len;
|
||||
|
||||
w0[0] |= s0[0];
|
||||
w0[1] |= s0[1];
|
||||
w0[2] |= s0[2];
|
||||
w0[3] |= s0[3];
|
||||
w1[0] |= s1[0];
|
||||
w1[1] |= s1[1];
|
||||
w1[2] |= s1[2];
|
||||
w1[3] |= s1[3];
|
||||
w2[0] |= s2[0];
|
||||
w2[1] |= s2[1];
|
||||
w2[2] |= s2[2];
|
||||
w2[3] |= s2[3];
|
||||
w3[0] |= s3[0];
|
||||
w3[1] |= s3[1];
|
||||
w3[2] |= s3[2];
|
||||
w3[3] |= s3[3];
|
||||
|
||||
/**
|
||||
* sha1
|
||||
*/
|
||||
|
||||
u32x w0_t = swap32 (w0[0]);
|
||||
u32x w1_t = swap32 (w0[1]);
|
||||
u32x w2_t = swap32 (w0[2]);
|
||||
u32x w3_t = swap32 (w0[3]);
|
||||
u32x w4_t = swap32 (w1[0]);
|
||||
u32x w5_t = swap32 (w1[1]);
|
||||
u32x w6_t = swap32 (w1[2]);
|
||||
u32x w7_t = swap32 (w1[3]);
|
||||
u32x w8_t = swap32 (w2[0]);
|
||||
u32x w9_t = swap32 (w2[1]);
|
||||
u32x wa_t = swap32 (w2[2]);
|
||||
u32x wb_t = swap32 (w2[3]);
|
||||
u32x wc_t = swap32 (w3[0]);
|
||||
u32x wd_t = swap32 (w3[1]);
|
||||
u32x we_t = 0;
|
||||
u32x wf_t = pw_salt_len * 8;
|
||||
|
||||
u32x a = SHA1M_A;
|
||||
u32x b = SHA1M_B;
|
||||
u32x c = SHA1M_C;
|
||||
u32x d = SHA1M_D;
|
||||
u32x e = SHA1M_E;
|
||||
|
||||
#undef K
|
||||
#define K SHA1C00
|
||||
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w0_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w1_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w2_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w3_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w4_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, w5_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, w6_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, w7_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, w8_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, w9_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wa_t);
|
||||
SHA1_STEP (SHA1_F0o, e, a, b, c, d, wb_t);
|
||||
SHA1_STEP (SHA1_F0o, d, e, a, b, c, wc_t);
|
||||
SHA1_STEP (SHA1_F0o, c, d, e, a, b, wd_t);
|
||||
SHA1_STEP (SHA1_F0o, b, c, d, e, a, we_t);
|
||||
SHA1_STEP (SHA1_F0o, a, b, c, d, e, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F0o, e, a, b, c, d, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F0o, d, e, a, b, c, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F0o, c, d, e, a, b, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F0o, b, c, d, e, a, w3_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C01
|
||||
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w7_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C02
|
||||
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wb_t);
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F2o, a, b, c, d, e, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F2o, e, a, b, c, d, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F2o, d, e, a, b, c, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F2o, c, d, e, a, b, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F2o, b, c, d, e, a, wb_t);
|
||||
|
||||
#undef K
|
||||
#define K SHA1C03
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, wf_t);
|
||||
w0_t = rotl32 ((wd_t ^ w8_t ^ w2_t ^ w0_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w0_t);
|
||||
w1_t = rotl32 ((we_t ^ w9_t ^ w3_t ^ w1_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w1_t);
|
||||
w2_t = rotl32 ((wf_t ^ wa_t ^ w4_t ^ w2_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w2_t);
|
||||
w3_t = rotl32 ((w0_t ^ wb_t ^ w5_t ^ w3_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w3_t);
|
||||
w4_t = rotl32 ((w1_t ^ wc_t ^ w6_t ^ w4_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w4_t);
|
||||
w5_t = rotl32 ((w2_t ^ wd_t ^ w7_t ^ w5_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, w5_t);
|
||||
w6_t = rotl32 ((w3_t ^ we_t ^ w8_t ^ w6_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, w6_t);
|
||||
w7_t = rotl32 ((w4_t ^ wf_t ^ w9_t ^ w7_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, w7_t);
|
||||
w8_t = rotl32 ((w5_t ^ w0_t ^ wa_t ^ w8_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, w8_t);
|
||||
w9_t = rotl32 ((w6_t ^ w1_t ^ wb_t ^ w9_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, w9_t);
|
||||
wa_t = rotl32 ((w7_t ^ w2_t ^ wc_t ^ wa_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wa_t);
|
||||
wb_t = rotl32 ((w8_t ^ w3_t ^ wd_t ^ wb_t), 1u); SHA1_STEP (SHA1_F1, a, b, c, d, e, wb_t);
|
||||
|
||||
if (MATCHES_NONE_VS (e, e_rev)) continue;
|
||||
|
||||
wc_t = rotl32 ((w9_t ^ w4_t ^ we_t ^ wc_t), 1u); SHA1_STEP (SHA1_F1, e, a, b, c, d, wc_t);
|
||||
wd_t = rotl32 ((wa_t ^ w5_t ^ wf_t ^ wd_t), 1u); SHA1_STEP (SHA1_F1, d, e, a, b, c, wd_t);
|
||||
we_t = rotl32 ((wb_t ^ w6_t ^ w0_t ^ we_t), 1u); SHA1_STEP (SHA1_F1, c, d, e, a, b, we_t);
|
||||
wf_t = rotl32 ((wc_t ^ w7_t ^ w1_t ^ wf_t), 1u); SHA1_STEP (SHA1_F1, b, c, d, e, a, wf_t);
|
||||
|
||||
COMPARE_S_SIMD (d, e, c, b);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00130_s08 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
|
||||
__kernel void m00130_s16 (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
}
|
||||
138
yt/OpenCL/m00130_a0-pure.cl
Normal file
138
yt/OpenCL/m00130_a0-pure.cl
Normal file
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Author......: See docs/credits.txt
|
||||
* License.....: MIT
|
||||
*/
|
||||
|
||||
//#define NEW_SIMD_CODE
|
||||
|
||||
#include "inc_vendor.cl"
|
||||
#include "inc_hash_constants.h"
|
||||
#include "inc_hash_functions.cl"
|
||||
#include "inc_types.cl"
|
||||
#include "inc_common.cl"
|
||||
#include "inc_rp.h"
|
||||
#include "inc_rp.cl"
|
||||
#include "inc_scalar.cl"
|
||||
#include "inc_hash_sha1.cl"
|
||||
|
||||
__kernel void m00130_mxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_utf16le_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_M_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void m00130_sxx (__global pw_t *pws, __constant const kernel_rule_t *rules_buf, __global const pw_t *combs_buf, __global const bf_t *bfs_buf, __global void *tmps, __global void *hooks, __global const u32 *bitmaps_buf_s1_a, __global const u32 *bitmaps_buf_s1_b, __global const u32 *bitmaps_buf_s1_c, __global const u32 *bitmaps_buf_s1_d, __global const u32 *bitmaps_buf_s2_a, __global const u32 *bitmaps_buf_s2_b, __global const u32 *bitmaps_buf_s2_c, __global const u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global const digest_t *digests_buf, __global u32 *hashes_shown, __global const salt_t *salt_bufs, __global const void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV0_buf, __global u32 *d_scryptV1_buf, __global u32 *d_scryptV2_buf, __global u32 *d_scryptV3_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u64 gid_max)
|
||||
{
|
||||
/**
|
||||
* modifier
|
||||
*/
|
||||
|
||||
const u64 lid = get_local_id (0);
|
||||
const u64 gid = get_global_id (0);
|
||||
|
||||
if (gid >= gid_max) return;
|
||||
|
||||
/**
|
||||
* digest
|
||||
*/
|
||||
|
||||
const u32 search[4] =
|
||||
{
|
||||
digests_buf[digests_offset].digest_buf[DGST_R0],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R1],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R2],
|
||||
digests_buf[digests_offset].digest_buf[DGST_R3]
|
||||
};
|
||||
|
||||
/**
|
||||
* base
|
||||
*/
|
||||
|
||||
COPY_PW (pws[gid]);
|
||||
|
||||
const u32 salt_len = salt_bufs[salt_pos].salt_len;
|
||||
|
||||
u32 s[64] = { 0 };
|
||||
|
||||
for (int i = 0, idx = 0; i < salt_len; i += 4, idx += 1)
|
||||
{
|
||||
s[idx] = swap32_S (salt_bufs[salt_pos].salt_buf[idx]);
|
||||
}
|
||||
|
||||
/**
|
||||
* loop
|
||||
*/
|
||||
|
||||
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
|
||||
{
|
||||
pw_t tmp = PASTE_PW;
|
||||
|
||||
tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_ctx_t ctx;
|
||||
|
||||
sha1_init (&ctx);
|
||||
|
||||
sha1_update_utf16le_swap (&ctx, tmp.i, tmp.pw_len);
|
||||
|
||||
sha1_update (&ctx, s, salt_len);
|
||||
|
||||
sha1_final (&ctx);
|
||||
|
||||
const u32 r0 = ctx.h[DGST_R0];
|
||||
const u32 r1 = ctx.h[DGST_R1];
|
||||
const u32 r2 = ctx.h[DGST_R2];
|
||||
const u32 r3 = ctx.h[DGST_R3];
|
||||
|
||||
COMPARE_S_SCALAR (r0, r1, r2, r3);
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user