1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
/**
* Author......: See docs/credits.txt
* License.....: MIT
*/
#ifndef _BRAIN_H
#define _BRAIN_H
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <errno.h>
#include <dirent.h>
#include <search.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#if defined (_WIN)
#define _WINNT_WIN32 0x0601
#include <ws2tcpip.h>
#include <winsock2.h>
#include <wincrypt.h>
#define SEND_FLAGS 0
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
#if defined (__linux__)
#define SEND_FLAGS MSG_NOSIGNAL
#else
#define SEND_FLAGS 0
#endif
#endif
#include "xxhash.h"
static const int BRAIN_CLIENT_CONNECT_TIMEOUT = 5;
static const int BRAIN_SERVER_TIMER = 5 * 60;
static const int BRAIN_SERVER_SESSIONS_MAX = 64;
static const int BRAIN_SERVER_ATTACKS_MAX = 64 * 1024;
static const int BRAIN_SERVER_CLIENTS_MAX = 256;
static const int BRAIN_SERVER_REALLOC_HASH_SIZE = 1024 * 1024;
static const int BRAIN_SERVER_REALLOC_ATTACK_SIZE = 1024;
static const int BRAIN_HASH_SIZE = 2 * sizeof (u32);
static const int BRAIN_LINK_VERSION_CUR = 1;
static const int BRAIN_LINK_VERSION_MIN = 1;
static const int BRAIN_LINK_CHUNK_SIZE = 4 * 1024;
static const int BRAIN_LINK_CANDIDATES_MAX = 128 * 1024 * 256; // units * threads * accel
typedef enum brain_operation
{
BRAIN_OPERATION_COMMIT = 1,
BRAIN_OPERATION_HASH_LOOKUP = 2,
BRAIN_OPERATION_ATTACK_RESERVE = 3,
} brain_operation_t;
typedef enum brain_client_feature
{
BRAIN_CLIENT_FEATURE_HASHES = 1,
BRAIN_CLIENT_FEATURE_ATTACKS = 2,
} brain_client_feature_t;
typedef struct brain_server_attack_long
{
u64 offset;
u64 length;
} brain_server_attack_long_t;
typedef struct brain_server_attack_short
{
u64 offset;
u64 length;
int client_idx;
} brain_server_attack_short_t;
typedef struct brain_server_hash_long
{
u32 hash[2];
} brain_server_hash_long_t;
typedef struct brain_server_hash_short
{
u32 hash[2];
} brain_server_hash_short_t;
typedef struct brain_server_hash_unique
{
u32 hash[2];
i64 hash_idx;
} brain_server_hash_unique_t;
typedef struct brain_server_db_attack
{
u32 brain_attack;
brain_server_attack_short_t *short_buf;
i64 short_alloc;
i64 short_cnt;
brain_server_attack_long_t *long_buf;
i64 long_alloc;
i64 long_cnt;
int ab;
hc_thread_mutex_t mux_ar;
hc_thread_mutex_t mux_ag;
bool write_attacks;
} brain_server_db_attack_t;
typedef struct brain_server_db_hash
{
u32 brain_session;
brain_server_hash_long_t *long_buf;
i64 long_alloc;
i64 long_cnt;
int hb;
hc_thread_mutex_t mux_hr;
hc_thread_mutex_t mux_hg;
bool write_hashes;
} brain_server_db_hash_t;
typedef struct brain_server_db_short
{
brain_server_hash_short_t *short_buf;
i64 short_cnt;
} brain_server_db_short_t;
typedef struct brain_server_dbs
{
// required for cyclic dump
hc_thread_mutex_t mux_dbs;
brain_server_db_hash_t *hash_buf;
brain_server_db_attack_t *attack_buf;
int hash_cnt;
int attack_cnt;
int *client_slots;
} brain_server_dbs_t;
typedef struct brain_server_dumper_options
{
brain_server_dbs_t *brain_server_dbs;
u32 brain_server_timer;
} brain_server_dumper_options_t;
typedef struct brain_server_client_options
{
brain_server_dbs_t *brain_server_dbs;
int client_idx;
int client_fd;
char *auth_password;
u32 *session_whitelist_buf;
int session_whitelist_cnt;
} brain_server_client_options_t;
int brain_logging (FILE *stream, const int client_idx, const char *format, ...);
u32 brain_compute_session (hashcat_ctx_t *hashcat_ctx);
u32 brain_compute_attack (hashcat_ctx_t *hashcat_ctx);
u64 brain_compute_attack_wordlist (const char *filename);
u32 brain_auth_challenge (void);
u64 brain_auth_hash (const u32 challenge, const char *pw_buf, const int pw_len);
int brain_connect (int sockfd, const struct sockaddr *addr, socklen_t addrlen, const int timeout);
bool brain_recv (int sockfd, void *buf, size_t len, int flags, hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_send (int sockfd, void *buf, size_t len, int flags, hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_recv_all (int sockfd, void *buf, size_t len, int flags, hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_send_all (int sockfd, void *buf, size_t len, int flags, hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_client_reserve (hc_device_param_t *device_param, const status_ctx_t *status_ctx, u64 words_off, u64 work, u64 *overlap);
bool brain_client_commit (hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_client_lookup (hc_device_param_t *device_param, const status_ctx_t *status_ctx);
bool brain_client_connect (hc_device_param_t *device_param, const status_ctx_t *status_ctx, const char *host, const int port, const char *password, u32 brain_session, u32 brain_attack, i64 passwords_max, u64 *highest);
void brain_client_disconnect (hc_device_param_t *device_param);
void brain_client_generate_hash (u64 *hash, const char *line_buf, const size_t line_len);
int brain_server (const char *listen_host, const int listen_port, const char *brain_password, const char *brain_session_whitelist, const u32 brain_server_timer);
bool brain_server_read_hash_dumps (brain_server_dbs_t *brain_server_dbs, const char *path);
bool brain_server_write_hash_dumps (brain_server_dbs_t *brain_server_dbs, const char *path);
bool brain_server_read_hash_dump (brain_server_db_hash_t *brain_server_db_hash, const char *file);
bool brain_server_write_hash_dump (brain_server_db_hash_t *brain_server_db_hash, const char *file);
bool brain_server_read_attack_dumps (brain_server_dbs_t *brain_server_dbs, const char *path);
bool brain_server_write_attack_dumps (brain_server_dbs_t *brain_server_dbs, const char *path);
bool brain_server_read_attack_dump (brain_server_db_attack_t *brain_server_db_attack, const char *file);
bool brain_server_write_attack_dump (brain_server_db_attack_t *brain_server_db_attack, const char *file);
int brain_server_get_client_idx (brain_server_dbs_t *brain_server_dbs);
u64 brain_server_highest_attack (const brain_server_db_attack_t *buf);
u64 brain_server_highest_attack_long (const brain_server_attack_long_t *buf, const i64 cnt, const u64 start);
u64 brain_server_highest_attack_short (const brain_server_attack_short_t *buf, const i64 cnt, const u64 start);
u64 brain_server_find_attack_long (const brain_server_attack_long_t *buf, const i64 cnt, const u64 offset, const u64 length);
u64 brain_server_find_attack_short (const brain_server_attack_short_t *buf, const i64 cnt, const u64 offset, const u64 length);
i64 brain_server_find_hash_long (const u32 *search, const brain_server_hash_long_t *buf, const i64 cnt);
i64 brain_server_find_hash_short (const u32 *search, const brain_server_hash_short_t *buf, const i64 cnt);
int brain_server_sort_db_hash (const void *v1, const void *v2);
int brain_server_sort_db_attack (const void *v1, const void *v2);
int brain_server_sort_attack_long (const void *v1, const void *v2);
int brain_server_sort_attack_short (const void *v1, const void *v2);
int brain_server_sort_hash (const void *v1, const void *v2);
int brain_server_sort_hash_long (const void *v1, const void *v2);
int brain_server_sort_hash_short (const void *v1, const void *v2);
int brain_server_sort_hash_unique (const void *v1, const void *v2);
void brain_server_handle_signal (int signo);
void *brain_server_handle_client (void *p);
void *brain_server_handle_dumps (void *p);
void brain_server_db_hash_init (brain_server_db_hash_t *brain_server_db_hash, const u32 brain_session);
bool brain_server_db_hash_realloc (brain_server_db_hash_t *brain_server_db_hash, const i64 new_long_cnt);
void brain_server_db_hash_free (brain_server_db_hash_t *brain_server_db_hash);
void brain_server_db_attack_init (brain_server_db_attack_t *brain_server_db_attack, const u32 brain_attack);
bool brain_server_db_attack_realloc (brain_server_db_attack_t *brain_server_db_attack, const i64 new_long_cnt, const i64 new_short_cnt);
void brain_server_db_attack_free (brain_server_db_attack_t *brain_server_db_attack);
int brain_ctx_init (hashcat_ctx_t *hashcat_ctx);
void brain_ctx_destroy (hashcat_ctx_t *hashcat_ctx);
#endif // _BRAIN_H
|
