/**
* 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