// return that.
//-----------------------------------------------------------------------------
static int ReadAdc(int ch)
-{
- uint32_t d;
-
- AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
- AT91C_BASE_ADC->ADC_MR =
- ADC_MODE_PRESCALE(63 /* was 32 */) | // ADC_CLK = MCK / ((63+1) * 2) = 48MHz / 128 = 375kHz
- ADC_MODE_STARTUP_TIME(1 /* was 16 */) | // Startup Time = (1+1) * 8 / ADC_CLK = 16 / 375kHz = 42,7us Note: must be > 20us
- ADC_MODE_SAMPLE_HOLD_TIME(15 /* was 8 */); // Sample & Hold Time SHTIM = 15 / ADC_CLK = 15 / 375kHz = 40us
-
+{
// Note: ADC_MODE_PRESCALE and ADC_MODE_SAMPLE_HOLD_TIME are set to the maximum allowed value.
- // Both AMPL_LO and AMPL_HI are very high impedance (10MOhm) outputs, the input capacitance of the ADC is 12pF (typical). This results in a time constant
- // of RC = 10MOhm * 12pF = 120us. Even after the maximum configurable sample&hold time of 40us the input capacitor will not be fully charged.
+ // AMPL_HI is are high impedance (10MOhm || 1MOhm) output, the input capacitance of the ADC is 12pF (typical). This results in a time constant
+ // of RC = (0.91MOhm) * 12pF = 10.9us. Even after the maximum configurable sample&hold time of 40us the input capacitor will not be fully charged.
//
// The maths are:
// If there is a voltage v_in at the input, the voltage v_cap at the capacitor (this is what we are measuring) will be
//
- // v_cap = v_in * (1 - exp(-RC/SHTIM)) = v_in * (1 - exp(-3)) = v_in * 0,95 (i.e. an error of 5%)
- //
- // Note: with the "historic" values in the comments above, the error was 34% !!!
-
- AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
+ // v_cap = v_in * (1 - exp(-SHTIM/RC)) = v_in * (1 - exp(-40us/10.9us)) = v_in * 0,97 (i.e. an error of 3%)
- AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
+ AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
+ AT91C_BASE_ADC->ADC_MR =
+ ADC_MODE_PRESCALE(63) | // ADC_CLK = MCK / ((63+1) * 2) = 48MHz / 128 = 375kHz
+ ADC_MODE_STARTUP_TIME(1) | // Startup Time = (1+1) * 8 / ADC_CLK = 16 / 375kHz = 42,7us Note: must be > 20us
+ ADC_MODE_SAMPLE_HOLD_TIME(15); // Sample & Hold Time SHTIM = 15 / ADC_CLK = 15 / 375kHz = 40us
- while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch)))
- ;
- d = AT91C_BASE_ADC->ADC_CDR[ch];
+ AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
+ AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
- return d;
+ while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch))) {};
+
+ return AT91C_BASE_ADC->ADC_CDR[ch];
}
int AvgAdc(int ch) // was static - merlok
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
+ SpinDelay(50);
+
for (i=255; i>=19; i--) {
WDT_HIT();
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
if (i==95) *vLf125 = adcval; // voltage at 125Khz
if (i==89) *vLf134 = adcval; // voltage at 134Khz
- LF_Results[i] = adcval>>8; // scale int to fit in byte for graphing purposes
+ LF_Results[i] = adcval >> 9; // scale int to fit in byte for graphing purposes
if(LF_Results[i] > peak) {
*peakv = adcval;
peak = LF_Results[i];
for(uint32_t sniffCounter = 0; true; ) {
if(BUTTON_PRESS()) {
- DbpString("cancelled by button");
+ DbpString("Canceled by button.");
break;
}
} // main cycle
- DbpString("COMMAND FINISHED");
+ DbpString("COMMAND FINISHED.");
FpgaDisableSscDma();
MfSniffEnd();
#include "parity.h"\r
#include "crc.h"\r
\r
+#define HARDNESTED_AUTHENTICATION_TIMEOUT 848 // card times out 1ms after wrong authentication (according to NXP documentation)\r
+#define HARDNESTED_PRE_AUTHENTICATION_LEADTIME 400 // some (non standard) cards need a pause after select before they are ready for first authentication \r
+\r
// the block number for the ISO14443-4 PCB\r
static uint8_t pcb_blocknum = 0;\r
// Deselect card by sending a s-block. the crc is precalced for speed\r
}\r
\r
if (slow) {\r
- timeout = GetCountSspClk() + PRE_AUTHENTICATION_LEADTIME;\r
+ timeout = GetCountSspClk() + HARDNESTED_PRE_AUTHENTICATION_LEADTIME;\r
while(GetCountSspClk() < timeout);\r
}\r
\r
continue;\r
}\r
\r
- // send a dummy response in order to trigger the cards authentication failure timeout\r
- uint8_t dummy_answer[8] = {0};\r
- ReaderTransmit(dummy_answer, 8, NULL);\r
+ // send an incomplete dummy response in order to trigger the card's authentication failure timeout\r
+ uint8_t dummy_answer[1] = {0};\r
+ ReaderTransmit(dummy_answer, 1, NULL);\r
\r
+ timeout = GetCountSspClk() + HARDNESTED_AUTHENTICATION_TIMEOUT;\r
+ \r
num_nonces++;\r
if (num_nonces % 2) {\r
memcpy(buf+i, receivedAnswer, 4);\r
i += 9;\r
}\r
\r
+ // wait for the card to become ready again\r
+ while(GetCountSspClk() < timeout);\r
+\r
}\r
\r
LED_C_OFF();\r
#define CRYPT_REQUEST 2\r
#define AUTH_FIRST 0 \r
#define AUTH_NESTED 2\r
-#define AUTHENTICATION_TIMEOUT 848 // card times out 1ms after wrong authentication (according to NXP documentation)\r
-#define PRE_AUTHENTICATION_LEADTIME 400 // some (non standard) cards need a pause after select before they are ready for first authentication\r
\r
// mifare 4bit card answers\r
#define CARD_ACK 0x0A // 1010 - ACK\r
static int CmdHelp(const char *Cmd);
static int waitCmd(uint8_t iLen);
+// structure and database for uid -> tagtype lookups
+typedef struct {
+ uint8_t uid;
+ char* desc;
+} manufactureName;
-const manufactureName manufactureMapping[] = {
+static const manufactureName manufactureMapping[] = {
// ID, "Vendor Country"
{ 0x01, "Motorola UK" },
{ 0x02, "ST Microelectronics SA France" },
break;
case 'x':
case 'X':
- cm = cm - ISO14A_CONNECT;
+ cm &= ~ISO14A_CONNECT;
break;
default:
PrintAndLog("Unknown command.");
PrintAndLog(" UID : %s", sprint_hex(card.uid, card.uidlen));
PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
- PrintAndLog(" SAK : %02x [%d]", card.sak, resp.arg[0]);
+ PrintAndLog(" SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
if(card.ats_len >= 3) { // a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
}
PrintAndLog(" UID : %s", sprint_hex(card.uid, card.uidlen));
PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
- PrintAndLog(" SAK : %02x [%d]", card.sak, resp.arg[0]);
+ PrintAndLog(" SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
bool isMifareClassic = true;
switch (card.sak) {
#include <stdint.h>
#include <stdbool.h>
-// structure and database for uid -> tagtype lookups
-typedef struct {
- uint8_t uid;
- char* desc;
-} manufactureName;
-
int CmdHF14A(const char *Cmd);
int CmdHF14AList(const char *Cmd);
int CmdHF14AMifare(const char *Cmd);
#include "mifarehost.h"\r
#include "mifare.h"\r
#include "mfkey.h"\r
+#include "hardnested/hardnested_bf_core.h"\r
\r
#define NESTED_SECTOR_RETRY 10 // how often we try mfested() until we give up\r
\r
PrintAndLog(" w: Acquire nonces and write them to binary file nonces.bin");\r
PrintAndLog(" s: Slower acquisition (required by some non standard cards)");\r
PrintAndLog(" r: Read nonces.bin and start attack");\r
+ PrintAndLog(" iX: set type of SIMD instructions. Without this flag programs autodetect it.");\r
+ PrintAndLog(" i5: AVX512");\r
+ PrintAndLog(" i2: AVX2");\r
+ PrintAndLog(" ia: AVX");\r
+ PrintAndLog(" is: SSE2");\r
+ PrintAndLog(" im: MMX");\r
+ PrintAndLog(" in: none (use CPU regular instruction set)");\r
PrintAndLog(" ");\r
PrintAndLog(" sample1: hf mf hardnested 0 A FFFFFFFFFFFF 4 A");\r
PrintAndLog(" sample2: hf mf hardnested 0 A FFFFFFFFFFFF 4 A w");\r
int tests = 0;\r
\r
\r
+ uint16_t iindx = 0;\r
if (ctmp == 'R' || ctmp == 'r') {\r
nonce_file_read = true;\r
+ iindx = 1;\r
if (!param_gethex(Cmd, 1, trgkey, 12)) {\r
know_target_key = true;\r
+ iindx = 2;\r
}\r
} else if (ctmp == 'T' || ctmp == 't') {\r
tests = param_get32ex(Cmd, 1, 100, 10);\r
+ iindx = 2;\r
if (!param_gethex(Cmd, 2, trgkey, 12)) {\r
know_target_key = true;\r
+ iindx = 3;\r
}\r
} else {\r
blockNo = param_get8(Cmd, 0);\r
know_target_key = true;\r
i++;\r
}\r
+ iindx = i;\r
\r
while ((ctmp = param_getchar(Cmd, i))) {\r
if (ctmp == 's' || ctmp == 'S') {\r
slow = true;\r
} else if (ctmp == 'w' || ctmp == 'W') {\r
nonce_file_write = true;\r
+ } else if (param_getlength(Cmd, i) == 2 && ctmp == 'i') {\r
+ iindx = i;\r
} else {\r
- PrintAndLog("Possible options are w and/or s");\r
+ PrintAndLog("Possible options are w , s and/or iX");\r
return 1;\r
}\r
i++;\r
}\r
}\r
+ \r
+ SetSIMDInstr(SIMD_AUTO);\r
+ if (iindx > 0) {\r
+ while ((ctmp = param_getchar(Cmd, iindx))) {\r
+ if (param_getlength(Cmd, iindx) == 2 && ctmp == 'i') {\r
+ switch(param_getchar_indx(Cmd, 1, iindx)) {\r
+ case '5':\r
+ SetSIMDInstr(SIMD_AVX512);\r
+ break;\r
+ case '2':\r
+ SetSIMDInstr(SIMD_AVX2);\r
+ break;\r
+ case 'a':\r
+ SetSIMDInstr(SIMD_AVX);\r
+ break;\r
+ case 's':\r
+ SetSIMDInstr(SIMD_SSE2);\r
+ break;\r
+ case 'm':\r
+ SetSIMDInstr(SIMD_MMX);\r
+ break;\r
+ case 'n':\r
+ SetSIMDInstr(SIMD_NONE);\r
+ break;\r
+ default:\r
+ PrintAndLog("Unknown SIMD type. %c", param_getchar_indx(Cmd, 1, iindx));\r
+ return 1;\r
+ }\r
+ }\r
+ iindx++;\r
+ } \r
+ }\r
\r
PrintAndLog("--target block no:%3d, target key type:%c, known target key: 0x%02x%02x%02x%02x%02x%02x%s, file action: %s, Slow: %s, Tests: %d ",\r
trgBlockNo,\r
}\r
\r
UsbCommand resp;\r
- if (WaitForResponseTimeout(CMD_ACK,&resp,2000)) {\r
+ if (WaitForResponseTimeoutW(CMD_ACK, &resp, 2000, false)) {\r
res = resp.arg[0] & 0xff;\r
uint16_t traceLen = resp.arg[1];\r
len = resp.arg[2];\r
\r
if (res == 0) { // we are done\r
- free(buf);\r
- return 0;\r
+ break;\r
}\r
\r
if (res == 1) { // there is (more) data to be transferred\r
} // while (true)\r
\r
free(buf);\r
+ \r
+ msleep(300); // wait for exiting arm side.\r
+ PrintAndLog("Done.");\r
return 0;\r
}\r
\r
#include "crapto1/crapto1.h"
#include "parity.h"
#include "hardnested/hardnested_bruteforce.h"
+#include "hardnested/hardnested_bf_core.h"
#include "hardnested/hardnested_bitarray_core.h"
#include "zlib.h"
static void get_SIMD_instruction_set(char* instruction_set) {
-#if defined (__i386__) || defined (__x86_64__)
- #if !defined(__APPLE__) || (defined(__APPLE__) && (__clang_major__ > 8 || __clang_major__ == 8 && __clang_minor__ >= 1))
- #if (__GNUC__ >= 5) && (__GNUC__ > 5 || __GNUC_MINOR__ > 2)
- if (__builtin_cpu_supports("avx512f")) strcpy(instruction_set, "AVX512F");
- else if (__builtin_cpu_supports("avx2")) strcpy(instruction_set, "AVX2");
- #else
- if (__builtin_cpu_supports("avx2")) strcpy(instruction_set, "AVX2");
- #endif
- else if (__builtin_cpu_supports("avx")) strcpy(instruction_set, "AVX");
- else if (__builtin_cpu_supports("sse2")) strcpy(instruction_set, "SSE2");
- else if (__builtin_cpu_supports("mmx")) strcpy(instruction_set, "MMX");
- else
- #endif
-#endif
- strcpy(instruction_set, "no");
+ switch(GetSIMDInstrAuto()) {
+ case SIMD_AVX512:
+ strcpy(instruction_set, "AVX512F");
+ break;
+ case SIMD_AVX2:
+ strcpy(instruction_set, "AVX2");
+ break;
+ case SIMD_AVX:
+ strcpy(instruction_set, "AVX");
+ break;
+ case SIMD_SSE2:
+ strcpy(instruction_set, "SSE2");
+ break;
+ case SIMD_MMX:
+ strcpy(instruction_set, "MMX");
+ break;
+ default:
+ strcpy(instruction_set, "no");
+ break;
+ }
}
static void print_progress_header(void) {
char progress_text[80];
- char instr_set[12] = "";
+ char instr_set[12] = {0};
get_SIMD_instruction_set(instr_set);
sprintf(progress_text, "Start using %d threads and %s SIMD core", num_CPUs(), instr_set);
PrintAndLog("\n\n");
int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *trgkey, bool nonce_file_read, bool nonce_file_write, bool slow, int tests)
{
char progress_text[80];
+
+ char instr_set[12] = {0};
+ get_SIMD_instruction_set(instr_set);
+ PrintAndLog("Using %s SIMD core.", instr_set);
srand((unsigned) time(NULL));
brute_force_per_second = brute_force_benchmark();
res = rsa_public(&cp->ctx, buf, result);
if(res) {
- printf("RSA encrypt failed. Error: %x data len: %d key len: %d\n", res * -1, len, keylen);
+ printf("RSA encrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
return NULL;
}
res = rsa_private(&cp->ctx, buf, result); // CHECK???
if(res) {
- printf("RSA decrypt failed. Error: %x data len: %d key len: %d\n", res * -1, len, keylen);
+ printf("RSA decrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
return NULL;
}
}
if (cert_tlv->len != enc_pk->mlen) {
- printf("ERROR: Certificate length (%d) not equal key length (%d)\n", cert_tlv->len, enc_pk->mlen);
+ printf("ERROR: Certificate length (%zd) not equal key length (%zd)\n", cert_tlv->len, enc_pk->mlen);
return NULL;
}
kcp = crypto_pk_open(enc_pk->pk_algo,
un_tlv,
NULL);
if (!data || data_len < 3) {
- printf("ERROR: can't decode message. len %d\n", data_len);
+ printf("ERROR: can't decode message. len %zd\n", data_len);
return NULL;
}
tmp = crypto_pk_get_parameter(pubk, 0, &tmp_len);
if (tmp_len != sizeof(pk_N) || memcmp(tmp, pk_N, tmp_len)) {
- fprintf(stderr, "ERROR: crypto_pk_get_parameter(0) Modulus. param len %d len %d\n", tmp_len, sizeof(pk_N));
+ fprintf(stderr, "ERROR: crypto_pk_get_parameter(0) Modulus. param len %zd len %zd\n", tmp_len, sizeof(pk_N));
free(tmp);
goto close_pub;
}
tmp = crypto_pk_get_parameter(privk, 0, &tmp_len);
if (tmp_len != sizeof(pk_N) || memcmp(tmp, pk_N, tmp_len)) {
- fprintf(stderr, "ERROR: crypto_pk_get_parameter(0) Modulus. param len %d len %d\n", tmp_len, sizeof(pk_N));
+ fprintf(stderr, "ERROR: crypto_pk_get_parameter(0) Modulus. param len %zd len %zd\n", tmp_len, sizeof(pk_N));
free(tmp);
goto close;
}
crack_states_bitsliced_t *crack_states_bitsliced_function_p = &crack_states_bitsliced_dispatch;
bitslice_test_nonces_t *bitslice_test_nonces_function_p = &bitslice_test_nonces_dispatch;
-// determine the available instruction set at runtime and call the correct function
-const uint64_t crack_states_bitsliced_dispatch(uint32_t cuid, uint8_t *best_first_bytes, statelist_t *p, uint32_t *keys_found, uint64_t *num_keys_tested, uint32_t nonces_to_bruteforce, uint8_t *bf_test_nonce_2nd_byte, noncelist_t *nonces) {
+static SIMDExecInstr intSIMDInstr = SIMD_AUTO;
+
+void SetSIMDInstr(SIMDExecInstr instr) {
+ intSIMDInstr = instr;
+
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_dispatch;
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_dispatch;
+}
+
+SIMDExecInstr GetSIMDInstr() {
+ SIMDExecInstr instr = SIMD_NONE;
+
#if defined (__i386__) || defined (__x86_64__)
#if !defined(__APPLE__) || (defined(__APPLE__) && (__clang_major__ > 8 || __clang_major__ == 8 && __clang_minor__ >= 1))
#if (__GNUC__ >= 5) && (__GNUC__ > 5 || __GNUC_MINOR__ > 2)
- if (__builtin_cpu_supports("avx512f")) crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX512;
- else if (__builtin_cpu_supports("avx2")) crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX2;
+ if (__builtin_cpu_supports("avx512f")) instr = SIMD_AVX512;
+ else if (__builtin_cpu_supports("avx2")) instr = SIMD_AVX2;
#else
- if (__builtin_cpu_supports("avx2")) crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX2;
+ if (__builtin_cpu_supports("avx2")) instr = SIMD_AVX2;
#endif
- else if (__builtin_cpu_supports("avx")) crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX;
- else if (__builtin_cpu_supports("sse2")) crack_states_bitsliced_function_p = &crack_states_bitsliced_SSE2;
- else if (__builtin_cpu_supports("mmx")) crack_states_bitsliced_function_p = &crack_states_bitsliced_MMX;
+ else if (__builtin_cpu_supports("avx")) instr = SIMD_AVX;
+ else if (__builtin_cpu_supports("sse2")) instr = SIMD_SSE2;
+ else if (__builtin_cpu_supports("mmx")) instr = SIMD_MMX;
else
#endif
#endif
- crack_states_bitsliced_function_p = &crack_states_bitsliced_NOSIMD;
+ instr = SIMD_NONE;
+
+ return instr;
+}
+
+SIMDExecInstr GetSIMDInstrAuto() {
+ SIMDExecInstr instr = intSIMDInstr;
+ if (instr == SIMD_AUTO)
+ return GetSIMDInstr();
+
+ return instr;
+}
+
+// determine the available instruction set at runtime and call the correct function
+const uint64_t crack_states_bitsliced_dispatch(uint32_t cuid, uint8_t *best_first_bytes, statelist_t *p, uint32_t *keys_found, uint64_t *num_keys_tested, uint32_t nonces_to_bruteforce, uint8_t *bf_test_nonce_2nd_byte, noncelist_t *nonces) {
+ switch(GetSIMDInstrAuto()) {
+#if defined (__i386__) || defined (__x86_64__)
+#if !defined(__APPLE__) || (defined(__APPLE__) && (__clang_major__ > 8 || __clang_major__ == 8 && __clang_minor__ >= 1))
+#if (__GNUC__ >= 5) && (__GNUC__ > 5 || __GNUC_MINOR__ > 2)
+ case SIMD_AVX512:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX512;
+ break;
+#endif
+ case SIMD_AVX2:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX2;
+ break;
+ case SIMD_AVX:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_AVX;
+ break;
+ case SIMD_SSE2:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_SSE2;
+ break;
+ case SIMD_MMX:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_MMX;
+ break;
+#endif
+#endif
+ default:
+ crack_states_bitsliced_function_p = &crack_states_bitsliced_NOSIMD;
+ break;
+ }
// call the most optimized function for this CPU
return (*crack_states_bitsliced_function_p)(cuid, best_first_bytes, p, keys_found, num_keys_tested, nonces_to_bruteforce, bf_test_nonce_2nd_byte, nonces);
}
void bitslice_test_nonces_dispatch(uint32_t nonces_to_bruteforce, uint32_t *bf_test_nonce, uint8_t *bf_test_nonce_par) {
-#if defined (__i386__) || defined (__x86_64__)
- #if !defined(__APPLE__) || (defined(__APPLE__) && (__clang_major__ > 8 || __clang_major__ == 8 && __clang_minor__ >= 1))
- #if (__GNUC__ >= 5) && (__GNUC__ > 5 || __GNUC_MINOR__ > 2)
- if (__builtin_cpu_supports("avx512f")) bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX512;
- else if (__builtin_cpu_supports("avx2")) bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX2;
- #else
- if (__builtin_cpu_supports("avx2")) bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX2;
- #endif
- else if (__builtin_cpu_supports("avx")) bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX;
- else if (__builtin_cpu_supports("sse2")) bitslice_test_nonces_function_p = &bitslice_test_nonces_SSE2;
- else if (__builtin_cpu_supports("mmx")) bitslice_test_nonces_function_p = &bitslice_test_nonces_MMX;
- else
- #endif
+ switch(GetSIMDInstrAuto()) {
+#if defined (__i386__) || defined (__x86_64__)
+#if !defined(__APPLE__) || (defined(__APPLE__) && (__clang_major__ > 8 || __clang_major__ == 8 && __clang_minor__ >= 1))
+#if (__GNUC__ >= 5) && (__GNUC__ > 5 || __GNUC_MINOR__ > 2)
+ case SIMD_AVX512:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX512;
+ break;
+#endif
+ case SIMD_AVX2:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX2;
+ break;
+ case SIMD_AVX:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_AVX;
+ break;
+ case SIMD_SSE2:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_SSE2;
+ break;
+ case SIMD_MMX:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_MMX;
+ break;
+#endif
#endif
- bitslice_test_nonces_function_p = &bitslice_test_nonces_NOSIMD;
+ default:
+ bitslice_test_nonces_function_p = &bitslice_test_nonces_NOSIMD;
+ break;
+ }
// call the most optimized function for this CPU
(*bitslice_test_nonces_function_p)(nonces_to_bruteforce, bf_test_nonce, bf_test_nonce_par);
#include "hardnested_bruteforce.h" // statelist_t
+typedef enum {
+ SIMD_AUTO,
+ SIMD_AVX512,
+ SIMD_AVX2,
+ SIMD_AVX,
+ SIMD_SSE2,
+ SIMD_MMX,
+ SIMD_NONE,
+} SIMDExecInstr;
+extern void SetSIMDInstr(SIMDExecInstr instr);
+extern SIMDExecInstr GetSIMDInstrAuto();
+
extern const uint64_t crack_states_bitsliced(uint32_t cuid, uint8_t *best_first_bytes, statelist_t *p, uint32_t *keys_found, uint64_t *num_keys_tested, uint32_t nonces_to_bruteforce, uint8_t *bf_test_nonces_2nd_byte, noncelist_t *nonces);
extern void bitslice_test_nonces(uint32_t nonces_to_bruteforce, uint32_t *bf_test_nonces, uint8_t *bf_test_nonce_par);
}
-static void* crack_states_thread(void* x){
+static void* __attribute__((force_align_arg_pointer)) crack_states_thread(void* x){
struct arg {
bool silent;
projects / proxmark3-svn / commitdiff