FIX: "hf mf hardnested" merging of @matrix commit bd8249afec

client/cmdhfmfhard.c

@@ -17,8 +17,7 @@
 
 #define CONFIDENCE_THRESHOLD	0.95		// Collect nonces until we are certain enough that the following brute force is successfull
 #define GOOD_BYTES_REQUIRED	13		// default 28, could be smaller == faster
-#define MIN_NONCES_REQUIRED	4000		// 4000-5000 could be good
+#define NONCES_THRESHOLD	5000		// every N nonces check if we can crack the key
-#define NONCES_TRIGGER		2500		// every 2500 nonces check if we can crack the key
 #define CRACKING_THRESHOLD	39.00f		// as 2^39
 
 #define END_OF_LIST_MARKER		0xFFFFFFFF
@@ -114,12 +113,8 @@ static partial_indexed_statelist_t partial_statelist[17];
 static partial_indexed_statelist_t statelist_bitflip;
 static statelist_t *candidates = NULL;
 
-bool thread_check_started = false;
-bool thread_check_done = false;
 bool field_off = false;
 
-pthread_t thread_check;
-
 static bool generate_candidates(uint16_t, uint16_t);
 static bool brute_force(void);
 
@@ -260,7 +255,7 @@ static double p_hypergeometric(uint16_t N, uint16_t K, uint16_t n, uint16_t k)
 		for (int16_t i = N; i >= N-n+1; i--) {
 			log_result -= log(i);
 		}
-		return (log_result > 0) ? exp(log_result) : 0.0;
+		return exp(log_result);
 	} else {
 		if (n-k == N-K) {	// special case. The published recursion below would fail with a divide by zero exception
 			double log_result = 0.0;
@@ -270,7 +265,7 @@ static double p_hypergeometric(uint16_t N, uint16_t K, uint16_t n, uint16_t k)
 			for (int16_t i = K+1; i <= N; i++) {
 				log_result -= log(i);
 			}
-			return (log_result > 0) ? exp(log_result) : 0.0;
+			return exp(log_result);
 		} else { 			// recursion
 			return (p_hypergeometric(N, K, n, k-1) * (K-k+1) * (n-k+1) / (k * (N-K-n+k)));
 		}
@@ -284,9 +279,6 @@ static float sum_probability(uint16_t K, uint16_t n, uint16_t k)
 	if (k > K || p_K[K] == 0.0) return 0.0;
 
 	double p_T_is_k_when_S_is_K = p_hypergeometric(N, K, n, k);
-	
-	if (p_T_is_k_when_S_is_K == 0.0) return 0.0;
-	
 	double p_S_is_K = p_K[K];
 	double p_T_is_k = 0;
 	for (uint16_t i = 0; i <= 256; i++) {
@@ -564,9 +556,11 @@ static void sort_best_first_bytes(void)
 	}	
 
 	// swap best possible first byte to the pole position
+	if (best_first_byte != 0) {
 	uint16_t temp = best_first_bytes[0];
 	best_first_bytes[0] = best_first_bytes[best_first_byte];
 	best_first_bytes[best_first_byte] = temp;
+	}
 	
 }
 
@@ -774,6 +768,7 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
 		flags |= field_off ? 0x0004 : 0;
 		UsbCommand c = {CMD_MIFARE_ACQUIRE_ENCRYPTED_NONCES, {blockNo + keyType * 0x100, trgBlockNo + trgKeyType * 0x100, flags}};
 		memcpy(c.d.asBytes, key, 6);
+
 		clearCommandBuffer();
 		SendCommand(&c);
 		
@@ -838,15 +833,14 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
 				printf("Acquired %5d nonces (%5d / %5d with distinct bytes 0 and 1). Number of bytes with probability for correctly guessed Sum(a8) > %1.1f%%: %d\n",
 					total_num_nonces,
 					total_added_nonces,
-					(total_added_nonces < MIN_NONCES_REQUIRED) ? MIN_NONCES_REQUIRED : (NONCES_TRIGGER*idx),
+					NONCES_THRESHOLD * idx,
 					CONFIDENCE_THRESHOLD * 100.0,
 					num_good_first_bytes);
 			}
 
-			if (total_added_nonces >= MIN_NONCES_REQUIRED) {
+			if (total_added_nonces >= (NONCES_THRESHOLD * idx))
+			{
 				num_good_first_bytes = estimate_second_byte_sum();
-				if (total_added_nonces > (NONCES_TRIGGER * idx)) {
-			
 					clock_t time1 = clock();
 					bool cracking = generate_candidates(first_byte_Sum, nonces[best_first_bytes[0]].Sum8_guess);
 					time1 = clock() - time1;
@@ -860,8 +854,6 @@ static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_
 				}
 			}
 
-		}
-		
 		if (!initialize) {
 			if (!WaitForResponseTimeout(CMD_ACK, &resp, 3000)) {
 				if (fnonces) fclose(fnonces);
@@ -1314,6 +1306,7 @@ static bool generate_candidates(uint16_t sum_a0, uint16_t sum_a8)
 					for (uint16_t s = 0; s <= 16; s += 2) {
 						if (r*(16-s) + (16-r)*s == sum_a8) {
 							current_candidates = add_more_candidates(current_candidates);
+							if (current_candidates) {
 							// check for the smallest partial statelist. Try this first - it might give 0 candidates 
 							// and eliminate the need to calculate the other part
 							if (MIN(partial_statelist[p].len[ODD_STATE], partial_statelist[r].len[ODD_STATE]) 
@@ -1344,9 +1337,11 @@ static bool generate_candidates(uint16_t sum_a0, uint16_t sum_a8)
 			}
 		}
 	}					
+	}					
 
 	maximum_states = 0;
-	for (statelist_t *sl = candidates; sl != NULL; sl = sl->next) {
+	unsigned int n = 0;
+	for (statelist_t *sl = candidates; sl != NULL && n < 128; sl = sl->next, n++) {
 		maximum_states += (uint64_t)sl->len[ODD_STATE] * sl->len[EVEN_STATE];
 	}
 
@@ -1691,10 +1686,11 @@ static bool brute_force(void)
 
 		// count number of states to go
 		bucket_count = 0;
-		for (statelist_t *p = candidates; p != NULL; p = p->next) {
+		for (statelist_t *p = candidates; p != NULL && bucket_count < 128; p = p->next) {
 			buckets[bucket_count] = p;
 			bucket_count++;
 		}
+		buckets[bucket_count] = NULL;
 
 #ifndef __WIN32
 		thread_count = sysconf(_SC_NPROCESSORS_CONF);
@@ -1787,8 +1783,10 @@ int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBloc
 			if (time1 > 0)
 				PrintAndLog("Time for generating key candidates list: %1.0f seconds", ((float)time1)/CLOCKS_PER_SEC);
 
-			if (cracking)
+			if (cracking || known_target_key != -1) {
 				brute_force();
+			}
+
 		} else { // acquire nonces.
 			uint16_t is_OK = acquire_nonces(blockNo, keyType, key, trgBlockNo, trgKeyType, nonce_file_write, slow);
 			if (is_OK != 0) {