/**
* Authors.....: Jens Steube <jens.steube@gmail.com>
* Gabriele Gristina <matrix@hashcat.net>
+ * magnum <john.magnum@hushmail.com>
*
* License.....: MIT
*/
#include <shared.h>
#include <limits.h>
-/**
- * tuning tools
- */
-
-#define GET_ACCEL(x) KERNEL_ACCEL_ ## x
-#define GET_LOOPS(x) KERNEL_LOOPS_ ## x
-
/**
* basic bit handling
*/
+u32 is_power_of_2(u32 v)
+{
+ return (v && !(v & (v - 1)));
+}
+
u32 rotl32 (const u32 a, const u32 n)
{
return ((a << n) | (a >> (32 - n)));
lock.l_type = F_UNLCK;
fcntl(fileno(fp), F_SETLK, &lock);
}
-#endif /* F_SETLKW */
+#endif // F_SETLKW
#ifdef _WIN
void fsync (int fd)
{
NvU32 pGpuCount;
- if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle, &pGpuCount) != NVAPI_OK) return (0);
+ if (hm_NvAPI_EnumPhysicalGPUs (data.hm_nv, nvGPUHandle, &pGpuCount) != NVAPI_OK) return (0);
if (pGpuCount == 0)
{
for (uint i = 0; i < DEVICES_MAX; i++)
{
- if (hc_NVML_nvmlDeviceGetHandleByIndex (data.hm_dll_nv, 1, i, &nvGPUHandle[i]) != NVML_SUCCESS) break;
+ if (hm_NVML_nvmlDeviceGetHandleByIndex (data.hm_nv, 1, i, &nvGPUHandle[i]) != NVML_SUCCESS) break;
// can be used to determine if the device by index matches the cuda device by index
// char name[100]; memset (name, 0, sizeof (name));
- // hc_NVML_nvmlDeviceGetName (data.hm_dll_nv, nvGPUHandle[i], name, sizeof (name) - 1);
+ // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
pGpuCount++;
}
}
#endif // LINUX && HAVE_NVML
-#if defined(HAVE_ADL) || defined(HAVE_NVML)
-void hm_close (HM_LIB hm_dll)
-{
- #ifdef _POSIX
- dlclose (hm_dll);
-
- #elif _WIN
- FreeLibrary (hm_dll);
-
- #endif
-}
-
-HM_LIB hm_init (const cl_uint vendor_id)
-{
- HM_LIB hm_dll = NULL;
-
- #ifdef HAVE_ADL
- if (vendor_id == VENDOR_ID_AMD)
- {
- #ifdef _POSIX
- hm_dll = dlopen ("libatiadlxx.so", RTLD_LAZY | RTLD_GLOBAL);
-
- #elif _WIN
- hm_dll = LoadLibrary ("atiadlxx.dll");
-
- if (hm_dll == NULL)
- {
- hm_dll = LoadLibrary ("atiadlxy.dll");
- }
-
- #endif
- }
- #endif
-
- #if defined(LINUX) && defined(HAVE_NVML)
- if (vendor_id == VENDOR_ID_NV)
- {
- hm_dll = dlopen ("libnvidia-ml.so", RTLD_LAZY | RTLD_GLOBAL);
- }
- #endif
-
- return hm_dll;
-}
-#endif // HAVE_ADL || HAVE_NVML
-
#ifdef HAVE_ADL
int get_adapters_num_amd (void *adl, int *iNumberAdapters)
{
- if (hc_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR *) adl, iNumberAdapters) != ADL_OK) return -1;
+ if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR *) adl, iNumberAdapters) != ADL_OK) return -1;
if (iNumberAdapters == 0)
{
lpOdParameters.iSize = sizeof (ADLODParameters);
size_t plevels_size = 0;
- if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
__func__, iAdapterIndex,
lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
- if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
LPAdapterInfo lpAdapterInfo = (LPAdapterInfo) mymalloc (AdapterInfoSize);
- if (hc_ADL_Adapter_AdapterInfo_Get ((ADL_PTR *) adl, lpAdapterInfo, AdapterInfoSize) != ADL_OK) return NULL;
+ if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR *) adl, lpAdapterInfo, AdapterInfoSize) != ADL_OK) return NULL;
return lpAdapterInfo;
}
FanSpeedInfo.iSize = sizeof (ADLFanSpeedInfo);
- if (hc_ADL_Overdrive5_FanSpeedInfo_Get (adl, info.iAdapterIndex, 0, &FanSpeedInfo) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl, info.iAdapterIndex, 0, &FanSpeedInfo) != ADL_OK) return -1;
// check read and write capability in fanspeedinfo
memset (&faninfo, 0, sizeof (faninfo));
- if (hc_ADL_Overdrive6_FanSpeed_Get (adl, info.iAdapterIndex, &faninfo) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive6_FanSpeed_Get (adl, info.iAdapterIndex, &faninfo) != ADL_OK) return -1;
// check read capability in fanspeedinfo
int od_enabled = 0;
int od_version = 0;
- if (hc_ADL_Overdrive_Caps (adl, info.iAdapterIndex, &od_supported, &od_enabled, &od_version) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive_Caps (adl, info.iAdapterIndex, &od_supported, &od_enabled, &od_version) != ADL_OK) return -1;
// store the overdrive version in hm_device
#ifdef HAVE_ADL
if (data.devices_param[device_id].vendor_id == VENDOR_ID_AMD)
{
- if (data.adl)
+ if (data.hm_amd)
{
if (data.hm_device[device_id].od_version == 5)
{
Temperature.iSize = sizeof (ADLTemperature);
- if (hc_ADL_Overdrive5_Temperature_Get (data.adl, data.hm_device[device_id].adapter_index.amd, 0, &Temperature) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive5_Temperature_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 0, &Temperature) != ADL_OK) return -1;
return Temperature.iTemperature / 1000;
}
{
int Temperature = 0;
- if (hc_ADL_Overdrive6_Temperature_Get (data.adl, data.hm_device[device_id].adapter_index.amd, &Temperature) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive6_Temperature_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &Temperature) != ADL_OK) return -1;
return Temperature / 1000;
}
#if defined(LINUX) && defined(HAVE_NVML)
int temperature = 0;
- hc_NVML_nvmlDeviceGetTemperature (data.hm_dll_nv, data.hm_device[device_id].adapter_index.nv, NVML_TEMPERATURE_GPU, (unsigned int *) &temperature);
+ hm_NVML_nvmlDeviceGetTemperature (data.hm_nv, data.hm_device[device_id].adapter_index.nv, NVML_TEMPERATURE_GPU, (uint *) &temperature);
return temperature;
#endif
pThermalSettings.sensor[0].controller = NVAPI_THERMAL_CONTROLLER_UNKNOWN;
pThermalSettings.sensor[0].target = NVAPI_THERMAL_TARGET_GPU;
- if (hc_NvAPI_GPU_GetThermalSettings (data.hm_device[device_id].adapter_index.nv, 0, &pThermalSettings) != NVAPI_OK) return -1;
+ if (hm_NvAPI_GPU_GetThermalSettings (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &pThermalSettings) != NVAPI_OK) return -1;
return pThermalSettings.sensor[0].currentTemp;
#endif // WIN && HAVE_NVAPI
#ifdef HAVE_ADL
if (data.devices_param[device_id].vendor_id == VENDOR_ID_AMD)
{
- if (data.adl)
+ if (data.hm_amd)
{
if (data.hm_device[device_id].od_version == 5)
{
lpFanSpeedValue.iSpeedType = ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
lpFanSpeedValue.iFlags = ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED;
- if (hc_ADL_Overdrive5_FanSpeed_Get (data.adl, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive5_FanSpeed_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
return lpFanSpeedValue.iFanSpeed;
}
memset (&faninfo, 0, sizeof (faninfo));
- if (hc_ADL_Overdrive6_FanSpeed_Get (data.adl, data.hm_device[device_id].adapter_index.amd, &faninfo) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive6_FanSpeed_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &faninfo) != ADL_OK) return -1;
return faninfo.iFanSpeedPercent;
}
#if defined(LINUX) && defined(HAVE_NVML)
int speed = 0;
- hc_NVML_nvmlDeviceGetFanSpeed (data.hm_dll_nv, 1, data.hm_device[device_id].adapter_index.nv, (unsigned int *) &speed);
+ hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, data.hm_device[device_id].adapter_index.nv, (uint *) &speed);
return speed;
#endif
#if defined(WIN) && defined(HAVE_NVAPI)
- NvU32 speed = 0;
- hc_NvAPI_GPU_GetTachReading (data.hm_device[device_id].adapter_index.nv, &speed);
+ NV_GPU_COOLER_SETTINGS pCoolerSettings;
- return speed;
+ pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
+
+ hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, data.hm_device[device_id].adapter_index.nv, 0, &pCoolerSettings);
+
+ return pCoolerSettings.Cooler[0].CurrentLevel;
#endif
}
#endif // HAVE_NVML || HAVE_NVAPI
#ifdef HAVE_ADL
if (data.devices_param[device_id].vendor_id == VENDOR_ID_AMD)
{
- if (data.adl)
+ if (data.hm_amd)
{
ADLPMActivity PMActivity;
PMActivity.iSize = sizeof (ADLPMActivity);
- if (hc_ADL_Overdrive_CurrentActivity_Get (data.adl, data.hm_device[device_id].adapter_index.amd, &PMActivity) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive_CurrentActivity_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &PMActivity) != ADL_OK) return -1;
return PMActivity.iActivityPercent;
}
#if defined(LINUX) && defined(HAVE_NVML)
nvmlUtilization_t utilization;
- hc_NVML_nvmlDeviceGetUtilizationRates (data.hm_dll_nv, data.hm_device[device_id].adapter_index.nv, &utilization);
+ hm_NVML_nvmlDeviceGetUtilizationRates (data.hm_nv, data.hm_device[device_id].adapter_index.nv, &utilization);
return utilization.gpu;
#endif
pDynamicPstatesInfoEx.version = NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER;
- if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data.hm_device[device_id].adapter_index.nv, &pDynamicPstatesInfoEx) != NVAPI_OK) return -1;
+ if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data.hm_nv, data.hm_device[device_id].adapter_index.nv, &pDynamicPstatesInfoEx) != NVAPI_OK) return -1;
return pDynamicPstatesInfoEx.utilization[0].percentage;
#endif
{
if (data.hm_device[device_id].fan_supported == 1)
{
- if (data.adl)
+ if (data.hm_amd)
{
if (data.hm_device[device_id].od_version == 5)
{
lpFanSpeedValue.iFlags = ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED;
lpFanSpeedValue.iFanSpeed = fanspeed;
- if (hc_ADL_Overdrive5_FanSpeed_Set (data.adl, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive5_FanSpeed_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 0, &lpFanSpeedValue) != ADL_OK) return -1;
return 0;
}
fan_speed_value.iSpeedType = ADL_OD6_FANSPEED_TYPE_PERCENT;
fan_speed_value.iFanSpeed = fanspeed;
- if (hc_ADL_Overdrive6_FanSpeed_Set (data.adl, data.hm_device[device_id].adapter_index.amd, &fan_speed_value) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive6_FanSpeed_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &fan_speed_value) != ADL_OK) return -1;
return 0;
}
return session_dir;
}
+uint count_lines (FILE *fd)
+{
+ uint cnt = 0;
+
+ char *buf = (char *) mymalloc (HCBUFSIZ + 1);
+
+ char prev = '\n';
+
+ while (!feof (fd))
+ {
+ size_t nread = fread (buf, sizeof (char), HCBUFSIZ, fd);
+
+ if (nread < 1) continue;
+
+ size_t i;
+
+ for (i = 0; i < nread; i++)
+ {
+ if (prev == '\n') cnt++;
+
+ prev = buf[i];
+ }
+ }
+
+ myfree (buf);
+
+ return cnt;
+}
+
void truecrypt_crc32 (const char *filename, u8 keytab[64])
{
uint crc = ~0;
myfree (buf);
}
+#ifdef OSX
+int pthread_setaffinity_np (pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
+{
+ int core;
+
+ for (core = 0; core < (8 * (int)cpu_size); core++)
+ if (CPU_ISSET(core, cpu_set)) break;
+
+ thread_affinity_policy_data_t policy = { core };
+
+ const int rc = thread_policy_set (pthread_mach_thread_np (thread), THREAD_AFFINITY_POLICY, (thread_policy_t) &policy, 1);
+
+ if (data.quiet == 0)
+ {
+ if (rc != KERN_SUCCESS)
+ {
+ log_error ("ERROR: %s : %d", "thread_policy_set()", rc);
+ }
+ }
+
+ return rc;
+}
+#endif
+
void set_cpu_affinity (char *cpu_affinity)
{
#ifdef WIN
DWORD_PTR aff_mask = 0;
- #elif LINUX
+ #elif _POSIX
cpu_set_t cpuset;
CPU_ZERO (&cpuset);
#endif
{
#ifdef WIN
aff_mask = 0;
- #elif LINUX
+ #elif _POSIX
CPU_ZERO (&cpuset);
#endif
#ifdef WIN
aff_mask |= 1 << (cpu_id - 1);
- #elif LINUX
+ #elif _POSIX
CPU_SET ((cpu_id - 1), &cpuset);
#endif
#ifdef WIN
SetProcessAffinityMask (GetCurrentProcess (), aff_mask);
SetThreadAffinityMask (GetCurrentThread (), aff_mask);
- #elif LINUX
+ #elif _POSIX
pthread_t thread = pthread_self ();
pthread_setaffinity_np (thread, sizeof (cpu_set_t), &cpuset);
#endif
return NULL;
}
+int sort_by_u32 (const void *v1, const void *v2)
+{
+ const u32 *s1 = (const u32 *) v1;
+ const u32 *s2 = (const u32 *) v2;
+
+ return *s1 - *s2;
+}
+
int sort_by_salt (const void *v1, const void *v2)
{
const salt_t *s1 = (const salt_t *) v1;
uint n;
- n = 12;
+ n = 16;
while (n--)
{
const salt_t *s1 = h1->salt;
const salt_t *s2 = h2->salt;
- uint n = 12;
+ uint n = 16;
while (n--)
{
const salt_t *s2 = h2->salt;
// testphase: this should work
- uint n = 12;
+ uint n = 16;
while (n--)
{
const salt_t *s1 = h1->salt;
const salt_t *s2 = h2->salt;
- // 12 - 2 (since last 2 uints contain the digest)
- uint n = 10;
+ // 16 - 2 (since last 2 uints contain the digest)
+ uint n = 14;
while (n--)
{
return (0);
}
+int sort_by_tuning_db_alias (const void *v1, const void *v2)
+{
+ const tuning_db_alias_t *t1 = (const tuning_db_alias_t *) v1;
+ const tuning_db_alias_t *t2 = (const tuning_db_alias_t *) v2;
+
+ const int res1 = strcmp (t1->device_name, t2->device_name);
+
+ if (res1 != 0) return (res1);
+
+ return 0;
+}
+
+int sort_by_tuning_db_entry (const void *v1, const void *v2)
+{
+ const tuning_db_entry_t *t1 = (const tuning_db_entry_t *) v1;
+ const tuning_db_entry_t *t2 = (const tuning_db_entry_t *) v2;
+
+ const int res1 = strcmp (t1->device_name, t2->device_name);
+
+ if (res1 != 0) return (res1);
+
+ const int res2 = t1->attack_mode
+ - t2->attack_mode;
+
+ if (res2 != 0) return (res2);
+
+ const int res3 = t1->hash_type
+ - t2->hash_type;
+
+ if (res3 != 0) return (res3);
+
+ return 0;
+}
+
void format_debug (char *debug_file, uint debug_mode, unsigned char *orig_plain_ptr, uint orig_plain_len, unsigned char *mod_plain_ptr, uint mod_plain_len, char *rule_buf, int rule_len)
{
uint outfile_autohex = data.outfile_autohex;
line_len++;
- if (line_len == BUFSIZ) line_len--;
+ if (line_len == HCBUFSIZ) line_len--;
if (c == '\n') break;
}
case OPTI_TYPE_SINGLE_SALT: return ((char *) OPTI_STR_SINGLE_SALT); break;
case OPTI_TYPE_BRUTE_FORCE: return ((char *) OPTI_STR_BRUTE_FORCE); break;
case OPTI_TYPE_RAW_HASH: return ((char *) OPTI_STR_RAW_HASH); break;
+ case OPTI_TYPE_USES_BITS_8: return ((char *) OPTI_STR_USES_BITS_8); break;
+ case OPTI_TYPE_USES_BITS_16: return ((char *) OPTI_STR_USES_BITS_16); break;
+ case OPTI_TYPE_USES_BITS_32: return ((char *) OPTI_STR_USES_BITS_32); break;
+ case OPTI_TYPE_USES_BITS_64: return ((char *) OPTI_STR_USES_BITS_64); break;
}
return (NULL);
case 121: return ((char *) HT_00121); break;
case 122: return ((char *) HT_00122); break;
case 124: return ((char *) HT_00124); break;
+ case 125: return ((char *) HT_00125); break;
case 130: return ((char *) HT_00130); break;
case 131: return ((char *) HT_00131); break;
case 132: return ((char *) HT_00132); break;
case 12800: return ((char *) HT_12800); break;
case 12900: return ((char *) HT_12900); break;
case 13000: return ((char *) HT_13000); break;
+ case 13100: return ((char *) HT_13100); break;
+ case 13200: return ((char *) HT_13200); break;
+ case 13300: return ((char *) HT_13300); break;
+ case 13400: return ((char *) HT_13400); break;
+ case 13500: return ((char *) HT_13500); break;
}
return ((char *) "Unknown");
case STATUS_QUIT: return ((char *) ST_0007); break;
case STATUS_BYPASS: return ((char *) ST_0008); break;
case STATUS_STOP_AT_CHECKPOINT: return ((char *) ST_0009); break;
+ case STATUS_AUTOTUNE: return ((char *) ST_0010); break;
}
return ((char *) "Unknown");
}
-void ascii_digest (char out_buf[4096], uint salt_pos, uint digest_pos)
+void ascii_digest (char *out_buf, uint salt_pos, uint digest_pos)
{
uint hash_type = data.hash_type;
uint hash_mode = data.hash_mode;
}
else if (hash_mode == 23)
{
- // do not show the \nskyper\n part in output
+ // do not show the skyper part in output
char *salt_buf_ptr = (char *) salt.salt_buf;
snprintf (out_buf, len-1, "{SSHA}%s", ptr_plain);
}
- else if (hash_mode == 122)
+ else if ((hash_mode == 122) || (hash_mode == 125))
{
snprintf (out_buf, len-1, "%s%08x%08x%08x%08x%08x",
(char *) salt.salt_buf,
wpa_t *wpa = &wpas[salt_pos];
- uint pke[25] = { 0 };
-
- char *pke_ptr = (char *) pke;
-
- for (uint i = 0; i < 25; i++)
- {
- pke[i] = byte_swap_32 (wpa->pke[i]);
- }
-
- unsigned char mac1[6] = { 0 };
- unsigned char mac2[6] = { 0 };
-
- memcpy (mac1, pke_ptr + 23, 6);
- memcpy (mac2, pke_ptr + 29, 6);
-
snprintf (out_buf, len-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
(char *) salt.salt_buf,
- mac1[0],
- mac1[1],
- mac1[2],
- mac1[3],
- mac1[4],
- mac1[5],
- mac2[0],
- mac2[1],
- mac2[2],
- mac2[3],
- mac2[4],
- mac2[5]);
+ wpa->orig_mac1[0],
+ wpa->orig_mac1[1],
+ wpa->orig_mac1[2],
+ wpa->orig_mac1[3],
+ wpa->orig_mac1[4],
+ wpa->orig_mac1[5],
+ wpa->orig_mac2[0],
+ wpa->orig_mac2[1],
+ wpa->orig_mac2[2],
+ wpa->orig_mac2[3],
+ wpa->orig_mac2[4],
+ wpa->orig_mac2[5]);
}
else if (hash_mode == 4400)
{
{
char digest_buf_c[34] = { 0 };
+ digest_buf[0] = byte_swap_32 (digest_buf[0]);
+ digest_buf[1] = byte_swap_32 (digest_buf[1]);
+ digest_buf[2] = byte_swap_32 (digest_buf[2]);
+ digest_buf[3] = byte_swap_32 (digest_buf[3]);
+ digest_buf[4] = byte_swap_32 (digest_buf[4]);
+
base32_encode (int_to_itoa32, (const u8 *) digest_buf, 20, (u8 *) digest_buf_c);
digest_buf_c[32] = 0;
byte_swap_32 (digest_buf[1])
);
}
+ else if (hash_mode == 13100)
+ {
+ krb5tgs_t *krb5tgss = (krb5tgs_t *) data.esalts_buf;
+
+ krb5tgs_t *krb5tgs = &krb5tgss[salt_pos];
+
+ u8 *ptr_checksum = (u8 *) krb5tgs->checksum;
+ u8 *ptr_edata2 = (u8 *) krb5tgs->edata2;
+
+ char data[2560 * 4 * 2] = { 0 };
+
+ char *ptr_data = data;
+
+ for (uint i = 0; i < 16; i++, ptr_data += 2)
+ sprintf (ptr_data, "%02x", ptr_checksum[i]);
+
+ /* skip '$' */
+ ptr_data++;
+
+ for (uint i = 0; i < krb5tgs->edata2_len; i++, ptr_data += 2)
+ sprintf (ptr_data, "%02x", ptr_edata2[i]);
+
+ snprintf (out_buf, len-1, "%s$%s$%s$%s",
+ SIGNATURE_KRB5TGS,
+ (char *) krb5tgs->account_info,
+ data,
+ data + 33);
+ }
+ else if (hash_mode == 13200)
+ {
+ snprintf (out_buf, len-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
+ SIGNATURE_AXCRYPT,
+ salt.salt_iter,
+ salt.salt_buf[0],
+ salt.salt_buf[1],
+ salt.salt_buf[2],
+ salt.salt_buf[3],
+ salt.salt_buf[4],
+ salt.salt_buf[5],
+ salt.salt_buf[6],
+ salt.salt_buf[7],
+ salt.salt_buf[8],
+ salt.salt_buf[9]);
+ }
+ else if (hash_mode == 13300)
+ {
+ snprintf (out_buf, len-1, "%s$%08x%08x%08x%08x",
+ SIGNATURE_AXCRYPT_SHA1,
+ digest_buf[0],
+ digest_buf[1],
+ digest_buf[2],
+ digest_buf[3]);
+ }
+ else if (hash_mode == 13400)
+ {
+ keepass_t *keepasss = (keepass_t *) data.esalts_buf;
+
+ keepass_t *keepass = &keepasss[salt_pos];
+
+ u32 version = (u32) keepass->version;
+ u32 rounds = salt.salt_iter;
+ u32 algorithm = (u32) keepass->algorithm;
+ u32 keyfile_len = (u32) keepass->keyfile_len;
+
+ u32 *ptr_final_random_seed = (u32 *) keepass->final_random_seed ;
+ u32 *ptr_transf_random_seed = (u32 *) keepass->transf_random_seed ;
+ u32 *ptr_enc_iv = (u32 *) keepass->enc_iv ;
+ u32 *ptr_contents_hash = (u32 *) keepass->contents_hash ;
+ u32 *ptr_keyfile = (u32 *) keepass->keyfile ;
+
+ /* specific to version 1 */
+ u32 contents_len;
+ u32 *ptr_contents;
+
+ /* specific to version 2 */
+ u32 expected_bytes_len;
+ u32 *ptr_expected_bytes;
+
+ u32 final_random_seed_len;
+ u32 transf_random_seed_len;
+ u32 enc_iv_len;
+ u32 contents_hash_len;
+
+ transf_random_seed_len = 8;
+ enc_iv_len = 4;
+ contents_hash_len = 8;
+ final_random_seed_len = 8;
+
+ if (version == 1)
+ final_random_seed_len = 4;
+
+ snprintf (out_buf, len-1, "%s*%d*%d*%d",
+ SIGNATURE_KEEPASS,
+ version,
+ rounds,
+ algorithm);
+
+ char *ptr_data = out_buf;
+
+ ptr_data += strlen(out_buf);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < final_random_seed_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_final_random_seed[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < transf_random_seed_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_transf_random_seed[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < enc_iv_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_enc_iv[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ if (version == 1)
+ {
+ contents_len = (u32) keepass->contents_len;
+ ptr_contents = (u32 *) keepass->contents;
+
+ for (uint i = 0; i < contents_hash_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents_hash[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ /* inline flag */
+ *ptr_data = '1';
+ ptr_data++;
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ char ptr_contents_len[10] = { 0 };
+
+ sprintf ((char*) ptr_contents_len, "%d", contents_len);
+
+ sprintf (ptr_data, "%d", contents_len);
+
+ ptr_data += strlen(ptr_contents_len);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < contents_len / 4; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents[i]);
+ }
+ else if (version == 2)
+ {
+ expected_bytes_len = 8;
+ ptr_expected_bytes = (u32 *) keepass->expected_bytes ;
+
+ for (uint i = 0; i < expected_bytes_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_expected_bytes[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < contents_hash_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents_hash[i]);
+ }
+ if (keyfile_len)
+ {
+ *ptr_data = '*';
+ ptr_data++;
+
+ /* inline flag */
+ *ptr_data = '1';
+ ptr_data++;
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ sprintf (ptr_data, "%d", keyfile_len);
+
+ ptr_data += 2;
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < 8; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_keyfile[i]);
+ }
+ }
+ else if (hash_mode == 13500)
+ {
+ pstoken_t *pstokens = (pstoken_t *) data.esalts_buf;
+ pstoken_t *pstoken = &pstokens[salt_pos];
+
+ uint mysalt = pstoken->salt_len > 512 ? 512 : pstoken->salt_len;
+
+ char pstoken_tmp[1024 + 1];
+ u8 *salt_buf_ptr = (u8 *) pstoken->salt_buf;
+
+ memset(pstoken_tmp, 0, sizeof (pstoken_tmp));
+
+ for (uint i = 0; i < mysalt; i++)
+ {
+ snprintf(&pstoken_tmp[i*2], 2, "%02x", salt_buf_ptr[i]);
+ }
+
+ snprintf (out_buf, len-1, "%08x%08x%08x%08x%08x:%s",
+ digest_buf[0],
+ digest_buf[1],
+ digest_buf[2],
+ digest_buf[3],
+ digest_buf[4],
+ pstoken_tmp);
+ }
else
{
if (hash_type == HASH_TYPE_MD4)
memcpy (hccap->eapol, wpa->eapol, wpa->eapol_size);
}
- uint pke_tmp[25] = { 0 };
-
- for (int i = 5; i < 25; i++)
- {
- pke_tmp[i] = byte_swap_32 (wpa->pke[i]);
- }
-
- char *pke_ptr = (char *) pke_tmp;
-
- memcpy (hccap->mac1, pke_ptr + 23, 6);
- memcpy (hccap->mac2, pke_ptr + 29, 6);
- memcpy (hccap->nonce1, pke_ptr + 67, 32);
- memcpy (hccap->nonce2, pke_ptr + 35, 32);
+ memcpy (hccap->mac1, wpa->orig_mac1, 6);
+ memcpy (hccap->mac2, wpa->orig_mac2, 6);
+ memcpy (hccap->nonce1, wpa->orig_nonce1, 32);
+ memcpy (hccap->nonce2, wpa->orig_nonce2, 32);
char *digests_buf_ptr = (char *) data.digests_buf;
{
if (data.devices_status == STATUS_PAUSED)
{
- float ms_paused;
+ double ms_paused;
hc_timer_get (data.timer_paused, ms_paused);
if (rd->pid)
{
- char pidbin[BUFSIZ] = { 0 };
+ char *pidbin = (char *) mymalloc (HCBUFSIZ);
int pidbin_len = -1;
#ifdef _POSIX
- snprintf (pidbin, sizeof (pidbin) - 1, "/proc/%d/cmdline", rd->pid);
+ snprintf (pidbin, HCBUFSIZ - 1, "/proc/%d/cmdline", rd->pid);
FILE *fd = fopen (pidbin, "rb");
if (fd)
{
- pidbin_len = fread (pidbin, 1, BUFSIZ, fd);
+ pidbin_len = fread (pidbin, 1, HCBUFSIZ, fd);
pidbin[pidbin_len] = 0;
#elif _WIN
HANDLE hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, rd->pid);
- char pidbin2[BUFSIZ] = { 0 };
+ char *pidbin2 = (char *) mymalloc (HCBUFSIZ);
int pidbin2_len = -1;
- pidbin_len = GetModuleFileName (NULL, pidbin, BUFSIZ);
- pidbin2_len = GetModuleFileNameEx (hProcess, NULL, pidbin2, BUFSIZ);
+ pidbin_len = GetModuleFileName (NULL, pidbin, HCBUFSIZ);
+ pidbin2_len = GetModuleFileNameEx (hProcess, NULL, pidbin2, HCBUFSIZ);
pidbin[pidbin_len] = 0;
pidbin2[pidbin2_len] = 0;
exit (-1);
}
}
+
+ myfree (pidbin2);
+
#endif
+
+ myfree (pidbin);
}
if (rd->version_bin < RESTORE_MIN)
rd->argv = (char **) mycalloc (rd->argc, sizeof (char *));
+ char *buf = (char *) mymalloc (HCBUFSIZ);
+
for (uint i = 0; i < rd->argc; i++)
{
- char buf[BUFSIZ] = { 0 };
-
- if (fgets (buf, BUFSIZ - 1, fp) == NULL)
+ if (fgets (buf, HCBUFSIZ - 1, fp) == NULL)
{
log_error ("ERROR: cannot read %s", eff_restore_file);
rd->argv[i] = mystrdup (buf);
}
- fclose (fp);
-
- char new_cwd[1024] = { 0 };
-
- char *nwd = getcwd (new_cwd, sizeof (new_cwd));
-
- if (nwd == NULL)
- {
- log_error ("Restore file is corrupted");
- }
-
- if (strncmp (new_cwd, rd->cwd, sizeof (new_cwd)) != 0)
- {
- if (getcwd (rd->cwd, sizeof (rd->cwd)) == NULL)
- {
- log_error ("ERROR: could not determine current user path: %s", strerror (errno));
+ myfree (buf);
- exit (-1);
- }
+ fclose (fp);
- log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd);
- }
+ log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd->cwd);
if (chdir (rd->cwd))
{
- log_error ("ERROR: cannot chdir to %s: %s", rd->cwd, strerror (errno));
+ log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
+ " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
+ " https://github.com/philsmd/analyze_hc_restore\n"
+ " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd->cwd);
exit (-1);
}
}
/**
- * adjustments
+ * tuning db
*/
-uint set_kernel_accel (uint hash_mode)
+void tuning_db_destroy (tuning_db_t *tuning_db)
{
- switch (hash_mode)
+ int i;
+
+ for (i = 0; i < tuning_db->alias_cnt; i++)
{
- case 0: return GET_ACCEL (0);
- case 10: return GET_ACCEL (10);
- case 11: return GET_ACCEL (11);
- case 12: return GET_ACCEL (12);
- case 20: return GET_ACCEL (20);
- case 21: return GET_ACCEL (21);
- case 22: return GET_ACCEL (22);
- case 23: return GET_ACCEL (23);
- case 30: return GET_ACCEL (30);
- case 40: return GET_ACCEL (40);
- case 50: return GET_ACCEL (50);
- case 60: return GET_ACCEL (60);
- case 100: return GET_ACCEL (100);
- case 101: return GET_ACCEL (101);
- case 110: return GET_ACCEL (110);
- case 111: return GET_ACCEL (111);
- case 112: return GET_ACCEL (112);
- case 120: return GET_ACCEL (120);
- case 121: return GET_ACCEL (121);
- case 122: return GET_ACCEL (122);
- case 124: return GET_ACCEL (124);
- case 130: return GET_ACCEL (130);
- case 131: return GET_ACCEL (131);
- case 132: return GET_ACCEL (132);
- case 133: return GET_ACCEL (133);
- case 140: return GET_ACCEL (140);
- case 141: return GET_ACCEL (141);
- case 150: return GET_ACCEL (150);
- case 160: return GET_ACCEL (160);
- case 190: return GET_ACCEL (190);
- case 200: return GET_ACCEL (200);
- case 300: return GET_ACCEL (300);
- case 400: return GET_ACCEL (400);
- case 500: return GET_ACCEL (500);
- case 501: return GET_ACCEL (501);
- case 900: return GET_ACCEL (900);
- case 910: return GET_ACCEL (910);
- case 1000: return GET_ACCEL (1000);
- case 1100: return GET_ACCEL (1100);
- case 1400: return GET_ACCEL (1400);
- case 1410: return GET_ACCEL (1410);
- case 1420: return GET_ACCEL (1420);
- case 1421: return GET_ACCEL (1421);
- case 1430: return GET_ACCEL (1430);
- case 1440: return GET_ACCEL (1440);
- case 1441: return GET_ACCEL (1441);
- case 1450: return GET_ACCEL (1450);
- case 1460: return GET_ACCEL (1460);
- case 1500: return GET_ACCEL (1500);
- case 1600: return GET_ACCEL (1600);
- case 1700: return GET_ACCEL (1700);
- case 1710: return GET_ACCEL (1710);
- case 1711: return GET_ACCEL (1711);
- case 1720: return GET_ACCEL (1720);
- case 1722: return GET_ACCEL (1722);
- case 1730: return GET_ACCEL (1730);
- case 1731: return GET_ACCEL (1731);
- case 1740: return GET_ACCEL (1740);
- case 1750: return GET_ACCEL (1750);
- case 1760: return GET_ACCEL (1760);
- case 1800: return GET_ACCEL (1800);
- case 2100: return GET_ACCEL (2100);
- case 2400: return GET_ACCEL (2400);
- case 2410: return GET_ACCEL (2410);
- case 2500: return GET_ACCEL (2500);
- case 2600: return GET_ACCEL (2600);
- case 2611: return GET_ACCEL (2611);
- case 2612: return GET_ACCEL (2612);
- case 2711: return GET_ACCEL (2711);
- case 2811: return GET_ACCEL (2811);
- case 3000: return GET_ACCEL (3000);
- case 3100: return GET_ACCEL (3100);
- case 3200: return GET_ACCEL (3200);
- case 3710: return GET_ACCEL (3710);
- case 3711: return GET_ACCEL (3711);
- case 3800: return GET_ACCEL (3800);
- case 4300: return GET_ACCEL (4300);
- case 4400: return GET_ACCEL (4400);
- case 4500: return GET_ACCEL (4500);
- case 4700: return GET_ACCEL (4700);
- case 4800: return GET_ACCEL (4800);
- case 4900: return GET_ACCEL (4900);
- case 5000: return GET_ACCEL (5000);
- case 5100: return GET_ACCEL (5100);
- case 5200: return GET_ACCEL (5200);
- case 5300: return GET_ACCEL (5300);
- case 5400: return GET_ACCEL (5400);
- case 5500: return GET_ACCEL (5500);
- case 5600: return GET_ACCEL (5600);
- case 5700: return GET_ACCEL (5700);
- case 5800: return GET_ACCEL (5800);
- case 6000: return GET_ACCEL (6000);
- case 6100: return GET_ACCEL (6100);
- case 6211: return GET_ACCEL (6211);
- case 6212: return GET_ACCEL (6212);
- case 6213: return GET_ACCEL (6213);
- case 6221: return GET_ACCEL (6221);
- case 6222: return GET_ACCEL (6222);
- case 6223: return GET_ACCEL (6223);
- case 6231: return GET_ACCEL (6231);
- case 6232: return GET_ACCEL (6232);
- case 6233: return GET_ACCEL (6233);
- case 6241: return GET_ACCEL (6241);
- case 6242: return GET_ACCEL (6242);
- case 6243: return GET_ACCEL (6243);
- case 6300: return GET_ACCEL (6300);
- case 6400: return GET_ACCEL (6400);
- case 6500: return GET_ACCEL (6500);
- case 6600: return GET_ACCEL (6600);
- case 6700: return GET_ACCEL (6700);
- case 6800: return GET_ACCEL (6800);
- case 6900: return GET_ACCEL (6900);
- case 7100: return GET_ACCEL (7100);
- case 7200: return GET_ACCEL (7200);
- case 7300: return GET_ACCEL (7300);
- case 7400: return GET_ACCEL (7400);
- case 7500: return GET_ACCEL (7500);
- case 7600: return GET_ACCEL (7600);
- case 7700: return GET_ACCEL (7700);
- case 7800: return GET_ACCEL (7800);
- case 7900: return GET_ACCEL (7900);
- case 8000: return GET_ACCEL (8000);
- case 8100: return GET_ACCEL (8100);
- case 8200: return GET_ACCEL (8200);
- case 8300: return GET_ACCEL (8300);
- case 8400: return GET_ACCEL (8400);
- case 8500: return GET_ACCEL (8500);
- case 8600: return GET_ACCEL (8600);
- case 8700: return GET_ACCEL (8700);
- case 8800: return GET_ACCEL (8800);
- case 8900: return GET_ACCEL (8900);
- case 9000: return GET_ACCEL (9000);
- case 9100: return GET_ACCEL (9100);
- case 9200: return GET_ACCEL (9200);
- case 9300: return GET_ACCEL (9300);
- case 9400: return GET_ACCEL (9400);
- case 9500: return GET_ACCEL (9500);
- case 9600: return GET_ACCEL (9600);
- case 9700: return GET_ACCEL (9700);
- case 9710: return GET_ACCEL (9710);
- case 9720: return GET_ACCEL (9720);
- case 9800: return GET_ACCEL (9800);
- case 9810: return GET_ACCEL (9810);
- case 9820: return GET_ACCEL (9820);
- case 9900: return GET_ACCEL (9900);
- case 10000: return GET_ACCEL (10000);
- case 10100: return GET_ACCEL (10100);
- case 10200: return GET_ACCEL (10200);
- case 10300: return GET_ACCEL (10300);
- case 10400: return GET_ACCEL (10400);
- case 10410: return GET_ACCEL (10410);
- case 10420: return GET_ACCEL (10420);
- case 10500: return GET_ACCEL (10500);
- case 10600: return GET_ACCEL (10600);
- case 10700: return GET_ACCEL (10700);
- case 10800: return GET_ACCEL (10800);
- case 10900: return GET_ACCEL (10900);
- case 11000: return GET_ACCEL (11000);
- case 11100: return GET_ACCEL (11100);
- case 11200: return GET_ACCEL (11200);
- case 11300: return GET_ACCEL (11300);
- case 11400: return GET_ACCEL (11400);
- case 11500: return GET_ACCEL (11500);
- case 11600: return GET_ACCEL (11600);
- case 11700: return GET_ACCEL (11700);
- case 11800: return GET_ACCEL (11800);
- case 11900: return GET_ACCEL (11900);
- case 12000: return GET_ACCEL (12000);
- case 12100: return GET_ACCEL (12100);
- case 12200: return GET_ACCEL (12200);
- case 12300: return GET_ACCEL (12300);
- case 12400: return GET_ACCEL (12400);
- case 12500: return GET_ACCEL (12500);
- case 12600: return GET_ACCEL (12600);
- case 12700: return GET_ACCEL (12700);
- case 12800: return GET_ACCEL (12800);
- case 12900: return GET_ACCEL (12900);
- case 13000: return GET_ACCEL (13000);
- }
+ tuning_db_alias_t *alias = &tuning_db->alias_buf[i];
- return 0;
-}
+ myfree (alias->device_name);
+ myfree (alias->alias_name);
+ }
-uint set_kernel_loops (uint hash_mode)
-{
- switch (hash_mode)
+ for (i = 0; i < tuning_db->entry_cnt; i++)
{
- case 0: return GET_LOOPS (0);
- case 10: return GET_LOOPS (10);
- case 11: return GET_LOOPS (11);
- case 12: return GET_LOOPS (12);
- case 20: return GET_LOOPS (20);
- case 21: return GET_LOOPS (21);
- case 22: return GET_LOOPS (22);
- case 23: return GET_LOOPS (23);
- case 30: return GET_LOOPS (30);
- case 40: return GET_LOOPS (40);
- case 50: return GET_LOOPS (50);
- case 60: return GET_LOOPS (60);
- case 100: return GET_LOOPS (100);
- case 101: return GET_LOOPS (101);
- case 110: return GET_LOOPS (110);
- case 111: return GET_LOOPS (111);
- case 112: return GET_LOOPS (112);
- case 120: return GET_LOOPS (120);
- case 121: return GET_LOOPS (121);
- case 122: return GET_LOOPS (122);
- case 124: return GET_LOOPS (124);
- case 130: return GET_LOOPS (130);
- case 131: return GET_LOOPS (131);
- case 132: return GET_LOOPS (132);
- case 133: return GET_LOOPS (133);
- case 140: return GET_LOOPS (140);
- case 141: return GET_LOOPS (141);
- case 150: return GET_LOOPS (150);
- case 160: return GET_LOOPS (160);
- case 190: return GET_LOOPS (190);
- case 200: return GET_LOOPS (200);
- case 300: return GET_LOOPS (300);
- case 400: return GET_LOOPS (400);
- case 500: return GET_LOOPS (500);
- case 501: return GET_LOOPS (501);
- case 900: return GET_LOOPS (900);
- case 910: return GET_LOOPS (910);
- case 1000: return GET_LOOPS (1000);
- case 1100: return GET_LOOPS (1100);
- case 1400: return GET_LOOPS (1400);
- case 1410: return GET_LOOPS (1410);
- case 1420: return GET_LOOPS (1420);
- case 1421: return GET_LOOPS (1421);
- case 1430: return GET_LOOPS (1430);
- case 1440: return GET_LOOPS (1440);
- case 1441: return GET_LOOPS (1441);
- case 1450: return GET_LOOPS (1450);
- case 1460: return GET_LOOPS (1460);
- case 1500: return GET_LOOPS (1500);
- case 1600: return GET_LOOPS (1600);
- case 1700: return GET_LOOPS (1700);
- case 1710: return GET_LOOPS (1710);
- case 1711: return GET_LOOPS (1711);
- case 1720: return GET_LOOPS (1720);
- case 1722: return GET_LOOPS (1722);
- case 1730: return GET_LOOPS (1730);
- case 1731: return GET_LOOPS (1731);
- case 1740: return GET_LOOPS (1740);
- case 1750: return GET_LOOPS (1750);
- case 1760: return GET_LOOPS (1760);
- case 1800: return GET_LOOPS (1800);
- case 2100: return GET_LOOPS (2100);
- case 2400: return GET_LOOPS (2400);
- case 2410: return GET_LOOPS (2410);
- case 2500: return GET_LOOPS (2500);
- case 2600: return GET_LOOPS (2600);
- case 2611: return GET_LOOPS (2611);
- case 2612: return GET_LOOPS (2612);
- case 2711: return GET_LOOPS (2711);
- case 2811: return GET_LOOPS (2811);
- case 3000: return GET_LOOPS (3000);
- case 3100: return GET_LOOPS (3100);
- case 3200: return GET_LOOPS (3200);
- case 3710: return GET_LOOPS (3710);
- case 3711: return GET_LOOPS (3711);
- case 3800: return GET_LOOPS (3800);
- case 4300: return GET_LOOPS (4300);
- case 4400: return GET_LOOPS (4400);
- case 4500: return GET_LOOPS (4500);
- case 4700: return GET_LOOPS (4700);
- case 4800: return GET_LOOPS (4800);
- case 4900: return GET_LOOPS (4900);
- case 5000: return GET_LOOPS (5000);
- case 5100: return GET_LOOPS (5100);
- case 5200: return GET_LOOPS (5200);
- case 5300: return GET_LOOPS (5300);
- case 5400: return GET_LOOPS (5400);
- case 5500: return GET_LOOPS (5500);
- case 5600: return GET_LOOPS (5600);
- case 5700: return GET_LOOPS (5700);
- case 5800: return GET_LOOPS (5800);
- case 6000: return GET_LOOPS (6000);
- case 6100: return GET_LOOPS (6100);
- case 6211: return GET_LOOPS (6211);
- case 6212: return GET_LOOPS (6212);
- case 6213: return GET_LOOPS (6213);
- case 6221: return GET_LOOPS (6221);
- case 6222: return GET_LOOPS (6222);
- case 6223: return GET_LOOPS (6223);
- case 6231: return GET_LOOPS (6231);
- case 6232: return GET_LOOPS (6232);
- case 6233: return GET_LOOPS (6233);
- case 6241: return GET_LOOPS (6241);
- case 6242: return GET_LOOPS (6242);
- case 6243: return GET_LOOPS (6243);
- case 6300: return GET_LOOPS (6300);
- case 6400: return GET_LOOPS (6400);
- case 6500: return GET_LOOPS (6500);
- case 6600: return GET_LOOPS (6600);
- case 6700: return GET_LOOPS (6700);
- case 6800: return GET_LOOPS (6800);
- case 6900: return GET_LOOPS (6900);
- case 7100: return GET_LOOPS (7100);
- case 7200: return GET_LOOPS (7200);
- case 7300: return GET_LOOPS (7300);
- case 7400: return GET_LOOPS (7400);
- case 7500: return GET_LOOPS (7500);
- case 7600: return GET_LOOPS (7600);
- case 7700: return GET_LOOPS (7700);
- case 7800: return GET_LOOPS (7800);
- case 7900: return GET_LOOPS (7900);
- case 8000: return GET_LOOPS (8000);
- case 8100: return GET_LOOPS (8100);
- case 8200: return GET_LOOPS (8200);
- case 8300: return GET_LOOPS (8300);
- case 8400: return GET_LOOPS (8400);
- case 8500: return GET_LOOPS (8500);
- case 8600: return GET_LOOPS (8600);
- case 8700: return GET_LOOPS (8700);
- case 8800: return GET_LOOPS (8800);
- case 8900: return GET_LOOPS (8900);
- case 9000: return GET_LOOPS (9000);
- case 9100: return GET_LOOPS (9100);
- case 9200: return GET_LOOPS (9200);
- case 9300: return GET_LOOPS (9300);
- case 9400: return GET_LOOPS (9400);
- case 9500: return GET_LOOPS (9500);
- case 9600: return GET_LOOPS (9600);
- case 9700: return GET_LOOPS (9700);
- case 9710: return GET_LOOPS (9710);
- case 9720: return GET_LOOPS (9720);
- case 9800: return GET_LOOPS (9800);
- case 9810: return GET_LOOPS (9810);
- case 9820: return GET_LOOPS (9820);
- case 9900: return GET_LOOPS (9900);
- case 10000: return GET_LOOPS (10000);
- case 10100: return GET_LOOPS (10100);
- case 10200: return GET_LOOPS (10200);
- case 10300: return GET_LOOPS (10300);
- case 10400: return GET_LOOPS (10400);
- case 10410: return GET_LOOPS (10410);
- case 10420: return GET_LOOPS (10420);
- case 10500: return GET_LOOPS (10500);
- case 10600: return GET_LOOPS (10600);
- case 10700: return GET_LOOPS (10700);
- case 10800: return GET_LOOPS (10800);
- case 10900: return GET_LOOPS (10900);
- case 11000: return GET_LOOPS (11000);
- case 11100: return GET_LOOPS (11100);
- case 11200: return GET_LOOPS (11200);
- case 11300: return GET_LOOPS (11300);
- case 11400: return GET_LOOPS (11400);
- case 11500: return GET_LOOPS (11500);
- case 11600: return GET_LOOPS (11600);
- case 11700: return GET_LOOPS (11700);
- case 11800: return GET_LOOPS (11800);
- case 11900: return GET_LOOPS (11900);
- case 12000: return GET_LOOPS (12000);
- case 12100: return GET_LOOPS (12100);
- case 12200: return GET_LOOPS (12200);
- case 12300: return GET_LOOPS (12300);
- case 12400: return GET_LOOPS (12400);
- case 12500: return GET_LOOPS (12500);
- case 12600: return GET_LOOPS (12600);
- case 12700: return GET_LOOPS (12700);
- case 12800: return GET_LOOPS (12800);
- case 12900: return GET_LOOPS (12900);
- case 13000: return GET_LOOPS (13000);
+ tuning_db_entry_t *entry = &tuning_db->entry_buf[i];
+
+ myfree (entry->device_name);
}
- return 0;
+ myfree (tuning_db->alias_buf);
+ myfree (tuning_db->entry_buf);
+
+ myfree (tuning_db);
}
-/**
- * parser
- */
+tuning_db_t *tuning_db_alloc (FILE *fp)
+{
+ tuning_db_t *tuning_db = (tuning_db_t *) mymalloc (sizeof (tuning_db_t));
-uint parse_and_store_salt (char *out, char *in, uint salt_len)
+ int num_lines = count_lines (fp);
+
+ // a bit over-allocated
+
+ tuning_db->alias_buf = (tuning_db_alias_t *) mycalloc (num_lines + 1, sizeof (tuning_db_alias_t));
+ tuning_db->alias_cnt = 0;
+
+ tuning_db->entry_buf = (tuning_db_entry_t *) mycalloc (num_lines + 1, sizeof (tuning_db_entry_t));
+ tuning_db->entry_cnt = 0;
+
+ return tuning_db;
+}
+
+tuning_db_t *tuning_db_init (const char *tuning_db_file)
{
- u8 tmp[256] = { 0 };
+ FILE *fp = fopen (tuning_db_file, "rb");
- if (salt_len > sizeof (tmp))
+ if (fp == NULL)
{
- return UINT_MAX;
+ log_error ("%s: %s", tuning_db_file, strerror (errno));
+
+ exit (-1);
}
- memcpy (tmp, in, salt_len);
+ tuning_db_t *tuning_db = tuning_db_alloc (fp);
- if (data.opts_type & OPTS_TYPE_ST_HEX)
- {
- if ((salt_len % 2) == 0)
- {
- u32 new_salt_len = salt_len / 2;
+ rewind (fp);
- for (uint i = 0, j = 0; i < new_salt_len; i += 1, j += 2)
- {
- u8 p0 = tmp[j + 0];
- u8 p1 = tmp[j + 1];
+ int line_num = 0;
- tmp[i] = hex_convert (p1) << 0;
- tmp[i] |= hex_convert (p0) << 4;
+ char *buf = (char *) mymalloc (HCBUFSIZ);
+
+ while (!feof (fp))
+ {
+ char *line_buf = fgets (buf, HCBUFSIZ - 1, fp);
+
+ if (line_buf == NULL) break;
+
+ line_num++;
+
+ const int line_len = in_superchop (line_buf);
+
+ if (line_len == 0) continue;
+
+ if (line_buf[0] == '#') continue;
+
+ // start processing
+
+ char *token_ptr[7] = { NULL };
+
+ int token_cnt = 0;
+
+ char *next = strtok (line_buf, "\t ");
+
+ token_ptr[token_cnt] = next;
+
+ token_cnt++;
+
+ while ((next = strtok (NULL, "\t ")) != NULL)
+ {
+ token_ptr[token_cnt] = next;
+
+ token_cnt++;
+ }
+
+ if (token_cnt == 2)
+ {
+ char *device_name = token_ptr[0];
+ char *alias_name = token_ptr[1];
+
+ tuning_db_alias_t *alias = &tuning_db->alias_buf[tuning_db->alias_cnt];
+
+ alias->device_name = mystrdup (device_name);
+ alias->alias_name = mystrdup (alias_name);
+
+ tuning_db->alias_cnt++;
+ }
+ else if (token_cnt == 6)
+ {
+ if ((token_ptr[1][0] != '0') &&
+ (token_ptr[1][0] != '1') &&
+ (token_ptr[1][0] != '3') &&
+ (token_ptr[1][0] != '*'))
+ {
+ log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr[1][0], line_num);
+
+ continue;
+ }
+
+ if ((token_ptr[3][0] != '1') &&
+ (token_ptr[3][0] != '2') &&
+ (token_ptr[3][0] != '4') &&
+ (token_ptr[3][0] != '8') &&
+ (token_ptr[3][0] != 'N'))
+ {
+ log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr[3][0], line_num);
+
+ continue;
+ }
+
+ char *device_name = token_ptr[0];
+
+ int attack_mode = -1;
+ int hash_type = -1;
+ int vector_width = -1;
+ int kernel_accel = -1;
+ int kernel_loops = -1;
+
+ if (token_ptr[1][0] != '*') attack_mode = atoi (token_ptr[1]);
+ if (token_ptr[2][0] != '*') hash_type = atoi (token_ptr[2]);
+ if (token_ptr[3][0] != 'N') vector_width = atoi (token_ptr[3]);
+
+ if (token_ptr[4][0] != 'A')
+ {
+ kernel_accel = atoi (token_ptr[4]);
+
+ if ((kernel_accel < 1) || (kernel_accel > 1024))
+ {
+ log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel, line_num);
+
+ continue;
+ }
+ }
+ else
+ {
+ kernel_accel = 0;
+ }
+
+ if (token_ptr[5][0] != 'A')
+ {
+ kernel_loops = atoi (token_ptr[5]);
+
+ if ((kernel_loops < 1) || (kernel_loops > 1024))
+ {
+ log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops, line_num);
+
+ continue;
+ }
+ }
+ else
+ {
+ kernel_loops = 0;
+ }
+
+ tuning_db_entry_t *entry = &tuning_db->entry_buf[tuning_db->entry_cnt];
+
+ entry->device_name = mystrdup (device_name);
+ entry->attack_mode = attack_mode;
+ entry->hash_type = hash_type;
+ entry->vector_width = vector_width;
+ entry->kernel_accel = kernel_accel;
+ entry->kernel_loops = kernel_loops;
+
+ tuning_db->entry_cnt++;
+ }
+ else
+ {
+ log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num);
+
+ continue;
+ }
+ }
+
+ myfree (buf);
+
+ fclose (fp);
+
+ // todo: print loaded 'cnt' message
+
+ // sort the database
+
+ qsort (tuning_db->alias_buf, tuning_db->alias_cnt, sizeof (tuning_db_alias_t), sort_by_tuning_db_alias);
+ qsort (tuning_db->entry_buf, tuning_db->entry_cnt, sizeof (tuning_db_entry_t), sort_by_tuning_db_entry);
+
+ return tuning_db;
+}
+
+tuning_db_entry_t *tuning_db_search (tuning_db_t *tuning_db, hc_device_param_t *device_param, int attack_mode, int hash_type)
+{
+ static tuning_db_entry_t s;
+
+ // first we need to convert all spaces in the device_name to underscore
+
+ char *device_name_nospace = strdup (device_param->device_name);
+
+ int device_name_length = strlen (device_name_nospace);
+
+ int i;
+
+ for (i = 0; i < device_name_length; i++)
+ {
+ if (device_name_nospace[i] == ' ') device_name_nospace[i] = '_';
+ }
+
+ // find out if there's an alias configured
+
+ tuning_db_alias_t a;
+
+ a.device_name = device_name_nospace;
+
+ tuning_db_alias_t *alias = bsearch (&a, tuning_db->alias_buf, tuning_db->alias_cnt, sizeof (tuning_db_alias_t), sort_by_tuning_db_alias);
+
+ char *alias_name = (alias == NULL) ? NULL : alias->alias_name;
+
+ // attack-mode 6 and 7 are attack-mode 1 basically
+
+ if (attack_mode == 6) attack_mode = 1;
+ if (attack_mode == 7) attack_mode = 1;
+
+ // bsearch is not ideal but fast enough
+
+ s.device_name = device_name_nospace;
+ s.attack_mode = attack_mode;
+ s.hash_type = hash_type;
+
+ tuning_db_entry_t *entry = NULL;
+
+ // this will produce all 2^3 combinations required
+
+ for (i = 0; i < 8; i++)
+ {
+ s.device_name = (i & 1) ? "*" : device_name_nospace;
+ s.attack_mode = (i & 2) ? -1 : attack_mode;
+ s.hash_type = (i & 4) ? -1 : hash_type;
+
+ entry = bsearch (&s, tuning_db->entry_buf, tuning_db->entry_cnt, sizeof (tuning_db_entry_t), sort_by_tuning_db_entry);
+
+ if (entry != NULL) break;
+
+ // in non-wildcard mode do some additional checks:
+
+ if ((i & 1) == 0)
+ {
+ // in case we have an alias-name
+
+ if (alias_name != NULL)
+ {
+ s.device_name = alias_name;
+
+ entry = bsearch (&s, tuning_db->entry_buf, tuning_db->entry_cnt, sizeof (tuning_db_entry_t), sort_by_tuning_db_entry);
+
+ if (entry != NULL) break;
+ }
+
+ // or by device type
+
+ if (device_param->device_type & CL_DEVICE_TYPE_CPU)
+ {
+ s.device_name = "DEVICE_TYPE_CPU";
+ }
+ else if (device_param->device_type & CL_DEVICE_TYPE_GPU)
+ {
+ s.device_name = "DEVICE_TYPE_GPU";
+ }
+ else if (device_param->device_type & CL_DEVICE_TYPE_ACCELERATOR)
+ {
+ s.device_name = "DEVICE_TYPE_ACCELERATOR";
+ }
+
+ entry = bsearch (&s, tuning_db->entry_buf, tuning_db->entry_cnt, sizeof (tuning_db_entry_t), sort_by_tuning_db_entry);
+
+ if (entry != NULL) break;
+ }
+ }
+
+ // free converted device_name
+
+ myfree (device_name_nospace);
+
+ return entry;
+}
+
+/**
+ * parser
+ */
+
+uint parse_and_store_salt (char *out, char *in, uint salt_len)
+{
+ u8 tmp[256] = { 0 };
+
+ if (salt_len > sizeof (tmp))
+ {
+ return UINT_MAX;
+ }
+
+ memcpy (tmp, in, salt_len);
+
+ if (data.opts_type & OPTS_TYPE_ST_HEX)
+ {
+ if ((salt_len % 2) == 0)
+ {
+ u32 new_salt_len = salt_len / 2;
+
+ for (uint i = 0, j = 0; i < new_salt_len; i += 1, j += 2)
+ {
+ u8 p0 = tmp[j + 0];
+ u8 p1 = tmp[j + 1];
+
+ tmp[i] = hex_convert (p1) << 0;
+ tmp[i] |= hex_convert (p0) << 4;
}
salt_len = new_salt_len;
return (PARSER_OK);
}
+int arubaos_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_125) || (input_len > DISPLAY_LEN_MAX_125)) return (PARSER_GLOBAL_LENGTH);
+
+ if ((input_buf[8] != '0') || (input_buf[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ char *hash_pos = input_buf + 10;
+
+ digest[0] = hex_to_u32 ((const u8 *) &hash_pos[ 0]);
+ digest[1] = hex_to_u32 ((const u8 *) &hash_pos[ 8]);
+ digest[2] = hex_to_u32 ((const u8 *) &hash_pos[16]);
+ digest[3] = hex_to_u32 ((const u8 *) &hash_pos[24]);
+ digest[4] = hex_to_u32 ((const u8 *) &hash_pos[32]);
+
+ digest[0] -= SHA1M_A;
+ digest[1] -= SHA1M_B;
+ digest[2] -= SHA1M_C;
+ digest[3] -= SHA1M_D;
+ digest[4] -= SHA1M_E;
+
+ uint salt_len = 10;
+
+ char *salt_buf_ptr = (char *) salt->salt_buf;
+
+ salt_len = parse_and_store_salt (salt_buf_ptr, input_buf, salt_len);
+
+ if (salt_len == UINT_MAX) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
+
+ return (PARSER_OK);
+}
+
int osx1_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_122) || (input_len > DISPLAY_LEN_MAX_122)) return (PARSER_GLOBAL_LENGTH);
salt_len = parse_and_store_salt (salt_buf_ptr, salt_buf, salt_len);
- // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
- if (salt_len > 10) return (PARSER_SALT_LENGTH);
+ // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
+ // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
+
+ if (salt_len > 28) return (PARSER_SALT_LENGTH);
salt->salt_len = salt_len;
uint salt_len = strlen (in.essid);
+ if (salt_len > 36)
+ {
+ log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
+
+ return (PARSER_SALT_LENGTH);
+ }
+
memcpy (salt->salt_buf, in.essid, salt_len);
salt->salt_len = salt_len;
wpa->pke[i] = byte_swap_32 (wpa->pke[i]);
}
+ memcpy (wpa->orig_mac1, in.mac1, 6);
+ memcpy (wpa->orig_mac2, in.mac2, 6);
+ memcpy (wpa->orig_nonce1, in.nonce1, 32);
+ memcpy (wpa->orig_nonce2, in.nonce2, 32);
+
wpa->keyver = in.keyver;
if (wpa->keyver > 255)
}
}
- salt->salt_buf[10] = digest[1];
- salt->salt_buf[11] = digest[2];
+ uint32_t *p0 = (uint32_t *) in.essid;
+ uint32_t c0 = 0;
+ uint32_t c1 = 0;
+
+ for (uint i = 0; i < sizeof (in.essid) / sizeof (uint32_t); i++) c0 ^= *p0++;
+ for (uint i = 0; i < sizeof (wpa->pke) / sizeof (wpa->pke[0]); i++) c1 ^= wpa->pke[i];
+
+ salt->salt_buf[10] = c0;
+ salt->salt_buf[11] = c1;
return (PARSER_OK);
}
int md5crypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
+ if (input_len < DISPLAY_LEN_MIN_500) return (PARSER_GLOBAL_LENGTH);
+
if (memcmp (SIGNATURE_MD5CRYPT, input_buf, 3)) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt->salt_iter = ROUNDS_MD5CRYPT;
}
- if ((input_len < DISPLAY_LEN_MIN_500) || (input_len > (DISPLAY_LEN_MAX_500 + iterations_len))) return (PARSER_GLOBAL_LENGTH);
+ if (input_len > (DISPLAY_LEN_MAX_500 + iterations_len)) return (PARSER_GLOBAL_LENGTH);
char *hash_pos = strchr (salt_pos, '$');
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
return (PARSER_OK);
}
+int sha1axcrypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13300) || (input_len > DISPLAY_LEN_MAX_13300)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_AXCRYPT_SHA1, input_buf, 13)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ input_buf +=14;
+
+ digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]);
+ digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
+ digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]);
+ digest[3] = hex_to_u32 ((const u8 *) &input_buf[24]);
+ digest[4] = 0x00000000;
+
+ return (PARSER_OK);
+}
+
int sha1s_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if (data.opts_type & OPTS_TYPE_ST_HEX)
return (PARSER_OK);
}
+int pstoken_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if (data.opts_type & OPTS_TYPE_ST_HEX)
+ {
+ if ((input_len < DISPLAY_LEN_MIN_13500) || (input_len > DISPLAY_LEN_MAX_13500)) return (PARSER_GLOBAL_LENGTH);
+ }
+ else
+ {
+ if ((input_len < DISPLAY_LEN_MIN_13500) || (input_len > DISPLAY_LEN_MAX_13500)) return (PARSER_GLOBAL_LENGTH);
+ }
+
+ u32 *digest = (u32 *) hash_buf->digest;
+ salt_t *salt = hash_buf->salt;
+ pstoken_t *pstoken = (pstoken_t *) hash_buf->esalt;
+ u8 pstoken_tmp[DISPLAY_LEN_MAX_13500 - 40 - 1];
+
+ memset(pstoken_tmp, 0, DISPLAY_LEN_MAX_13500 - 40 - 1);
+
+ digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]);
+ digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
+ digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]);
+ digest[3] = hex_to_u32 ((const u8 *) &input_buf[24]);
+ digest[4] = hex_to_u32 ((const u8 *) &input_buf[32]);
+
+ if (input_buf[40] != data.separator) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint salt_len = input_len - 40 - 1;
+
+ char *salt_buf = input_buf + 40 + 1;
+
+ if (salt_len == UINT_MAX || salt_len % 2 != 0) return (PARSER_SALT_LENGTH);
+
+ for (uint i = 0; i < salt_len / 2; i++)
+ {
+ pstoken_tmp[i] = hex_to_u8 ((const u8 *) &salt_buf[i * 2]);
+ }
+
+ salt_len /= 2;
+ salt->salt_len = salt_len;
+ pstoken->salt_len = salt_len;
+
+ memcpy(salt->salt_buf, pstoken_tmp, 16);
+ memcpy(pstoken->salt_buf, pstoken_tmp, salt_len);
+
+ return (PARSER_OK);
+}
+
+
int sha1b64_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_101) || (input_len > DISPLAY_LEN_MAX_101)) return (PARSER_GLOBAL_LENGTH);
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 6, input_len - 6, tmp_buf);
+ if (tmp_len < 20) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 20);
- salt->salt_len = tmp_len - 20;
+ int salt_len = tmp_len - 20;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 20, salt->salt_len);
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 9, input_len - 9, tmp_buf);
+ if (tmp_len < 64) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 64);
digest[0] = byte_swap_64 (digest[0]);
digest[6] -= SHA512M_G;
digest[7] -= SHA512M_H;
- salt->salt_len = tmp_len - 64;
+ int salt_len = tmp_len - 64;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 64, salt->salt_len);
u32 *digest = (u32 *) hash_buf->digest;
+ salt_t *salt = hash_buf->salt;
+
u8 tmp_buf[100] = { 0 };
base64_decode (base64_to_int, (const u8 *) input_buf, input_len, tmp_buf);
digest[3] -= SHA1M_D;
digest[4] -= SHA1M_E;
+ salt->salt_buf[0] = 0x80;
+
+ salt->salt_len = 0;
+
return (PARSER_OK);
}
// base64 decode
+ int salt_len_base64 = hash_pos - saltbuf_pos;
+
+ if (salt_len_base64 > 45) return (PARSER_SALT_LENGTH);
+
u8 tmp_buf[33] = { 0 };
- int tmp_len = base64_decode (base64_to_int, (const u8 *) saltbuf_pos, hash_pos - saltbuf_pos, tmp_buf);
+ int tmp_len = base64_decode (base64_to_int, (const u8 *) saltbuf_pos, salt_len_base64, tmp_buf);
char *salt_buf_ptr = (char *) salt->salt_buf;
char *hash_pos = strchr (salt_pos, '$');
- uint salt_len = hash_pos - salt_pos;
-
if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ uint salt_len = hash_pos - salt_pos;
+
hash_pos++;
uint hash_len = input_len - 10 - salt_len - 1;
// base64 decode salt
+ if (salt_len > 133) return (PARSER_SALT_LENGTH);
+
u8 tmp_buf[100] = { 0 };
salt_len = base64_decode (base64_to_int, (const u8 *) salt_pos, salt_len, tmp_buf);
salt->salt_len = salt_len;
- // base64 decode salt
+ // base64 decode hash
+
+ if (hash_len > 133) return (PARSER_HASH_LENGTH);
memset (tmp_buf, 0, sizeof (tmp_buf));
hash_len = base64_decode (base64_to_int, (const u8 *) hash_pos, hash_len, tmp_buf);
+ if (hash_len < 32 + 1) return (PARSER_SALT_LENGTH);
+
uint user_len = hash_len - 32;
const u8 *tmp_hash = tmp_buf + user_len;
return (PARSER_OK);
}
+int krb5tgs_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13100) || (input_len > DISPLAY_LEN_MAX_13100)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_KRB5TGS, input_buf, 11)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ krb5tgs_t *krb5tgs = (krb5tgs_t *) hash_buf->esalt;
+
+ /**
+ * parse line
+ */
+
+ /* Skip '$' */
+ char *account_pos = input_buf + 11 + 1;
+
+ char *data_pos;
+
+ uint data_len;
+
+ if (account_pos[0] == '*')
+ {
+ account_pos++;
+
+ data_pos = strchr (account_pos, '*');
+
+ /* Skip '*' */
+ data_pos++;
+
+ if (data_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint account_len = data_pos - account_pos + 1;
+
+ if (account_len >= 512) return (PARSER_SALT_LENGTH);
+
+ /* Skip '$' */
+ data_pos++;
+
+ data_len = input_len - 11 - 1 - account_len - 2;
+
+ memcpy (krb5tgs->account_info, account_pos - 1, account_len);
+ }
+ else
+ {
+ /* assume $krb5tgs$23$checksum$edata2 */
+ data_pos = account_pos;
+
+ memcpy (krb5tgs->account_info, "**", 3);
+
+ data_len = input_len - 11 - 1 - 1;
+ }
+
+ if (data_len < ((16 + 32) * 2)) return (PARSER_SALT_LENGTH);
+
+ char *checksum_ptr = (char *) krb5tgs->checksum;
+
+ for (uint i = 0; i < 16 * 2; i += 2)
+ {
+ const char p0 = data_pos[i + 0];
+ const char p1 = data_pos[i + 1];
+
+ *checksum_ptr++ = hex_convert (p1) << 0
+ | hex_convert (p0) << 4;
+ }
+
+ char *edata_ptr = (char *) krb5tgs->edata2;
+
+ krb5tgs->edata2_len = (data_len - 32) / 2 ;
+
+ /* skip '$' */
+ for (uint i = 16 * 2 + 1; i < (krb5tgs->edata2_len * 2) + (16 * 2 + 1); i += 2)
+ {
+ const char p0 = data_pos[i + 0];
+ const char p1 = data_pos[i + 1];
+ *edata_ptr++ = hex_convert (p1) << 0
+ | hex_convert (p0) << 4;
+ }
+
+ /* this is needed for hmac_md5 */
+ *edata_ptr++ = 0x80;
+
+ salt->salt_buf[0] = krb5tgs->checksum[0];
+ salt->salt_buf[1] = krb5tgs->checksum[1];
+ salt->salt_buf[2] = krb5tgs->checksum[2];
+ salt->salt_buf[3] = krb5tgs->checksum[3];
+
+ salt->salt_len = 32;
+
+ digest[0] = krb5tgs->checksum[0];
+ digest[1] = krb5tgs->checksum[1];
+ digest[2] = krb5tgs->checksum[2];
+ digest[3] = krb5tgs->checksum[3];
+
+ return (PARSER_OK);
+}
+
+int axcrypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13200) || (input_len > DISPLAY_LEN_MAX_13200)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_AXCRYPT, input_buf, 11)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ /**
+ * parse line
+ */
+
+ /* Skip '*' */
+ char *wrapping_rounds_pos = input_buf + 11 + 1;
+
+ char *salt_pos;
+
+ char *wrapped_key_pos;
+
+ char *data_pos;
+
+ salt->salt_iter = atoi (wrapping_rounds_pos);
+
+ salt_pos = strchr (wrapping_rounds_pos, '*');
+
+ if (salt_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint wrapping_rounds_len = salt_pos - wrapping_rounds_pos;
+
+ /* Skip '*' */
+ salt_pos++;
+
+ data_pos = salt_pos;
+
+ wrapped_key_pos = strchr (salt_pos, '*');
+
+ if (wrapped_key_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint salt_len = wrapped_key_pos - salt_pos;
+
+ if (salt_len != 32) return (PARSER_SALT_LENGTH);
+
+ /* Skip '*' */
+ wrapped_key_pos++;
+
+ uint wrapped_key_len = input_len - 11 - 1 - wrapping_rounds_len - 1 - salt_len - 1;
+
+ if (wrapped_key_len != 48) return (PARSER_SALT_LENGTH);
+
+ salt->salt_buf[0] = hex_to_u32 ((const u8 *) &data_pos[ 0]);
+ salt->salt_buf[1] = hex_to_u32 ((const u8 *) &data_pos[ 8]);
+ salt->salt_buf[2] = hex_to_u32 ((const u8 *) &data_pos[16]);
+ salt->salt_buf[3] = hex_to_u32 ((const u8 *) &data_pos[24]);
+
+ data_pos += 33;
+
+ salt->salt_buf[4] = hex_to_u32 ((const u8 *) &data_pos[ 0]);
+ salt->salt_buf[5] = hex_to_u32 ((const u8 *) &data_pos[ 8]);
+ salt->salt_buf[6] = hex_to_u32 ((const u8 *) &data_pos[16]);
+ salt->salt_buf[7] = hex_to_u32 ((const u8 *) &data_pos[24]);
+ salt->salt_buf[8] = hex_to_u32 ((const u8 *) &data_pos[32]);
+ salt->salt_buf[9] = hex_to_u32 ((const u8 *) &data_pos[40]);
+
+ salt->salt_len = 40;
+
+ digest[0] = salt->salt_buf[0];
+ digest[1] = salt->salt_buf[1];
+ digest[2] = salt->salt_buf[2];
+ digest[3] = salt->salt_buf[3];
+
+ return (PARSER_OK);
+}
+
+int keepass_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13400) || (input_len > DISPLAY_LEN_MAX_13400)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_KEEPASS, input_buf, 9)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ keepass_t *keepass = (keepass_t *) hash_buf->esalt;
+
+ /**
+ * parse line
+ */
+
+ char *version_pos;
+
+ char *rounds_pos;
+
+ char *algorithm_pos;
+
+ char *final_random_seed_pos;
+ u32 final_random_seed_len;
+
+ char *transf_random_seed_pos;
+ u32 transf_random_seed_len;
+
+ char *enc_iv_pos;
+ u32 enc_iv_len;
+
+ /* default is no keyfile provided */
+ char *keyfile_len_pos;
+ u32 keyfile_len = 0;
+ u32 is_keyfile_present = 0;
+ char *keyfile_inline_pos;
+ char *keyfile_pos;
+
+ /* specific to version 1 */
+ char *contents_len_pos;
+ u32 contents_len;
+ char *contents_pos;
+
+ /* specific to version 2 */
+ char *expected_bytes_pos;
+ u32 expected_bytes_len;
+
+ char *contents_hash_pos;
+ u32 contents_hash_len;
+
+ version_pos = input_buf + 8 + 1 + 1;
+
+ keepass->version = atoi (version_pos);
+
+ rounds_pos = strchr (version_pos, '*');
+
+ if (rounds_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ rounds_pos++;
+
+ salt->salt_iter = (atoi (rounds_pos));
+
+ algorithm_pos = strchr (rounds_pos, '*');
+
+ if (algorithm_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ algorithm_pos++;
+
+ keepass->algorithm = atoi (algorithm_pos);
+
+ final_random_seed_pos = strchr (algorithm_pos, '*');
+
+ if (final_random_seed_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ final_random_seed_pos++;
+
+ keepass->final_random_seed[0] = hex_to_u32 ((const u8 *) &final_random_seed_pos[ 0]);
+ keepass->final_random_seed[1] = hex_to_u32 ((const u8 *) &final_random_seed_pos[ 8]);
+ keepass->final_random_seed[2] = hex_to_u32 ((const u8 *) &final_random_seed_pos[16]);
+ keepass->final_random_seed[3] = hex_to_u32 ((const u8 *) &final_random_seed_pos[24]);
+
+ if (keepass->version == 2)
+ {
+ keepass->final_random_seed[4] = hex_to_u32 ((const u8 *) &final_random_seed_pos[32]);
+ keepass->final_random_seed[5] = hex_to_u32 ((const u8 *) &final_random_seed_pos[40]);
+ keepass->final_random_seed[6] = hex_to_u32 ((const u8 *) &final_random_seed_pos[48]);
+ keepass->final_random_seed[7] = hex_to_u32 ((const u8 *) &final_random_seed_pos[56]);
+ }
+
+ transf_random_seed_pos = strchr (final_random_seed_pos, '*');
+
+ if (transf_random_seed_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ final_random_seed_len = transf_random_seed_pos - final_random_seed_pos;
+
+ if (keepass->version == 1 && final_random_seed_len != 32) return (PARSER_SALT_LENGTH);
+ if (keepass->version == 2 && final_random_seed_len != 64) return (PARSER_SALT_LENGTH);
+
+ transf_random_seed_pos++;
+
+ keepass->transf_random_seed[0] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[ 0]);
+ keepass->transf_random_seed[1] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[ 8]);
+ keepass->transf_random_seed[2] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[16]);
+ keepass->transf_random_seed[3] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[24]);
+ keepass->transf_random_seed[4] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[32]);
+ keepass->transf_random_seed[5] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[40]);
+ keepass->transf_random_seed[6] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[48]);
+ keepass->transf_random_seed[7] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[56]);
+
+ enc_iv_pos = strchr (transf_random_seed_pos, '*');
+
+ if (enc_iv_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ transf_random_seed_len = enc_iv_pos - transf_random_seed_pos;
+
+ if (transf_random_seed_len != 64) return (PARSER_SALT_LENGTH);
+
+ enc_iv_pos++;
+
+ keepass->enc_iv[0] = hex_to_u32 ((const u8 *) &enc_iv_pos[ 0]);
+ keepass->enc_iv[1] = hex_to_u32 ((const u8 *) &enc_iv_pos[ 8]);
+ keepass->enc_iv[2] = hex_to_u32 ((const u8 *) &enc_iv_pos[16]);
+ keepass->enc_iv[3] = hex_to_u32 ((const u8 *) &enc_iv_pos[24]);
+
+ if (keepass->version == 1)
+ {
+ contents_hash_pos = strchr (enc_iv_pos, '*');
+
+ if (contents_hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ enc_iv_len = contents_hash_pos - enc_iv_pos;
+
+ if (enc_iv_len != 32) return (PARSER_SALT_LENGTH);
+
+ contents_hash_pos++;
+
+ keepass->contents_hash[0] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 0]);
+ keepass->contents_hash[1] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 8]);
+ keepass->contents_hash[2] = hex_to_u32 ((const u8 *) &contents_hash_pos[16]);
+ keepass->contents_hash[3] = hex_to_u32 ((const u8 *) &contents_hash_pos[24]);
+ keepass->contents_hash[4] = hex_to_u32 ((const u8 *) &contents_hash_pos[32]);
+ keepass->contents_hash[5] = hex_to_u32 ((const u8 *) &contents_hash_pos[40]);
+ keepass->contents_hash[6] = hex_to_u32 ((const u8 *) &contents_hash_pos[48]);
+ keepass->contents_hash[7] = hex_to_u32 ((const u8 *) &contents_hash_pos[56]);
+
+ /* get length of contents following */
+ char *inline_flag_pos = strchr (contents_hash_pos, '*');
+
+ if (inline_flag_pos == NULL) return (PARSER_SALT_LENGTH);
+
+ contents_hash_len = inline_flag_pos - contents_hash_pos;
+
+ if (contents_hash_len != 64) return (PARSER_SALT_LENGTH);
+
+ inline_flag_pos++;
+
+ u32 inline_flag = atoi (inline_flag_pos);
+
+ if (inline_flag != 1) return (PARSER_SALT_LENGTH);
+
+ contents_len_pos = strchr (inline_flag_pos, '*');
+
+ if (contents_len_pos == NULL) return (PARSER_SALT_LENGTH);
+
+ contents_len_pos++;
+
+ contents_len = atoi (contents_len_pos);
+
+ if (contents_len > 50000) return (PARSER_SALT_LENGTH);
+
+ contents_pos = strchr (contents_len_pos, '*');
+
+ if (contents_pos == NULL) return (PARSER_SALT_LENGTH);
+
+ contents_pos++;
+
+ u32 i;
+
+ keepass->contents_len = contents_len;
+
+ contents_len = contents_len / 4;
+
+ keyfile_inline_pos = strchr (contents_pos, '*');
+
+ u32 real_contents_len;
+
+ if (keyfile_inline_pos == NULL)
+ real_contents_len = input_len - (contents_pos - input_buf);
+ else
+ {
+ real_contents_len = keyfile_inline_pos - contents_pos;
+ keyfile_inline_pos++;
+ is_keyfile_present = 1;
+ }
+
+ if (real_contents_len != keepass->contents_len * 2) return (PARSER_SALT_LENGTH);
+
+ for (i = 0; i < contents_len; i++)
+ keepass->contents[i] = hex_to_u32 ((const u8 *) &contents_pos[i * 8]);
+ }
+ else if (keepass->version == 2)
+ {
+ expected_bytes_pos = strchr (enc_iv_pos, '*');
+
+ if (expected_bytes_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ enc_iv_len = expected_bytes_pos - enc_iv_pos;
+
+ if (enc_iv_len != 32) return (PARSER_SALT_LENGTH);
+
+ expected_bytes_pos++;
+
+ keepass->expected_bytes[0] = hex_to_u32 ((const u8 *) &expected_bytes_pos[ 0]);
+ keepass->expected_bytes[1] = hex_to_u32 ((const u8 *) &expected_bytes_pos[ 8]);
+ keepass->expected_bytes[2] = hex_to_u32 ((const u8 *) &expected_bytes_pos[16]);
+ keepass->expected_bytes[3] = hex_to_u32 ((const u8 *) &expected_bytes_pos[24]);
+ keepass->expected_bytes[4] = hex_to_u32 ((const u8 *) &expected_bytes_pos[32]);
+ keepass->expected_bytes[5] = hex_to_u32 ((const u8 *) &expected_bytes_pos[40]);
+ keepass->expected_bytes[6] = hex_to_u32 ((const u8 *) &expected_bytes_pos[48]);
+ keepass->expected_bytes[7] = hex_to_u32 ((const u8 *) &expected_bytes_pos[56]);
+
+ contents_hash_pos = strchr (expected_bytes_pos, '*');
+
+ if (contents_hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ expected_bytes_len = contents_hash_pos - expected_bytes_pos;
+
+ if (expected_bytes_len != 64) return (PARSER_SALT_LENGTH);
+
+ contents_hash_pos++;
+
+ keepass->contents_hash[0] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 0]);
+ keepass->contents_hash[1] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 8]);
+ keepass->contents_hash[2] = hex_to_u32 ((const u8 *) &contents_hash_pos[16]);
+ keepass->contents_hash[3] = hex_to_u32 ((const u8 *) &contents_hash_pos[24]);
+ keepass->contents_hash[4] = hex_to_u32 ((const u8 *) &contents_hash_pos[32]);
+ keepass->contents_hash[5] = hex_to_u32 ((const u8 *) &contents_hash_pos[40]);
+ keepass->contents_hash[6] = hex_to_u32 ((const u8 *) &contents_hash_pos[48]);
+ keepass->contents_hash[7] = hex_to_u32 ((const u8 *) &contents_hash_pos[56]);
+
+ keyfile_inline_pos = strchr (contents_hash_pos, '*');
+
+ if (keyfile_inline_pos == NULL)
+ contents_hash_len = input_len - (int) (contents_hash_pos - input_buf);
+ else
+ {
+ contents_hash_len = keyfile_inline_pos - contents_hash_pos;
+ keyfile_inline_pos++;
+ is_keyfile_present = 1;
+ }
+ if (contents_hash_len != 64) return (PARSER_SALT_LENGTH);
+ }
+
+ if (is_keyfile_present != 0)
+ {
+ keyfile_len_pos = strchr (keyfile_inline_pos, '*');
+
+ keyfile_len_pos++;
+
+ keyfile_len = atoi (keyfile_len_pos);
+
+ keepass->keyfile_len = keyfile_len;
+
+ if (keyfile_len != 64) return (PARSER_SALT_LENGTH);
+
+ keyfile_pos = strchr (keyfile_len_pos, '*');
+
+ if (keyfile_pos == NULL) return (PARSER_SALT_LENGTH);
+
+ keyfile_pos++;
+
+ u32 real_keyfile_len = input_len - (keyfile_pos - input_buf);
+
+ if (real_keyfile_len != 64) return (PARSER_SALT_LENGTH);
+
+ keepass->keyfile[0] = hex_to_u32 ((const u8 *) &keyfile_pos[ 0]);
+ keepass->keyfile[1] = hex_to_u32 ((const u8 *) &keyfile_pos[ 8]);
+ keepass->keyfile[2] = hex_to_u32 ((const u8 *) &keyfile_pos[16]);
+ keepass->keyfile[3] = hex_to_u32 ((const u8 *) &keyfile_pos[24]);
+ keepass->keyfile[4] = hex_to_u32 ((const u8 *) &keyfile_pos[32]);
+ keepass->keyfile[5] = hex_to_u32 ((const u8 *) &keyfile_pos[40]);
+ keepass->keyfile[6] = hex_to_u32 ((const u8 *) &keyfile_pos[48]);
+ keepass->keyfile[7] = hex_to_u32 ((const u8 *) &keyfile_pos[56]);
+ }
+
+ digest[0] = keepass->enc_iv[0];
+ digest[1] = keepass->enc_iv[1];
+ digest[2] = keepass->enc_iv[2];
+ digest[3] = keepass->enc_iv[3];
+
+ salt->salt_buf[0] = keepass->transf_random_seed[0];
+ salt->salt_buf[1] = keepass->transf_random_seed[1];
+ salt->salt_buf[2] = keepass->transf_random_seed[2];
+ salt->salt_buf[3] = keepass->transf_random_seed[3];
+ salt->salt_buf[4] = keepass->transf_random_seed[4];
+ salt->salt_buf[5] = keepass->transf_random_seed[5];
+ salt->salt_buf[6] = keepass->transf_random_seed[6];
+ salt->salt_buf[7] = keepass->transf_random_seed[7];
+
+ return (PARSER_OK);
+}
+
int cf10_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_12600) || (input_len > DISPLAY_LEN_MAX_12600)) return (PARSER_GLOBAL_LENGTH);
if (ch == 0) continue;
- #ifdef _POSIX
- if (ch != '\n')
- #endif
+ //https://github.com/hashcat/oclHashcat/issues/302
+ //#ifdef _POSIX
+ //if (ch != '\n')
+ //#endif
hc_thread_mutex_lock (mux_display);
switch (ch)
{
case 's':
+ case '\r':
case '\n':
log_info ("");
break;
}
+ //https://github.com/hashcat/oclHashcat/issues/302
+ //#ifdef _POSIX
+ //if (ch != '\n')
+ //#endif
+
hc_thread_mutex_unlock (mux_display);
}
#define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
#define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
-int cpu_rule_to_kernel_rule (char rule_buf[BUFSIZ], uint rule_len, kernel_rule_t *rule)
+int cpu_rule_to_kernel_rule (char *rule_buf, uint rule_len, kernel_rule_t *rule)
{
uint rule_pos;
uint rule_cnt;
return (0);
}
-int kernel_rule_to_cpu_rule (char rule_buf[BUFSIZ], kernel_rule_t *rule)
+int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule)
{
uint rule_cnt;
uint rule_pos;
- uint rule_len = BUFSIZ - 1; // maximum possible len
+ uint rule_len = HCBUFSIZ - 1; // maximum possible len
char rule_cmd;