mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-08-14 10:37:23 -07:00
use PrintAndLogEx() instead of PrintAndLog()
This commit is contained in:
Brian Pow
parent
44bd1cd13d
commit
b8f106d7a7
1 changed files with 73 additions and 73 deletions
|
|
@ -95,11 +95,11 @@ static void print_progress_header(void) {
|
|||
char instr_set[12] = "";
|
||||
get_SIMD_instruction_set(instr_set);
|
||||
sprintf(progress_text, "Start using %d threads and %s SIMD core", num_CPUs(), instr_set);
|
||||
PrintAndLog("\n\n");
|
||||
PrintAndLog(" time | #nonces | Activity | expected to brute force");
|
||||
PrintAndLog(" | | | #states | time ");
|
||||
PrintAndLog("------------------------------------------------------------------------------------------------------");
|
||||
PrintAndLog(" 0 | 0 | %-55s | |", progress_text);
|
||||
PrintAndLogEx(NORMAL, "\n\n");
|
||||
PrintAndLogEx(NORMAL, " time | #nonces | Activity | expected to brute force");
|
||||
PrintAndLogEx(NORMAL, " | | | #states | time ");
|
||||
PrintAndLogEx(NORMAL, "------------------------------------------------------------------------------------------------------");
|
||||
PrintAndLogEx(NORMAL, " 0 | 0 | %-55s | |", progress_text);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -119,7 +119,7 @@ void hardnested_print_progress(uint32_t nonces, char *activity, float brute_forc
|
|||
} else {
|
||||
sprintf(brute_force_time_string, "%2.0fd", brute_force_time/(60*60*24));
|
||||
}
|
||||
PrintAndLog(" %7.0f | %7u | %-55s | %15.0f | %5s", (float)total_time/1000.0, nonces, activity, brute_force, brute_force_time_string);
|
||||
PrintAndLogEx(NORMAL, " %7.0f | %7u | %-55s | %15.0f | %5s", (float)total_time/1000.0, nonces, activity, brute_force, brute_force_time_string);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -265,7 +265,7 @@ static void init_bitflip_bitarrays(void)
|
|||
uint8_t input_buffer[filesize];
|
||||
size_t bytesread = fread(input_buffer, 1, filesize, statesfile);
|
||||
if (bytesread != filesize) {
|
||||
printf("File read error with %s. Aborting...\n", state_file_name);
|
||||
PrintAndLogEx(WARNING, "File read error with %s. Aborting...\n", state_file_name);
|
||||
fclose(statesfile);
|
||||
inflateEnd(&compressed_stream);
|
||||
exit(5);
|
||||
|
|
@ -277,7 +277,7 @@ static void init_bitflip_bitarrays(void)
|
|||
if ((float)count/(1<<24) < IGNORE_BITFLIP_THRESHOLD) {
|
||||
uint32_t *bitset = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (bitset == NULL) {
|
||||
printf("Out of memory error in init_bitflip_statelists(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_bitflip_statelists(). Aborting...\n");
|
||||
inflateEnd(&compressed_stream);
|
||||
exit(4);
|
||||
}
|
||||
|
|
@ -288,10 +288,10 @@ static void init_bitflip_bitarrays(void)
|
|||
bitflip_bitarrays[odd_even][bitflip] = bitset;
|
||||
count_bitflip_bitarrays[odd_even][bitflip] = count;
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("(%03" PRIx16 " %s:%5.1f%%) ", bitflip, odd_even?"odd ":"even", (float)count/(1<<24)*100.0);
|
||||
PrintAndLogEx(NORMAL, "(%03" PRIx16 " %s:%5.1f%%) ", bitflip, odd_even?"odd ":"even", (float)count/(1<<24)*100.0);
|
||||
line++;
|
||||
if (line == 8) {
|
||||
printf("\n");
|
||||
PrintAndLogEx(NORMAL, "\n");
|
||||
line = 0;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -323,16 +323,16 @@ static void init_bitflip_bitarrays(void)
|
|||
}
|
||||
qsort(all_effective_bitflip, num_1st_byte_effective_bitflips, sizeof(uint16_t), compare_count_bitflip_bitarrays);
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("\n1st byte effective bitflips (%d): \n", num_1st_byte_effective_bitflips);
|
||||
PrintAndLogEx(NORMAL, "\n1st byte effective bitflips (%d): \n", num_1st_byte_effective_bitflips);
|
||||
for(uint16_t i = 0; i < num_1st_byte_effective_bitflips; i++) {
|
||||
printf("%03x ", all_effective_bitflip[i]);
|
||||
PrintAndLogEx(NORMAL, "%03x ", all_effective_bitflip[i]);
|
||||
}
|
||||
#endif
|
||||
qsort(all_effective_bitflip+num_1st_byte_effective_bitflips, num_all_effective_bitflips - num_1st_byte_effective_bitflips, sizeof(uint16_t), compare_count_bitflip_bitarrays);
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("\n2nd byte effective bitflips (%d): \n", num_all_effective_bitflips - num_1st_byte_effective_bitflips);
|
||||
PrintAndLogEx(NORMAL, "\n2nd byte effective bitflips (%d): \n", num_all_effective_bitflips - num_1st_byte_effective_bitflips);
|
||||
for(uint16_t i = num_1st_byte_effective_bitflips; i < num_all_effective_bitflips; i++) {
|
||||
printf("%03x ", all_effective_bitflip[i]);
|
||||
PrintAndLogEx(NORMAL, "%03x ", all_effective_bitflip[i]);
|
||||
}
|
||||
#endif
|
||||
char progress_text[80];
|
||||
|
|
@ -389,14 +389,14 @@ static void init_part_sum_bitarrays(void)
|
|||
for (uint16_t part_sum_a0 = 0; part_sum_a0 < NUM_PART_SUMS; part_sum_a0++) {
|
||||
part_sum_a0_bitarrays[odd_even][part_sum_a0] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (part_sum_a0_bitarrays[odd_even][part_sum_a0] == NULL) {
|
||||
printf("Out of memory error in init_part_suma0_statelists(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_part_suma0_statelists(). Aborting...\n");
|
||||
exit(4);
|
||||
}
|
||||
clear_bitarray24(part_sum_a0_bitarrays[odd_even][part_sum_a0]);
|
||||
}
|
||||
}
|
||||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
//printf("(%d, %" PRIu16 ")...", odd_even, part_sum_a0);
|
||||
//PrintAndLogEx(NORMAL, "(%d, %" PRIu16 ")...", odd_even, part_sum_a0);
|
||||
for (uint32_t state = 0; state < (1<<20); state++) {
|
||||
uint16_t part_sum_a0 = PartialSumProperty(state, odd_even) / 2;
|
||||
for (uint16_t low_bits = 0; low_bits < 1<<4; low_bits++) {
|
||||
|
|
@ -409,14 +409,14 @@ static void init_part_sum_bitarrays(void)
|
|||
for (uint16_t part_sum_a8 = 0; part_sum_a8 < NUM_PART_SUMS; part_sum_a8++) {
|
||||
part_sum_a8_bitarrays[odd_even][part_sum_a8] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (part_sum_a8_bitarrays[odd_even][part_sum_a8] == NULL) {
|
||||
printf("Out of memory error in init_part_suma8_statelists(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_part_suma8_statelists(). Aborting...\n");
|
||||
exit(4);
|
||||
}
|
||||
clear_bitarray24(part_sum_a8_bitarrays[odd_even][part_sum_a8]);
|
||||
}
|
||||
}
|
||||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
//printf("(%d, %" PRIu16 ")...", odd_even, part_sum_a8);
|
||||
//PrintAndLogEx(NORMAL, "(%d, %" PRIu16 ")...", odd_even, part_sum_a8);
|
||||
for (uint32_t state = 0; state < (1<<20); state++) {
|
||||
uint16_t part_sum_a8 = PartialSumProperty(state, odd_even) / 2;
|
||||
for (uint16_t high_bits = 0; high_bits < 1<<4; high_bits++) {
|
||||
|
|
@ -450,7 +450,7 @@ static void init_sum_bitarrays(void)
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
sum_a0_bitarrays[odd_even][sum_a0] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (sum_a0_bitarrays[odd_even][sum_a0] == NULL) {
|
||||
printf("Out of memory error in init_sum_bitarrays(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_sum_bitarrays(). Aborting...\n");
|
||||
exit(4);
|
||||
}
|
||||
clear_bitarray24(sum_a0_bitarrays[odd_even][sum_a0]);
|
||||
|
|
@ -568,14 +568,14 @@ static void init_nonce_memory(void)
|
|||
}
|
||||
nonces[i].states_bitarray[EVEN_STATE] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (nonces[i].states_bitarray[EVEN_STATE] == NULL) {
|
||||
printf("Out of memory error in init_nonce_memory(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_nonce_memory(). Aborting...\n");
|
||||
exit(4);
|
||||
}
|
||||
set_bitarray24(nonces[i].states_bitarray[EVEN_STATE]);
|
||||
nonces[i].num_states_bitarray[EVEN_STATE] = 1 << 24;
|
||||
nonces[i].states_bitarray[ODD_STATE] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (nonces[i].states_bitarray[ODD_STATE] == NULL) {
|
||||
printf("Out of memory error in init_nonce_memory(). Aborting...\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in init_nonce_memory(). Aborting...\n");
|
||||
exit(4);
|
||||
}
|
||||
set_bitarray24(nonces[i].states_bitarray[ODD_STATE]);
|
||||
|
|
@ -680,7 +680,7 @@ static void init_allbitflips_array(void)
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
uint32_t *bitset = all_bitflips_bitarray[odd_even] = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (bitset == NULL) {
|
||||
printf("Out of memory in init_allbitflips_array(). Aborting...");
|
||||
PrintAndLogEx(WARNING, "Out of memory in init_allbitflips_array(). Aborting...");
|
||||
exit(4);
|
||||
}
|
||||
set_bitarray24(bitset);
|
||||
|
|
@ -793,9 +793,9 @@ static void update_p_K(void)
|
|||
uint16_t sum_a8 = sums[sum_a8_idx];
|
||||
my_p_K[sum_a8_idx] = (float)estimated_num_states_coarse(sum_a0, sum_a8) / total_count;
|
||||
}
|
||||
// printf("my_p_K = [");
|
||||
// PrintAndLogEx(NORMAL, "my_p_K = [");
|
||||
// for (uint8_t sum_a8_idx = 0; sum_a8_idx < NUM_SUMS; sum_a8_idx++) {
|
||||
// printf("%7.4f ", my_p_K[sum_a8_idx]);
|
||||
// PrintAndLogEx(NORMAL, "%7.4f ", my_p_K[sum_a8_idx]);
|
||||
// }
|
||||
p_K = my_p_K;
|
||||
}
|
||||
|
|
@ -859,7 +859,7 @@ static float check_smallest_bitflip_bitarrays(void)
|
|||
#if defined (DEBUG_REDUCTION)
|
||||
num_odd = nonces[best_first_byte_smallest_bitarray].num_states_bitarray[ODD_STATE];
|
||||
num_even = nonces[best_first_byte_smallest_bitarray].num_states_bitarray[EVEN_STATE]; // * (float)nonces[best_first_byte_smallest_bitarray^0x80].num_states_bitarray[EVEN_STATE] / num_all_bitflips_bitarray[EVEN_STATE];
|
||||
printf("0x%02x: %8d * %8d = %12" PRIu64 " (2^%1.1f)\n", best_first_byte_smallest_bitarray, num_odd, num_even, (uint64_t)num_odd * num_even, log((uint64_t)num_odd * num_even)/log(2.0));
|
||||
PrintAndLogEx(NORMAL, "0x%02x: %8d * %8d = %12" PRIu64 " (2^%1.1f)\n", best_first_byte_smallest_bitarray, num_odd, num_even, (uint64_t)num_odd * num_even, log((uint64_t)num_odd * num_even)/log(2.0));
|
||||
#endif
|
||||
return (float)smallest/2.0;
|
||||
}
|
||||
|
|
@ -906,11 +906,11 @@ static float sort_best_first_bytes(void)
|
|||
// sort based on expected number of states to brute force
|
||||
qsort(best_first_bytes, 256, 1, compare_expected_num_brute_force);
|
||||
|
||||
// printf("refine estimations: ");
|
||||
// PrintAndLogEx(NORMAL, "refine estimations: ");
|
||||
#define NUM_REFINES 1
|
||||
// refine scores for the best:
|
||||
for (uint16_t i = 0; i < NUM_REFINES; i++) {
|
||||
// printf("%d...", i);
|
||||
// PrintAndLogEx(NORMAL, "%d...", i);
|
||||
uint16_t first_byte = best_first_bytes[i];
|
||||
for (uint8_t j = 0; j < NUM_SUMS && nonces[first_byte].sum_a8_guess[j].prob > 0.05; j++) {
|
||||
nonces[first_byte].sum_a8_guess[j].num_states = estimated_num_states(first_byte, sums[first_byte_Sum], sums[nonces[first_byte].sum_a8_guess[j].sum_a8_idx]);
|
||||
|
|
@ -920,17 +920,17 @@ static float sort_best_first_bytes(void)
|
|||
// || nonces[first_byte].sum_a8_guess[2].num_states == 0) {
|
||||
// if (nonces[first_byte].sum_a8_guess[0].num_states == 0) {
|
||||
// nonces[first_byte].sum_a8_guess[0].prob = 0.0;
|
||||
// printf("(0x%02x,%d)", first_byte, 0);
|
||||
// PrintAndLogEx(NORMAL, "(0x%02x,%d)", first_byte, 0);
|
||||
// }
|
||||
// if (nonces[first_byte].sum_a8_guess[1].num_states == 0) {
|
||||
// nonces[first_byte].sum_a8_guess[1].prob = 0.0;
|
||||
// printf("(0x%02x,%d)", first_byte, 1);
|
||||
// PrintAndLogEx(NORMAL, "(0x%02x,%d)", first_byte, 1);
|
||||
// }
|
||||
// if (nonces[first_byte].sum_a8_guess[2].num_states == 0) {
|
||||
// nonces[first_byte].sum_a8_guess[2].prob = 0.0;
|
||||
// printf("(0x%02x,%d)", first_byte, 2);
|
||||
// PrintAndLogEx(NORMAL, "(0x%02x,%d)", first_byte, 2);
|
||||
// }
|
||||
// printf("|");
|
||||
// PrintAndLogEx(NORMAL, "|");
|
||||
// qsort(nonces[first_byte].sum_a8_guess, NUM_SUMS, sizeof(guess_sum_a8_t), compare_sum_a8_guess);
|
||||
// for (uint8_t j = 0; j < NUM_SUMS && nonces[first_byte].sum_a8_guess[j].prob > 0.05; j++) {
|
||||
// nonces[first_byte].sum_a8_guess[j].num_states = estimated_num_states(first_byte, sums[first_byte_Sum], sums[nonces[first_byte].sum_a8_guess[j].sum_a8_idx]);
|
||||
|
|
@ -966,7 +966,7 @@ static float sort_best_first_bytes(void)
|
|||
}
|
||||
}
|
||||
if (best_byte != 0) {
|
||||
// printf("0x%02x <-> 0x%02x", best_first_bytes[0], best_first_bytes[best_byte]);
|
||||
// PrintAndLogEx(NORMAL, "0x%02x <-> 0x%02x", best_first_bytes[0], best_first_bytes[best_byte]);
|
||||
uint8_t tmp = best_first_bytes[0];
|
||||
best_first_bytes[0] = best_first_bytes[best_byte];
|
||||
best_first_bytes[best_byte] = tmp;
|
||||
|
|
@ -1014,7 +1014,7 @@ static float update_reduction_rate(float last, bool init)
|
|||
float reduction_rate = -1.0 * dev_xy / dev_x2; // the negative slope of the linear regression
|
||||
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("update_reduction_rate(%1.0f) = %1.0f per sample, brute_force_per_sample = %1.0f\n", last, reduction_rate, brute_force_per_second * (float)sample_period / 1000.0);
|
||||
PrintAndLogEx(NORMAL, "update_reduction_rate(%1.0f) = %1.0f per sample, brute_force_per_sample = %1.0f\n", last, reduction_rate, brute_force_per_second * (float)sample_period / 1000.0);
|
||||
#endif
|
||||
return reduction_rate;
|
||||
}
|
||||
|
|
@ -1023,7 +1023,7 @@ static float update_reduction_rate(float last, bool init)
|
|||
static bool shrink_key_space(float *brute_forces)
|
||||
{
|
||||
#if defined(DEBUG_REDUCTION)
|
||||
printf("shrink_key_space() with stage = 0x%02x\n", hardnested_stage);
|
||||
PrintAndLogEx(NORMAL, "shrink_key_space() with stage = 0x%02x\n", hardnested_stage);
|
||||
#endif
|
||||
float brute_forces1 = check_smallest_bitflip_bitarrays();
|
||||
float brute_forces2 = (float)(1LL << 47);
|
||||
|
|
@ -1067,14 +1067,14 @@ static int read_nonce_file(char *filename)
|
|||
|
||||
num_acquired_nonces = 0;
|
||||
if ((fnonces = fopen(filename,"rb")) == NULL) {
|
||||
PrintAndLog("Could not open file %s",filename);
|
||||
PrintAndLogEx(NORMAL, "Could not open file %s",filename);
|
||||
return 1;
|
||||
}
|
||||
snprintf(progress_text, 80, "Reading nonces from file %s...",filename);
|
||||
hardnested_print_progress(0, progress_text, (float)(1LL<<47), 0);
|
||||
bytes_read = fread(read_buf, 1, 6, fnonces);
|
||||
if (bytes_read != 6) {
|
||||
PrintAndLog("File reading error.");
|
||||
PrintAndLogEx(WARNING, "File reading error.");
|
||||
fclose(fnonces);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1148,7 +1148,7 @@ __attribute__((force_align_arg_pointer))
|
|||
uint16_t bitflip = all_effective_bitflip[bitflip_idx];
|
||||
if (time_budget & timeout()) {
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("break at bitflip_idx %d...", bitflip_idx);
|
||||
PrintAndLogEx(NORMAL, "break at bitflip_idx %d...", bitflip_idx);
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -1167,7 +1167,7 @@ __attribute__((force_align_arg_pointer))
|
|||
if (nonces[i].num_states_bitarray[odd_even] != old_count) {
|
||||
nonces[i].all_bitflips_dirty[odd_even] = true;
|
||||
}
|
||||
// printf("bitflip: %d old: %d, new: %d ", bitflip, old_count, nonces[i].num_states_bitarray[odd_even]);
|
||||
// PrintAndLogEx(NORMAL, "bitflip: %d old: %d, new: %d ", bitflip, old_count, nonces[i].num_states_bitarray[odd_even]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1184,7 +1184,7 @@ __attribute__((force_align_arg_pointer))
|
|||
uint16_t bitflip = all_effective_bitflip[bitflip_idx];
|
||||
if (time_budget & timeout()) {
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
printf("break at bitflip_idx %d...", bitflip_idx);
|
||||
PrintAndLogEx(NORMAL, "break at bitflip_idx %d...", bitflip_idx);
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -1214,8 +1214,8 @@ __attribute__((force_align_arg_pointer))
|
|||
}
|
||||
}
|
||||
}
|
||||
// printf("states_bitarray[0][%" PRIu16 "] contains %d ones.\n", i, count_states(nonces[i].states_bitarray[EVEN_STATE]));
|
||||
// printf("states_bitarray[1][%" PRIu16 "] contains %d ones.\n", i, count_states(nonces[i].states_bitarray[ODD_STATE]));
|
||||
// PrintAndLogEx(NORMAL, "states_bitarray[0][%" PRIu16 "] contains %d ones.\n", i, count_states(nonces[i].states_bitarray[EVEN_STATE]));
|
||||
// PrintAndLogEx(NORMAL, "states_bitarray[1][%" PRIu16 "] contains %d ones.\n", i, count_states(nonces[i].states_bitarray[ODD_STATE]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1258,7 +1258,7 @@ static void check_for_BitFlipProperties(bool time_budget)
|
|||
}
|
||||
}
|
||||
#if defined (DEBUG_REDUCTION)
|
||||
if (hardnested_stage & CHECK_1ST_BYTES) printf("stage 1 not completed yet\n");
|
||||
if (hardnested_stage & CHECK_1ST_BYTES) PrintAndLogEx(NORMAL, "stage 1 not completed yet\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -1377,7 +1377,7 @@ static void simulate_acquire_nonces()
|
|||
} while (!acquisition_completed);
|
||||
|
||||
time_t end_time = time(NULL);
|
||||
// PrintAndLog("Acquired a total of %" PRId32" nonces in %1.0f seconds (%1.0f nonces/minute)",
|
||||
// PrintAndLogEx(NORMAL, "Acquired a total of %" PRId32" nonces in %1.0f seconds (%1.0f nonces/minute)",
|
||||
// num_acquired_nonces,
|
||||
// difftime(end_time, time1),
|
||||
// difftime(end_time, time1)!=0.0?(float)total_num_nonces*60.0/difftime(end_time, time1):INFINITY
|
||||
|
|
@ -1435,7 +1435,7 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
|
|||
cuid = resp.arg[1];
|
||||
if (nonce_file_write && fnonces == NULL) {
|
||||
if ((fnonces = fopen(filename,"wb")) == NULL) {
|
||||
PrintAndLog("Could not create file %s", filename);
|
||||
PrintAndLogEx(NORMAL, "Could not create file %s", filename);
|
||||
return 3;
|
||||
}
|
||||
snprintf(progress_text, 80, "Writing acquired nonces to binary file %s", filename);
|
||||
|
|
@ -1458,9 +1458,9 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
|
|||
nt_enc2 = bytes_to_num(bufp+4, 4);
|
||||
par_enc = bytes_to_num(bufp+8, 1);
|
||||
|
||||
//printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc1, par_enc >> 4);
|
||||
//PrintAndLogEx(NORMAL, "Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc1, par_enc >> 4);
|
||||
num_acquired_nonces += add_nonce(nt_enc1, par_enc >> 4);
|
||||
//printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc2, par_enc & 0x0f);
|
||||
//PrintAndLogEx(NORMAL, "Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc2, par_enc & 0x0f);
|
||||
num_acquired_nonces += add_nonce(nt_enc2, par_enc & 0x0f);
|
||||
|
||||
if (nonce_file_write) {
|
||||
|
|
@ -1531,7 +1531,7 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
|
|||
fclose(fnonces);
|
||||
}
|
||||
|
||||
// PrintAndLog("Sampled a total of %d nonces in %d seconds (%0.0f nonces/minute)",
|
||||
// PrintAndLogEx(NORMAL, "Sampled a total of %d nonces in %d seconds (%0.0f nonces/minute)",
|
||||
// total_num_nonces,
|
||||
// time(NULL)-time1,
|
||||
// (float)total_num_nonces*60.0/(time(NULL)-time1));
|
||||
|
|
@ -1652,7 +1652,7 @@ static inline bool bitflips_match(uint8_t byte, uint32_t state, odd_even_t odd_e
|
|||
if (!possible) {
|
||||
#ifdef DEBUG_KEY_ELIMINATION
|
||||
if (!quiet && known_target_key != -1 && state == test_state[odd_even]) {
|
||||
printf("Initial state lists: %s test state eliminated by bitflip property.\n", odd_even==EVEN_STATE?"even":"odd");
|
||||
PrintAndLogEx(NORMAL, "Initial state lists: %s test state eliminated by bitflip property.\n", odd_even==EVEN_STATE?"even":"odd");
|
||||
sprintf(failstr, "Initial %s Byte Bitflip property", odd_even==EVEN_STATE?"even":"odd");
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1698,7 +1698,7 @@ static bool all_bitflips_match(uint8_t byte, uint32_t state, odd_even_t odd_even
|
|||
if (!found_match) {
|
||||
#ifdef DEBUG_KEY_ELIMINATION
|
||||
if (known_target_key != -1 && state == test_state[odd_even]) {
|
||||
printf("all_bitflips_match() 1st Byte: %s test state (0x%06x): Eliminated. Bytes = %02x, %02x, Common Bits = %d\n",
|
||||
PrintAndLogEx(NORMAL, "all_bitflips_match() 1st Byte: %s test state (0x%06x): Eliminated. Bytes = %02x, %02x, Common Bits = %d\n",
|
||||
odd_even==ODD_STATE?"odd":"even",
|
||||
test_state[odd_even],
|
||||
byte, byte2, num_common);
|
||||
|
|
@ -1741,12 +1741,12 @@ static void add_matching_states(statelist_t *candidates, uint8_t part_sum_a0, ui
|
|||
uint32_t worstcase_size = 1<<20;
|
||||
candidates->states[odd_even] = (uint32_t *)malloc(sizeof(uint32_t) * worstcase_size);
|
||||
if (candidates->states[odd_even] == NULL) {
|
||||
PrintAndLog("Out of memory error in add_matching_states() - statelist.\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in add_matching_states() - statelist.\n");
|
||||
exit(4);
|
||||
}
|
||||
uint32_t *candidates_bitarray = (uint32_t *)malloc_bitarray(sizeof(uint32_t) * (1<<19));
|
||||
if (candidates_bitarray == NULL) {
|
||||
PrintAndLog("Out of memory error in add_matching_states() - bitarray.\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in add_matching_states() - bitarray.\n");
|
||||
free(candidates->states[odd_even]);
|
||||
exit(4);
|
||||
}
|
||||
|
|
@ -1810,7 +1810,7 @@ static void add_bitflip_candidates(uint8_t byte)
|
|||
uint32_t worstcase_size = nonces[byte].num_states_bitarray[odd_even] + 1;
|
||||
candidates->states[odd_even] = (uint32_t *)malloc(sizeof(uint32_t) * worstcase_size);
|
||||
if (candidates->states[odd_even] == NULL) {
|
||||
PrintAndLog("Out of memory error in add_bitflip_candidates().\n");
|
||||
PrintAndLogEx(WARNING, "Out of memory error in add_bitflip_candidates().\n");
|
||||
exit(4);
|
||||
}
|
||||
|
||||
|
|
@ -1906,7 +1906,7 @@ __attribute__((force_align_arg_pointer))
|
|||
for (uint8_t p = 0; p < NUM_PART_SUMS; p++) {
|
||||
for (uint8_t q = 0; q < NUM_PART_SUMS; q++) {
|
||||
if (2*p*(16-2*q) + (16-2*p)*2*q == sum_a0) {
|
||||
// printf("Reducing Partial Statelists (p,q) = (%d,%d) with lengths %d, %d\n",
|
||||
// PrintAndLogEx(NORMAL, "Reducing Partial Statelists (p,q) = (%d,%d) with lengths %d, %d\n",
|
||||
// p, q, partial_statelist[p].len[ODD_STATE], partial_statelist[q].len[EVEN_STATE]);
|
||||
for (uint8_t r = 0; r < NUM_PART_SUMS; r++) {
|
||||
for (uint8_t s = 0; s < NUM_PART_SUMS; s++) {
|
||||
|
|
@ -1969,14 +1969,14 @@ __attribute__((force_align_arg_pointer))
|
|||
} else {
|
||||
// we really need to calculate something
|
||||
if (even_completed) { // we had one cache hit with non-zero even states
|
||||
// printf("Thread #%u: start working on odd states p=%2d, r=%2d...\n", my_thread_number, p, r);
|
||||
// PrintAndLogEx(NORMAL, "Thread #%u: start working on odd states p=%2d, r=%2d...\n", my_thread_number, p, r);
|
||||
sl_cache[p][r][ODD_STATE].cache_status = WORK_IN_PROGRESS;
|
||||
pthread_mutex_unlock(&statelist_cache_mutex);
|
||||
pthread_mutex_unlock(&book_of_work_mutex);
|
||||
add_matching_states(current_candidates, 2*p, 2*r, ODD_STATE);
|
||||
work_required = false;
|
||||
} else if (odd_completed) { // we had one cache hit with non-zero odd_states
|
||||
// printf("Thread #%u: start working on even states q=%2d, s=%2d...\n", my_thread_number, q, s);
|
||||
// PrintAndLogEx(NORMAL, "Thread #%u: start working on even states q=%2d, s=%2d...\n", my_thread_number, q, s);
|
||||
sl_cache[q][s][EVEN_STATE].cache_status = WORK_IN_PROGRESS;
|
||||
pthread_mutex_unlock(&statelist_cache_mutex);
|
||||
pthread_mutex_unlock(&book_of_work_mutex);
|
||||
|
|
@ -1993,7 +1993,7 @@ __attribute__((force_align_arg_pointer))
|
|||
|
||||
add_matching_states(current_candidates, 2*p, 2*r, ODD_STATE);
|
||||
if(current_candidates->len[ODD_STATE]) {
|
||||
// printf("Thread #%u: start working on even states q=%2d, s=%2d...\n", my_thread_number, q, s);
|
||||
// PrintAndLogEx(NORMAL, "Thread #%u: start working on even states q=%2d, s=%2d...\n", my_thread_number, q, s);
|
||||
add_matching_states(current_candidates, 2*q, 2*s, EVEN_STATE);
|
||||
} else { // no need to calculate even states yet
|
||||
pthread_mutex_lock(&statelist_cache_mutex);
|
||||
|
|
@ -2010,16 +2010,16 @@ __attribute__((force_align_arg_pointer))
|
|||
pthread_mutex_unlock(&book_of_work_mutex);
|
||||
|
||||
// if ((uint64_t)current_candidates->len[ODD_STATE] * current_candidates->len[EVEN_STATE]) {
|
||||
// printf("Candidates for p=%2u, q=%2u, r=%2u, s=%2u: %" PRIu32 " * %" PRIu32 " = %" PRIu64 " (2^%0.1f)\n",
|
||||
// PrintAndLogEx(NORMAL, "Candidates for p=%2u, q=%2u, r=%2u, s=%2u: %" PRIu32 " * %" PRIu32 " = %" PRIu64 " (2^%0.1f)\n",
|
||||
// 2*p, 2*q, 2*r, 2*s, current_candidates->len[ODD_STATE], current_candidates->len[EVEN_STATE],
|
||||
// (uint64_t)current_candidates->len[ODD_STATE] * current_candidates->len[EVEN_STATE],
|
||||
// log((uint64_t)current_candidates->len[ODD_STATE] * current_candidates->len[EVEN_STATE])/log(2));
|
||||
// uint32_t estimated_odd = estimated_num_states_part_sum(best_first_bytes[0], p, r, ODD_STATE);
|
||||
// uint32_t estimated_even= estimated_num_states_part_sum(best_first_bytes[0], q, s, EVEN_STATE);
|
||||
// uint64_t estimated_total = (uint64_t)estimated_odd * estimated_even;
|
||||
// printf("Estimated: %" PRIu32 " * %" PRIu32 " = %" PRIu64 " (2^%0.1f)\n", estimated_odd, estimated_even, estimated_total, log(estimated_total) / log(2));
|
||||
// PrintAndLogEx(NORMAL, "Estimated: %" PRIu32 " * %" PRIu32 " = %" PRIu64 " (2^%0.1f)\n", estimated_odd, estimated_even, estimated_total, log(estimated_total) / log(2));
|
||||
// if (estimated_odd < current_candidates->len[ODD_STATE] || estimated_even < current_candidates->len[EVEN_STATE]) {
|
||||
// printf("############################################################################ERROR! ESTIMATED < REAL !!!\n");
|
||||
// PrintAndLogEx(NORMAL, "############################################################################ERROR! ESTIMATED < REAL !!!\n");
|
||||
// //exit(2);
|
||||
// }
|
||||
// }
|
||||
|
|
@ -2037,7 +2037,7 @@ __attribute__((force_align_arg_pointer))
|
|||
|
||||
static void generate_candidates(uint8_t sum_a0_idx, uint8_t sum_a8_idx)
|
||||
{
|
||||
// printf("Generating crypto1 state candidates... \n");
|
||||
// PrintAndLogEx(NORMAL, "Generating crypto1 state candidates... \n");
|
||||
|
||||
// estimate maximum candidate states
|
||||
// maximum_states = 0;
|
||||
|
|
@ -2049,7 +2049,7 @@ static void generate_candidates(uint8_t sum_a0_idx, uint8_t sum_a8_idx)
|
|||
// }
|
||||
// }
|
||||
// }
|
||||
// printf("Number of possible keys with Sum(a0) = %d: %" PRIu64 " (2^%1.1f)\n", sum_a0, maximum_states, log(maximum_states)/log(2.0));
|
||||
// PrintAndLogEx(NORMAL, "Number of possible keys with Sum(a0) = %d: %" PRIu64 " (2^%1.1f)\n", sum_a0, maximum_states, log(maximum_states)/log(2.0));
|
||||
|
||||
init_statelist_cache();
|
||||
init_book_of_work();
|
||||
|
|
@ -2147,7 +2147,7 @@ static void Tests()
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
uint32_t *bitset = nonces[best_first_bytes[0]].states_bitarray[odd_even];
|
||||
if (!test_bit24(bitset, test_state[odd_even])) {
|
||||
printf("\nBUG: known target key's %s state is not member of first nonce byte's (0x%02x) states_bitarray!\n",
|
||||
PrintAndLogEx(NORMAL, "\nBUG: known target key's %s state is not member of first nonce byte's (0x%02x) states_bitarray!\n",
|
||||
odd_even==EVEN_STATE?"even":"odd ",
|
||||
best_first_bytes[0]);
|
||||
}
|
||||
|
|
@ -2158,7 +2158,7 @@ static void Tests()
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
uint32_t *bitset = all_bitflips_bitarray[odd_even];
|
||||
if (!test_bit24(bitset, test_state[odd_even])) {
|
||||
printf("\nBUG: known target key's %s state is not member of all_bitflips_bitarray!\n",
|
||||
PrintAndLogEx(NORMAL, "\nBUG: known target key's %s state is not member of all_bitflips_bitarray!\n",
|
||||
odd_even==EVEN_STATE?"even":"odd ");
|
||||
}
|
||||
}
|
||||
|
|
@ -2172,7 +2172,7 @@ static void Tests2(void)
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
uint32_t *bitset = nonces[best_first_byte_smallest_bitarray].states_bitarray[odd_even];
|
||||
if (!test_bit24(bitset, test_state[odd_even])) {
|
||||
printf("\nBUG: known target key's %s state is not member of first nonce byte's (0x%02x) states_bitarray!\n",
|
||||
PrintAndLogEx(NORMAL, "\nBUG: known target key's %s state is not member of first nonce byte's (0x%02x) states_bitarray!\n",
|
||||
odd_even==EVEN_STATE?"even":"odd ",
|
||||
best_first_byte_smallest_bitarray);
|
||||
}
|
||||
|
|
@ -2183,7 +2183,7 @@ static void Tests2(void)
|
|||
for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
|
||||
uint32_t *bitset = all_bitflips_bitarray[odd_even];
|
||||
if (!test_bit24(bitset, test_state[odd_even])) {
|
||||
printf("\nBUG: known target key's %s state is not member of all_bitflips_bitarray!\n",
|
||||
PrintAndLogEx(NORMAL, "\nBUG: known target key's %s state is not member of all_bitflips_bitarray!\n",
|
||||
odd_even==EVEN_STATE?"even":"odd ");
|
||||
}
|
||||
}
|
||||
|
|
@ -2219,7 +2219,7 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
|
|||
write_stats = true;
|
||||
setlocale(LC_NUMERIC, "");
|
||||
if ((fstats = fopen("hardnested_stats.txt","a")) == NULL) {
|
||||
PrintAndLog("Could not create/open file hardnested_stats.txt");
|
||||
PrintAndLogEx(NORMAL, "Could not create/open file hardnested_stats.txt");
|
||||
return 3;
|
||||
}
|
||||
for (uint32_t i = 0; i < tests; i++) {
|
||||
|
|
@ -2272,8 +2272,8 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
|
|||
for (statelist_t *sl = candidates; sl != NULL; sl = sl->next) {
|
||||
maximum_states += (uint64_t)sl->len[ODD_STATE] * sl->len[EVEN_STATE];
|
||||
}
|
||||
//printf("Number of remaining possible keys: %" PRIu64 " (2^%1.1f)\n", maximum_states, log(maximum_states)/log(2.0));
|
||||
// fprintf("fstats, "%" PRIu64 ";", maximum_states);
|
||||
//PrintAndLogEx(NORMAL, "Number of remaining possible keys: %" PRIu64 " (2^%1.1f)\n", maximum_states, log(maximum_states)/log(2.0));
|
||||
// fPrintAndLogEx(NORMAL, "fstats, "%" PRIu64 ";", maximum_states);
|
||||
best_first_bytes[0] = best_first_byte_smallest_bitarray;
|
||||
pre_XOR_nonces();
|
||||
prepare_bf_test_nonces(nonces, best_first_bytes[0]);
|
||||
|
|
@ -2294,9 +2294,9 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
|
|||
sprintf(progress_text, "(Estimated Sum(a8) is WRONG! Correct Sum(a8) = %" PRIu16 ")", real_sum_a8);
|
||||
hardnested_print_progress(num_acquired_nonces, progress_text, expected_brute_force, 0);
|
||||
}
|
||||
// printf("Estimated remaining states: %" PRIu64 " (2^%1.1f)\n", nonces[best_first_bytes[0]].sum_a8_guess[j].num_states, log(nonces[best_first_bytes[0]].sum_a8_guess[j].num_states)/log(2.0));
|
||||
// PrintAndLogEx(NORMAL, "Estimated remaining states: %" PRIu64 " (2^%1.1f)\n", nonces[best_first_bytes[0]].sum_a8_guess[j].num_states, log(nonces[best_first_bytes[0]].sum_a8_guess[j].num_states)/log(2.0));
|
||||
generate_candidates(first_byte_Sum, nonces[best_first_bytes[0]].sum_a8_guess[j].sum_a8_idx);
|
||||
// printf("Time for generating key candidates list: %1.0f sec (%1.1f sec CPU)\n", difftime(time(NULL), start_time), (float)(msclock() - start_clock)/1000.0);
|
||||
// PrintAndLogEx(NORMAL, "Time for generating key candidates list: %1.0f sec (%1.1f sec CPU)\n", difftime(time(NULL), start_time), (float)(msclock() - start_clock)/1000.0);
|
||||
//hardnested_print_progress(num_acquired_nonces, "Starting brute force...", expected_brute_force, 0);
|
||||
key_found = brute_force(foundkey);
|
||||
free_statelist_cache();
|
||||
|
|
@ -2389,7 +2389,7 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
|
|||
for (statelist_t *sl = candidates; sl != NULL; sl = sl->next) {
|
||||
maximum_states += (uint64_t)sl->len[ODD_STATE] * sl->len[EVEN_STATE];
|
||||
}
|
||||
// printf("Number of remaining possible keys: %" PRIu64 " (2^%1.1f)\n", maximum_states, log(maximum_states)/log(2.0));
|
||||
// PrintAndLogEx(NORMAL, "Number of remaining possible keys: %" PRIu64 " (2^%1.1f)\n", maximum_states, log(maximum_states)/log(2.0));
|
||||
best_first_bytes[0] = best_first_byte_smallest_bitarray;
|
||||
pre_XOR_nonces();
|
||||
prepare_bf_test_nonces(nonces, best_first_bytes[0]);
|
||||
|
|
@ -2410,9 +2410,9 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
|
|||
sprintf(progress_text, "(Estimated Sum(a8) is WRONG! Correct Sum(a8) = %" PRIu16 ")", real_sum_a8);
|
||||
hardnested_print_progress(num_acquired_nonces, progress_text, expected_brute_force, 0);
|
||||
}
|
||||
// printf("Estimated remaining states: %" PRIu64 " (2^%1.1f)\n", nonces[best_first_bytes[0]].sum_a8_guess[j].num_states, log(nonces[best_first_bytes[0]].sum_a8_guess[j].num_states)/log(2.0));
|
||||
// PrintAndLogEx(NORMAL, "Estimated remaining states: %" PRIu64 " (2^%1.1f)\n", nonces[best_first_bytes[0]].sum_a8_guess[j].num_states, log(nonces[best_first_bytes[0]].sum_a8_guess[j].num_states)/log(2.0));
|
||||
generate_candidates(first_byte_Sum, nonces[best_first_bytes[0]].sum_a8_guess[j].sum_a8_idx);
|
||||
// printf("Time for generating key candidates list: %1.0f sec (%1.1f sec CPU)\n", difftime(time(NULL), start_time), (float)(msclock() - start_clock)/1000.0);
|
||||
// PrintAndLogEx(NORMAL, "Time for generating key candidates list: %1.0f sec (%1.1f sec CPU)\n", difftime(time(NULL), start_time), (float)(msclock() - start_clock)/1000.0);
|
||||
//hardnested_print_progress(num_acquired_nonces, "Starting brute force...", expected_brute_force, 0);
|
||||
key_found = brute_force(foundkey);
|
||||
free_statelist_cache();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue