From 86caca5f6bc0dbb8e3f628edbf4937ee8289560e Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 12:45:15 +0200 Subject: [PATCH 1/6] Adding ability to load keys from file Switch -f allows for a file to be provided that contains additional keys --- src/mfoc.c | 66 +++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 53 insertions(+), 13 deletions(-) diff --git a/src/mfoc.c b/src/mfoc.c index ec8ca8e..110b6c0 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -97,22 +97,32 @@ int main(int argc, char *const argv[]) }; - mftag t; - mfreader r; - denonce d = {NULL, 0, DEFAULT_DIST_NR, DEFAULT_TOLERANCE, {0x00, 0x00, 0x00}}; + mftag t; + mfreader r; + denonce d = {NULL, 0, DEFAULT_DIST_NR, DEFAULT_TOLERANCE, {0x00, 0x00, 0x00}}; // Pointers to possible keys - pKeys *pk; - countKeys *ck; + pKeys *pk; + countKeys *ck; // Pointer to already broken keys, except defaults - bKeys *bk; + bKeys *bk; static mifare_param mp, mtmp; static mifare_classic_tag mtDump; mifare_cmd mc; FILE *pfDump = NULL; + + //File pointers for the keyfile + FILE * fp; + char * line = NULL; + size_t len = 0; + ssize_t read; + + //Regexp declarations + static const char *regex = "(?i)([0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])"; + struct slre_cap caps[2]; // Parse command line arguments while ((ch = getopt(argc, argv, "hD:s:BP:T:S:O:k:t:")) != -1) { @@ -136,6 +146,34 @@ int main(int argc, char *const argv[]) // fprintf(stdout, "Tolerance number: %d\n", probes); } break; + case 'f': + if (!(fp = fopen(optarg, "r"))) { + fprintf(stderr, "Cannot open keyfile: %s, exiting\n", optarg); + exit(EXIT_FAILURE); + } + while ((read = getline(&line, &len, fp)) != -1) { + int i, j = 0, str_len = strlen(line); + + while (j < str_len && + (i = slre_match(regex, line + j, str_len - j, caps, 2)) > 0) { + //We've found a key, let's add it to the structure. + p = realloc(defKeys, defKeys_len + 6); + if (!p) { + ERR("Cannot allocate memory for defKeys"); + exit(EXIT_FAILURE); + } + defKeys = p; + memset(defKeys + defKeys_len, 0, 6); + num_to_bytes(strtoll(caps[0].ptr, NULL, 16), 6, defKeys + defKeys_len); + fprintf(stdout, "The custom key 0x%.*s has been added to the default keys\n", caps[0].len, caps[0].ptr); + defKeys_len = defKeys_len + 6; + + j += i; + } + } + if (line) + free(line); + break; case 'k': // Add this key to the default keys p = realloc(defKeys, defKeys_len + 6); @@ -200,8 +238,8 @@ int main(int argc, char *const argv[]) } /* - // wait for tag to appear - for (i=0;!nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) && i < 10; i++) zsleep (100); + // wait for tag to appear + for (i=0;!nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) && i < 10; i++) zsleep (100); */ int tag_count; @@ -661,20 +699,22 @@ error: void usage(FILE *stream, int errno) { - fprintf(stream, "Usage: mfoc [-h] [-k key]... [-P probnum] [-T tolerance] [-O output]\n"); + fprintf(stream, "Usage: mfoc [-h] [-k key] [-f file] ... [-P probnum] [-T tolerance] [-O output]\n"); fprintf(stream, "\n"); fprintf(stream, " h print this help and exit\n"); -// fprintf(stream, " B instead of 'A' dump 'B' keys\n"); +// fprintf(stream, " B instead of 'A' dump 'B' keys\n"); fprintf(stream, " k try the specified key in addition to the default keys\n"); -// fprintf(stream, " D number of distance probes, default is 20\n"); -// fprintf(stream, " S number of sets with keystreams, default is 5\n"); + fprintf(stream, " f parses a file of keys to add in addition to the default keys \n"); +// fprintf(stream, " D number of distance probes, default is 20\n"); +// fprintf(stream, " S number of sets with keystreams, default is 5\n"); fprintf(stream, " P number of probes per sector, instead of default of 20\n"); fprintf(stream, " T nonce tolerance half-range, instead of default of 20\n (i.e., 40 for the total range, in both directions)\n"); -// fprintf(stream, " s specify the list of sectors to crack, for example -s 0,1,3,5\n"); +// fprintf(stream, " s specify the list of sectors to crack, for example -s 0,1,3,5\n"); fprintf(stream, " O file in which the card contents will be written (REQUIRED)\n"); fprintf(stream, "\n"); fprintf(stream, "Example: mfoc -O mycard.mfd\n"); fprintf(stream, "Example: mfoc -k ffffeeeedddd -O mycard.mfd\n"); + fprintf(stream, "Example: mfoc -f keys.txt -O mycard.mfd\n"); fprintf(stream, "Example: mfoc -P 50 -T 30 -O mycard.mfd\n"); fprintf(stream, "\n"); fprintf(stream, "This is mfoc version %s.\n", PACKAGE_VERSION); From c346e2af72745377b71fe3af8c8e0a1622cd471e Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 13:18:09 +0200 Subject: [PATCH 2/6] Tweaked in the SLRE libraries --- src/mfoc.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/mfoc.c b/src/mfoc.c index 110b6c0..d21702a 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -52,6 +52,10 @@ #include "nfc-utils.h" #include "mfoc.h" +//SLRE +#include "slre.h" +#include "slre.c" + nfc_context *context; int main(int argc, char *const argv[]) From 7ff1465409b32ac0ac904d7a45440d0afc7a3a45 Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 13:22:08 +0200 Subject: [PATCH 3/6] Added SLRE files --- src/slre.c | 433 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/slre.h | 60 ++++++++ 2 files changed, 493 insertions(+) create mode 100644 src/slre.c create mode 100644 src/slre.h diff --git a/src/slre.c b/src/slre.c new file mode 100644 index 0000000..4a7fd89 --- /dev/null +++ b/src/slre.c @@ -0,0 +1,433 @@ +/* + * Copyright (c) 2004-2013 Sergey Lyubka + * Copyright (c) 2013 Cesanta Software Limited + * All rights reserved + * + * This library is dual-licensed: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. For the terms of this + * license, see . + * + * You are free to use this library under the terms of the GNU General + * Public License, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * Alternatively, you can license this library under a commercial + * license, as set out in . + */ + +#include +#include +#include + +#include "slre.h" + +#define MAX_BRANCHES 100 +#define MAX_BRACKETS 100 +#define FAIL_IF(condition, error_code) if (condition) return (error_code) + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(ar) (sizeof(ar) / sizeof((ar)[0])) +#endif + +#ifdef SLRE_DEBUG +#define DBG(x) printf x +#else +#define DBG(x) +#endif + +struct bracket_pair { + const char *ptr; /* Points to the first char after '(' in regex */ + int len; /* Length of the text between '(' and ')' */ + int branches; /* Index in the branches array for this pair */ + int num_branches; /* Number of '|' in this bracket pair */ +}; + +struct branch { + int bracket_index; /* index for 'struct bracket_pair brackets' */ + /* array defined below */ + const char *schlong; /* points to the '|' character in the regex */ +}; + +struct regex_info { + /* + * Describes all bracket pairs in the regular expression. + * First entry is always present, and grabs the whole regex. + */ + struct bracket_pair brackets[MAX_BRACKETS]; + int num_brackets; + + /* + * Describes alternations ('|' operators) in the regular expression. + * Each branch falls into a specific branch pair. + */ + struct branch branches[MAX_BRANCHES]; + int num_branches; + + /* Array of captures provided by the user */ + struct slre_cap *caps; + int num_caps; + + /* E.g. SLRE_IGNORE_CASE. See enum below */ + int flags; +}; + +static int is_metacharacter(const unsigned char *s) { + static const char *metacharacters = "^$().[]*+?|\\Ssdbfnrtv"; + return strchr(metacharacters, *s) != NULL; +} + +static int op_len(const char *re) { + return re[0] == '\\' && re[1] == 'x' ? 4 : re[0] == '\\' ? 2 : 1; +} + +static int set_len(const char *re, int re_len) { + int len = 0; + + while (len < re_len && re[len] != ']') { + len += op_len(re + len); + } + + return len <= re_len ? len + 1 : -1; +} + +static int get_op_len(const char *re, int re_len) { + return re[0] == '[' ? set_len(re + 1, re_len - 1) + 1 : op_len(re); +} + +static int is_quantifier(const char *re) { + return re[0] == '*' || re[0] == '+' || re[0] == '?'; +} + +static int toi(int x) { + return isdigit(x) ? x - '0' : x - 'W'; +} + +static int hextoi(const unsigned char *s) { + return (toi(tolower(s[0])) << 4) | toi(tolower(s[1])); +} + +static int match_op(const unsigned char *re, const unsigned char *s, + struct regex_info *info) { + int result = 0; + switch (*re) { + case '\\': + /* Metacharacters */ + switch (re[1]) { + case 'S': FAIL_IF(isspace(*s), SLRE_NO_MATCH); result++; break; + case 's': FAIL_IF(!isspace(*s), SLRE_NO_MATCH); result++; break; + case 'd': FAIL_IF(!isdigit(*s), SLRE_NO_MATCH); result++; break; + case 'b': FAIL_IF(*s != '\b', SLRE_NO_MATCH); result++; break; + case 'f': FAIL_IF(*s != '\f', SLRE_NO_MATCH); result++; break; + case 'n': FAIL_IF(*s != '\n', SLRE_NO_MATCH); result++; break; + case 'r': FAIL_IF(*s != '\r', SLRE_NO_MATCH); result++; break; + case 't': FAIL_IF(*s != '\t', SLRE_NO_MATCH); result++; break; + case 'v': FAIL_IF(*s != '\v', SLRE_NO_MATCH); result++; break; + + case 'x': + /* Match byte, \xHH where HH is hexadecimal byte representaion */ + FAIL_IF(hextoi(re + 2) != *s, SLRE_NO_MATCH); + result++; + break; + + default: + /* Valid metacharacter check is done in bar() */ + FAIL_IF(re[1] != s[0], SLRE_NO_MATCH); + result++; + break; + } + break; + + case '|': FAIL_IF(1, SLRE_INTERNAL_ERROR); break; + case '$': FAIL_IF(1, SLRE_NO_MATCH); break; + case '.': result++; break; + + default: + if (info->flags & SLRE_IGNORE_CASE) { + FAIL_IF(tolower(*re) != tolower(*s), SLRE_NO_MATCH); + } else { + FAIL_IF(*re != *s, SLRE_NO_MATCH); + } + result++; + break; + } + + return result; +} + +static int match_set(const char *re, int re_len, const char *s, + struct regex_info *info) { + int len = 0, result = -1, invert = re[0] == '^'; + + if (invert) re++, re_len--; + + while (len <= re_len && re[len] != ']' && result <= 0) { + /* Support character range */ + if (re[len] != '-' && re[len + 1] == '-' && re[len + 2] != ']' && + re[len + 2] != '\0') { + result = info->flags && SLRE_IGNORE_CASE ? + *s >= re[len] && *s <= re[len + 2] : + tolower(*s) >= tolower(re[len]) && tolower(*s) <= tolower(re[len + 2]); + len += 3; + } else { + result = match_op((unsigned char *) re + len, (unsigned char *) s, info); + len += op_len(re + len); + } + } + return (!invert && result > 0) || (invert && result <= 0) ? 1 : -1; +} + +static int doh(const char *s, int s_len, struct regex_info *info, int bi); + +static int bar(const char *re, int re_len, const char *s, int s_len, + struct regex_info *info, int bi) { + /* i is offset in re, j is offset in s, bi is brackets index */ + int i, j, n, step; + + for (i = j = 0; i < re_len && j <= s_len; i += step) { + + /* Handle quantifiers. Get the length of the chunk. */ + step = re[i] == '(' ? info->brackets[bi + 1].len + 2 : + get_op_len(re + i, re_len - i); + + DBG(("%s [%.*s] [%.*s] re_len=%d step=%d i=%d j=%d\n", __func__, + re_len - i, re + i, s_len - j, s + j, re_len, step, i, j)); + + FAIL_IF(is_quantifier(&re[i]), SLRE_UNEXPECTED_QUANTIFIER); + FAIL_IF(step <= 0, SLRE_INVALID_CHARACTER_SET); + + if (i + step < re_len && is_quantifier(re + i + step)) { + DBG(("QUANTIFIER: [%.*s]%c [%.*s]\n", step, re + i, + re[i + step], s_len - j, s + j)); + if (re[i + step] == '?') { + int result = bar(re + i, step, s + j, s_len - j, info, bi); + j += result > 0 ? result : 0; + i++; + } else if (re[i + step] == '+' || re[i + step] == '*') { + int j2 = j, nj = j, n1, n2 = -1, ni, non_greedy = 0; + + /* Points to the regexp code after the quantifier */ + ni = i + step + 1; + if (ni < re_len && re[ni] == '?') { + non_greedy = 1; + ni++; + } + + do { + if ((n1 = bar(re + i, step, s + j2, s_len - j2, info, bi)) > 0) { + j2 += n1; + } + if (re[i + step] == '+' && n1 < 0) break; + + if (ni >= re_len) { + /* After quantifier, there is nothing */ + nj = j2; + } else if ((n2 = bar(re + ni, re_len - ni, s + j2, + s_len - j2, info, bi)) >= 0) { + /* Regex after quantifier matched */ + nj = j2 + n2; + } + if (nj > j && non_greedy) break; + } while (n1 > 0); + + if (n1 < 0 && re[i + step] == '*' && + (n2 = bar(re + ni, re_len - ni, s + j, s_len - j, info, bi)) > 0) { + nj = j + n2; + } + + DBG(("STAR/PLUS END: %d %d %d %d %d\n", j, nj, re_len - ni, n1, n2)); + FAIL_IF(re[i + step] == '+' && nj == j, SLRE_NO_MATCH); + + /* If while loop body above was not executed for the * quantifier, */ + /* make sure the rest of the regex matches */ + FAIL_IF(nj == j && ni < re_len && n2 < 0, SLRE_NO_MATCH); + + /* Returning here cause we've matched the rest of RE already */ + return nj; + } + continue; + } + + if (re[i] == '[') { + n = match_set(re + i + 1, re_len - (i + 2), s + j, info); + DBG(("SET %.*s [%.*s] -> %d\n", step, re + i, s_len - j, s + j, n)); + FAIL_IF(n <= 0, SLRE_NO_MATCH); + j += n; + } else if (re[i] == '(') { + n = SLRE_NO_MATCH; + bi++; + FAIL_IF(bi >= info->num_brackets, SLRE_INTERNAL_ERROR); + DBG(("CAPTURING [%.*s] [%.*s] [%s]\n", + step, re + i, s_len - j, s + j, re + i + step)); + + if (re_len - (i + step) <= 0) { + /* Nothing follows brackets */ + n = doh(s + j, s_len - j, info, bi); + } else { + int j2; + for (j2 = 0; j2 <= s_len - j; j2++) { + if ((n = doh(s + j, s_len - (j + j2), info, bi)) >= 0 && + bar(re + i + step, re_len - (i + step), + s + j + n, s_len - (j + n), info, bi) >= 0) break; + } + } + + DBG(("CAPTURED [%.*s] [%.*s]:%d\n", step, re + i, s_len - j, s + j, n)); + FAIL_IF(n < 0, n); + if (info->caps != NULL) { + info->caps[bi - 1].ptr = s + j; + info->caps[bi - 1].len = n; + } + j += n; + } else if (re[i] == '^') { + FAIL_IF(j != 0, SLRE_NO_MATCH); + } else if (re[i] == '$') { + FAIL_IF(j != s_len, SLRE_NO_MATCH); + } else { + FAIL_IF(j >= s_len, SLRE_NO_MATCH); + n = match_op((unsigned char *) (re + i), (unsigned char *) (s + j), info); + FAIL_IF(n <= 0, n); + j += n; + } + } + + return j; +} + +/* Process branch points */ +static int doh(const char *s, int s_len, struct regex_info *info, int bi) { + const struct bracket_pair *b = &info->brackets[bi]; + int i = 0, len, result; + const char *p; + + do { + p = i == 0 ? b->ptr : info->branches[b->branches + i - 1].schlong + 1; + len = b->num_branches == 0 ? b->len : + i == b->num_branches ? (int) (b->ptr + b->len - p) : + (int) (info->branches[b->branches + i].schlong - p); + DBG(("%s %d %d [%.*s] [%.*s]\n", __func__, bi, i, len, p, s_len, s)); + result = bar(p, len, s, s_len, info, bi); + DBG(("%s <- %d\n", __func__, result)); + } while (result <= 0 && i++ < b->num_branches); /* At least 1 iteration */ + + return result; +} + +static int baz(const char *s, int s_len, struct regex_info *info) { + int i, result = -1, is_anchored = info->brackets[0].ptr[0] == '^'; + + for (i = 0; i <= s_len; i++) { + result = doh(s + i, s_len - i, info, 0); + if (result >= 0) { + result += i; + break; + } + if (is_anchored) break; + } + + return result; +} + +static void setup_branch_points(struct regex_info *info) { + int i, j; + struct branch tmp; + + /* First, sort branches. Must be stable, no qsort. Use bubble algo. */ + for (i = 0; i < info->num_branches; i++) { + for (j = i + 1; j < info->num_branches; j++) { + if (info->branches[i].bracket_index > info->branches[j].bracket_index) { + tmp = info->branches[i]; + info->branches[i] = info->branches[j]; + info->branches[j] = tmp; + } + } + } + + /* + * For each bracket, set their branch points. This way, for every bracket + * (i.e. every chunk of regex) we know all branch points before matching. + */ + for (i = j = 0; i < info->num_brackets; i++) { + info->brackets[i].num_branches = 0; + info->brackets[i].branches = j; + while (j < info->num_branches && info->branches[j].bracket_index == i) { + info->brackets[i].num_branches++; + j++; + } + } +} + +static int foo(const char *re, int re_len, const char *s, int s_len, + struct regex_info *info) { + int i, step, depth = 0; + + /* First bracket captures everything */ + info->brackets[0].ptr = re; + info->brackets[0].len = re_len; + info->num_brackets = 1; + + /* Make a single pass over regex string, memorize brackets and branches */ + for (i = 0; i < re_len; i += step) { + step = get_op_len(re + i, re_len - i); + + if (re[i] == '|') { + FAIL_IF(info->num_branches >= (int) ARRAY_SIZE(info->branches), + SLRE_TOO_MANY_BRANCHES); + info->branches[info->num_branches].bracket_index = + info->brackets[info->num_brackets - 1].len == -1 ? + info->num_brackets - 1 : depth; + info->branches[info->num_branches].schlong = &re[i]; + info->num_branches++; + } else if (re[i] == '\\') { + FAIL_IF(i >= re_len - 1, SLRE_INVALID_METACHARACTER); + if (re[i + 1] == 'x') { + /* Hex digit specification must follow */ + FAIL_IF(re[i + 1] == 'x' && i >= re_len - 3, + SLRE_INVALID_METACHARACTER); + FAIL_IF(re[i + 1] == 'x' && !(isxdigit(re[i + 2]) && + isxdigit(re[i + 3])), SLRE_INVALID_METACHARACTER); + } else { + FAIL_IF(!is_metacharacter((unsigned char *) re + i + 1), + SLRE_INVALID_METACHARACTER); + } + } else if (re[i] == '(') { + FAIL_IF(info->num_brackets >= (int) ARRAY_SIZE(info->brackets), + SLRE_TOO_MANY_BRACKETS); + depth++; /* Order is important here. Depth increments first. */ + info->brackets[info->num_brackets].ptr = re + i + 1; + info->brackets[info->num_brackets].len = -1; + info->num_brackets++; + FAIL_IF(info->num_caps > 0 && info->num_brackets - 1 > info->num_caps, + SLRE_CAPS_ARRAY_TOO_SMALL); + } else if (re[i] == ')') { + int ind = info->brackets[info->num_brackets - 1].len == -1 ? + info->num_brackets - 1 : depth; + info->brackets[ind].len = (int) (&re[i] - info->brackets[ind].ptr); + DBG(("SETTING BRACKET %d [%.*s]\n", + ind, info->brackets[ind].len, info->brackets[ind].ptr)); + depth--; + FAIL_IF(depth < 0, SLRE_UNBALANCED_BRACKETS); + FAIL_IF(i > 0 && re[i - 1] == '(', SLRE_NO_MATCH); + } + } + + FAIL_IF(depth != 0, SLRE_UNBALANCED_BRACKETS); + setup_branch_points(info); + + return baz(s, s_len, info); +} + +int slre_match(const char *regexp, const char *s, int s_len, + struct slre_cap *caps, int num_caps, int flags) { + struct regex_info info; + + /* Initialize info structure */ + info.flags = flags; + info.num_brackets = info.num_branches = 0; + info.num_caps = num_caps; + info.caps = caps; + + DBG(("========================> [%s] [%.*s]\n", regexp, s_len, s)); + return foo(regexp, (int) strlen(regexp), s, s_len, &info); +} diff --git a/src/slre.h b/src/slre.h new file mode 100644 index 0000000..8929574 --- /dev/null +++ b/src/slre.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2004-2013 Sergey Lyubka + * Copyright (c) 2013 Cesanta Software Limited + * All rights reserved + * + * This library is dual-licensed: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. For the terms of this + * license, see . + * + * You are free to use this library under the terms of the GNU General + * Public License, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * Alternatively, you can license this library under a commercial + * license, as set out in . + */ + +/* + * This is a regular expression library that implements a subset of Perl RE. + * Please refer to README.md for a detailed reference. + */ + +#ifndef SLRE_HEADER_DEFINED +#define SLRE_HEADER_DEFINED + +#ifdef __cplusplus +extern "C" { +#endif + +struct slre_cap { + const char *ptr; + int len; +}; + + +int slre_match(const char *regexp, const char *buf, int buf_len, + struct slre_cap *caps, int num_caps, int flags); + +/* Possible flags for slre_match() */ +enum { SLRE_IGNORE_CASE = 1 }; + + +/* slre_match() failure codes */ +#define SLRE_NO_MATCH -1 +#define SLRE_UNEXPECTED_QUANTIFIER -2 +#define SLRE_UNBALANCED_BRACKETS -3 +#define SLRE_INTERNAL_ERROR -4 +#define SLRE_INVALID_CHARACTER_SET -5 +#define SLRE_INVALID_METACHARACTER -6 +#define SLRE_CAPS_ARRAY_TOO_SMALL -7 +#define SLRE_TOO_MANY_BRANCHES -8 +#define SLRE_TOO_MANY_BRACKETS -9 + +#ifdef __cplusplus +} +#endif + +#endif /* SLRE_HEADER_DEFINED */ From eff3dc0d5f17a21420ec0de8f9c6f6cc5fd178b7 Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 13:25:43 +0200 Subject: [PATCH 4/6] Updated SLRE syntax to comply with new version --- src/mfoc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/mfoc.c b/src/mfoc.c index d21702a..2c2df23 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -125,7 +125,7 @@ int main(int argc, char *const argv[]) ssize_t read; //Regexp declarations - static const char *regex = "(?i)([0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])"; + static const char *regex = "(?i)([0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F])"; struct slre_cap caps[2]; // Parse command line arguments @@ -159,7 +159,7 @@ int main(int argc, char *const argv[]) int i, j = 0, str_len = strlen(line); while (j < str_len && - (i = slre_match(regex, line + j, str_len - j, caps, 2)) > 0) { + (i = slre_match(regex, line + j, str_len - j, caps, 2, 0)) > 0) { //We've found a key, let's add it to the structure. p = realloc(defKeys, defKeys_len + 6); if (!p) { From 0976e6f28575d77a830ff27e0330cc2fb0453b3a Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 13:28:50 +0200 Subject: [PATCH 5/6] Added -f to CL arguments --- src/mfoc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mfoc.c b/src/mfoc.c index 2c2df23..c03446a 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -129,7 +129,7 @@ int main(int argc, char *const argv[]) struct slre_cap caps[2]; // Parse command line arguments - while ((ch = getopt(argc, argv, "hD:s:BP:T:S:O:k:t:")) != -1) { + while ((ch = getopt(argc, argv, "hD:s:BP:T:S:O:k:t:f:")) != -1) { switch (ch) { case 'P': // Number of probes From 51bae1e1c852a121a154da63ac1c57d312fad996 Mon Sep 17 00:00:00 2001 From: Simon Yorkston Date: Wed, 15 Apr 2015 14:24:55 +0200 Subject: [PATCH 6/6] Final tweaks to regexp --- src/mfoc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/mfoc.c b/src/mfoc.c index c03446a..1caf290 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -125,7 +125,7 @@ int main(int argc, char *const argv[]) ssize_t read; //Regexp declarations - static const char *regex = "(?i)([0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F])"; + static const char *regex = "([0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])"; struct slre_cap caps[2]; // Parse command line arguments @@ -159,7 +159,7 @@ int main(int argc, char *const argv[]) int i, j = 0, str_len = strlen(line); while (j < str_len && - (i = slre_match(regex, line + j, str_len - j, caps, 2, 0)) > 0) { + (i = slre_match(regex, line + j, str_len - j, caps, 500, 1)) > 0) { //We've found a key, let's add it to the structure. p = realloc(defKeys, defKeys_len + 6); if (!p) {