add: 'wiegand commands' - wiegand manipulation like encoding / decoding of credentials. From offical repo (@grauerfuchs)

Adapted and converted to fit this repo.

client/cmdmain.c

@@ -32,6 +32,7 @@
 #include "cmdflashmem.h"  // rdv40 flashmem commands
 #include "cmdsmartcard.h" // rdv40 smart card ISO7816 commands
 #include "cmdusart.h"     // rdv40 FPC USART commands
+#include "cmdwiegand.h"   // wiegand commands
 #include "ui.h"
 #include "util_posix.h"
 
@@ -98,11 +99,12 @@ static command_t CommandTable[] = {
     {"mem",     CmdFlashMem,  IfPm3Flash,              "{ Flash Memory manipulation... }"},
     {"msleep",  CmdMsleep,    AlwaysAvailable,         "Add a pause in milliseconds"},
     {"rem",     CmdRem,       AlwaysAvailable,         "Add text to row in log file"},
-    {"reveng",  CmdRev,       AlwaysAvailable,         "{ Crc calculations from the RevEng software }"},
+    {"reveng",  CmdRev,       AlwaysAvailable,         "{ CRC calculations from RevEng software }"},
     {"sc",      CmdSmartcard, IfPm3Smartcard,          "{ Smart card ISO7816 commands... }"},
     {"script",  CmdScript,    AlwaysAvailable,         "{ Scripting commands }"},
     {"trace",   CmdTrace,     AlwaysAvailable,         "{ Trace manipulation... }"},
     {"usart",   CmdUsart,     IfPm3FpcUsartFromUsb,    "{ USART commands... }"},
+    {"wiegand", CmdWiegand,   AlwaysAvailable,         "{ Wiegand format manipulation... }"},
     {"quit",    CmdQuit,      AlwaysAvailable,         ""},
     {"exit",    CmdQuit,      AlwaysAvailable,         "Exit program"},
     {NULL, NULL, NULL, NULL}

client/cmdwiegand.c

@@ -0,0 +1,205 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2018 iceman <iceman at iuse.se>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Trace commands
+//-----------------------------------------------------------------------------
+#include "cmdwiegand.h"
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include "cmdparser.h"          // command_t
+#include "comms.h"
+#include "pm3_cmd.h"
+#include "protocols.h"
+#include "parity.h"             // oddparity
+#include "cmdhflist.h"          // annotations
+#include "wiegand_formats.h"
+#include "wiegand_formatutils.h"
+#include "util.h" 
+
+static int CmdHelp(const char *Cmd);
+
+static int usage_wiegand_list() {
+    PrintAndLogEx(NORMAL, "List available wiegand formats");
+    return PM3_SUCCESS;
+}
+static int usage_wiegand_encode() {
+    PrintAndLogEx(NORMAL, "Encode wiegand formatted number to raw hex");
+    PrintAndLogEx(NORMAL, "Usage:  wiegand encode [w <format>] [<field> <value (decimal)>] {...}");
+    PrintAndLogEx(NORMAL, "Options:");
+    PrintAndLogEx(NORMAL, "          w <format>       see `wiegand list` for available formats");
+    PrintAndLogEx(NORMAL, "          c <value>        card number");
+    PrintAndLogEx(NORMAL, "          f <value>        facility code");
+    PrintAndLogEx(NORMAL, "          i <value>        issue Level");
+    PrintAndLogEx(NORMAL, "          o <value>        OEM code");
+    PrintAndLogEx(NORMAL, "");
+    PrintAndLogEx(NORMAL, "samples:");
+    PrintAndLogEx(NORMAL, "      wiegand encode w H10301 f 101 c 1337");
+    return PM3_SUCCESS;
+}
+static int usage_wiegand_decode() {
+    PrintAndLogEx(NORMAL, "Decode raw hex to wiegand format");
+    PrintAndLogEx(NORMAL, "Usage:  wiegand decode [id] <p>");
+    PrintAndLogEx(NORMAL, "        p         ignore invalid parity");
+    PrintAndLogEx(NORMAL, "");
+    PrintAndLogEx(NORMAL, "Samples:");
+    PrintAndLogEx(NORMAL, "          wiegand decode 2006f623ae");
+    return PM3_SUCCESS;
+}
+
+void PrintTagId(wiegand_message_t *packed){
+    if (packed->Top != 0) {
+        PrintAndLogEx(SUCCESS, "Card ID: %X%08X%08X",
+            (uint32_t)packed->Top,
+            (uint32_t)packed->Mid,
+            (uint32_t)packed->Bot)
+            ;
+    } else {
+        PrintAndLogEx(SUCCESS, "Card ID: %X%08X",
+            (uint32_t)packed->Mid,
+            (uint32_t)packed->Bot)
+            ; 
+    }
+}
+
+int CmdWiegandList(const char *Cmd) {
+    bool errors = false;
+    char cmdp = 0;
+    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
+        switch (tolower(param_getchar(Cmd, cmdp))) {
+            case 'h':
+                return usage_wiegand_list();
+            default:
+                PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar(Cmd, cmdp));
+                errors = true;
+                break;
+        }
+    }
+    HIDListFormats();
+    return PM3_SUCCESS;
+}
+
+int CmdWiegandEncode(const char *Cmd) {
+
+    int format_idx = -1;
+    char format[16] = {0};
+  
+    wiegand_card_t data;
+    memset(&data, 0, sizeof(wiegand_card_t));
+
+    bool errors = false;
+    char cmdp = 0;
+    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
+        switch (tolower(param_getchar(Cmd, cmdp))) {
+            case 'h':
+                return usage_wiegand_encode();
+            case 'w':
+                param_getstr(Cmd, cmdp + 1, format, sizeof(format));
+                format_idx = HIDFindCardFormat(format);
+                if (format_idx == -1) {
+                    PrintAndLogEx(WARNING, "Unknown format: %s", format);
+                    errors = true;
+                }
+                cmdp += 2;
+                break;
+            case 'i':
+                data.IssueLevel = param_get32ex(Cmd, cmdp + 1, 0, 10);
+                cmdp += 2;
+                break;
+            case 'f':
+                data.FacilityCode = param_get32ex(Cmd, cmdp + 1, 0, 10);
+                cmdp += 2;
+                break;
+            case 'c':
+                data.CardNumber = param_get64ex(Cmd, cmdp + 1, 0, 10);
+                cmdp += 2;
+                break;
+            case 'o':
+                data.OEM = param_get32ex(Cmd, cmdp + 1, 0, 10);
+                cmdp += 2;
+                break;
+            default:
+                PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar(Cmd, cmdp));
+                errors = true;
+                break;
+        }
+    }
+    if (errors || cmdp == 0) return usage_wiegand_encode();
+
+    wiegand_message_t packed;
+    memset(&packed, 0, sizeof(wiegand_message_t));
+    
+    if (HIDPack(format_idx, &data, &packed) == false) {
+        PrintAndLogEx(WARNING, "The card data could not be encoded in the selected format.");
+        return PM3_ESOFT;
+    }
+    
+    PrintTagId(&packed);
+    return PM3_SUCCESS;
+}
+
+int CmdWiegandDecode(const char *Cmd) {
+
+    uint32_t top = 0, mid = 0, bot = 0;
+    bool ignore_parity = false, gothex = false;
+    bool errors = false;
+    char cmdp = 0;
+    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
+        uint32_t strlen = param_getlength(Cmd, cmdp);
+        strlen++; // null termin
+        if ( strlen > 2 ) {
+            char *s = calloc(strlen, sizeof(uint8_t));
+            param_getstr(Cmd, cmdp, s, strlen);
+            hexstring_to_u96(&top, &mid, &bot, s);
+            free(s);
+            gothex = true;
+            cmdp++;
+            continue;
+        }
+        switch (tolower(param_getchar(Cmd, cmdp))) {
+            case 'h':
+                return usage_wiegand_decode();
+            case 'p':
+                ignore_parity = true;
+                cmdp++;
+                break;
+            default:
+                PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar(Cmd, cmdp));
+                errors = true;
+                break;
+        }
+    }
+    if (gothex == false)
+        errors = true;
+    
+    if (errors || cmdp < 1) return usage_wiegand_decode();
+
+    wiegand_message_t packed = initialize_message_object(top, mid, bot);
+    
+    HIDTryUnpack(&packed, ignore_parity);
+    return PM3_SUCCESS;
+}
+
+static command_t CommandTable[] = {
+    {"help",    CmdHelp,           AlwaysAvailable, "This help"},
+    {"list",    CmdWiegandList,    AlwaysAvailable, "List available wiegand formats"},
+    {"encode",  CmdWiegandEncode,  AlwaysAvailable, "Convert "},
+    {"decode",  CmdWiegandDecode,  AlwaysAvailable, "Convert raw hex to wiegand format"},
+    {NULL, NULL, NULL, NULL}
+};
+
+static int CmdHelp(const char *Cmd) {
+    (void)Cmd; // Cmd is not used so far
+    CmdsHelp(CommandTable);
+    return PM3_SUCCESS;
+}
+
+int CmdWiegand(const char *Cmd) {
+    clearCommandBuffer();
+    return CmdsParse(CommandTable, Cmd);
+}

client/cmdwiegand.h

@@ -0,0 +1,20 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2019 iceman <iceman at iuse.se>
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Trace commands
+//-----------------------------------------------------------------------------
+
+#ifndef CMDWIEGAND_H__
+#define CMDWIEGAND_H__
+
+#include "common.h"
+
+int CmdWiegand(const char *Cmd);
+int CmdWiegandList(const char *Cmd);
+int CmdWiegandEncode(const char *Cmd);
+int CmdWiegandDecode(const char *Cmd);
+#endif

client/util.c

@@ -878,3 +878,20 @@ char *strmcopy(const char *buf) {
     }
     return str;
 }
+
+/**
+ * Converts a hex string to component "hi2", "hi" and "lo" 32-bit integers, one nibble
+ * at a time.
+ *
+ * Returns the number of nibbles (4 bits) entered.
+ */
+int hexstring_to_u96(uint32_t* hi2, uint32_t* hi, uint32_t* lo, const char* str) {
+    int n = 0, i = 0;
+
+    while (sscanf(&str[i++], "%1x", &n ) == 1) {
+        *hi2 = (*hi2 << 4) | (*hi >> 28);
+        *hi = (*hi << 4) | (*lo >> 28);
+        *lo = (*lo << 4) | (n & 0xf);
+    }
+    return i - 1;
+}

client/util.h

@@ -98,4 +98,5 @@ void clean_ascii(unsigned char *buf, size_t len);
 void strcleanrn(char *buf, size_t len);
 void strcreplace(char *buf, size_t len, char from, char to);
 char *strmcopy(const char *buf);
+int hexstring_to_u96(uint32_t* hi2, uint32_t* hi, uint32_t* lo, const char* str);
 #endif

client/wiegand_formats.h

@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2018 grauerfuchs
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Wiegand format packing/unpacking routines
+//-----------------------------------------------------------------------------
+
+#ifndef WIEGAND_FORMATS_H__
+#define WIEGAND_FORMATS_H__
+
+#include <strings.h>    // memset
+#include <stdbool.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdio.h>
+#include "cmddata.h"
+#include "wiegand_formatutils.h"
+#include "parity.h" // for parity
+#include "ui.h"
+
+typedef struct {
+  bool hasCardNumber;
+  bool hasFacilityCode;
+  bool hasIssueLevel;
+  bool hasOEMCode;
+  bool hasParity;
+} cardformatdescriptor_t;
+
+// Structure for defined Wiegand card formats available for packing/unpacking
+typedef struct {
+  const char* Name;
+  bool (*Pack)(wiegand_card_t* card, wiegand_message_t* packed);
+  bool (*Unpack)(wiegand_message_t* packed, wiegand_card_t* card);
+  const char* Descrp;
+  cardformatdescriptor_t Fields;
+} cardformat_t;
+
+void HIDListFormats();
+int HIDFindCardFormat(const char *format);
+cardformat_t HIDGetCardFormat(int idx);
+bool HIDPack(int FormatIndex, wiegand_card_t* card, wiegand_message_t* packed);
+bool HIDTryUnpack(wiegand_message_t* packed, bool ignoreParity);
+
+#endif

client/wiegand_formatutils.c

@@ -0,0 +1,185 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2018 grauerfuchs
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Wiegand card format packing/unpacking support functions
+//-----------------------------------------------------------------------------
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include "wiegand_formatutils.h"
+#include "ui.h"
+
+bool get_bit_by_position(wiegand_message_t* data, uint8_t pos){
+  if (pos >= data->Length) return false;
+  pos = (data->Length - pos) - 1; // invert ordering; Indexing goes from 0 to 1. Subtract 1 for weight of bit.
+  bool result = false;
+  if (pos > 95) 
+    result = false;
+  else if (pos > 63)
+    result = (data->Top >> (pos - 64)) & 1;
+  else if (pos > 31)
+    result = (data->Mid >> (pos - 32)) & 1;
+  else
+    result = (data->Bot >> pos) & 1;
+  return result;
+}
+bool set_bit_by_position(wiegand_message_t* data, bool value, uint8_t pos){
+  if (pos >= data->Length) return false;
+  pos = (data->Length - pos) - 1; // invert ordering; Indexing goes from 0 to 1. Subtract 1 for weight of bit.
+  if (pos > 95) {
+    return false;
+  } else if (pos > 63) {
+    if (value)
+      data->Top |= (1 << (pos - 64));
+    else
+      data->Top &= ~(1 << (pos - 64));
+    return true;
+  } else if (pos > 31) {
+    if (value)
+      data->Mid |= (1 << (pos - 32));
+    else
+      data->Mid &= ~(1 << (pos - 32));
+    return true;
+  } else {
+    if (value)
+      data->Bot |= (1 << pos);
+    else
+      data->Bot &= ~(1 << pos);
+    return true;
+  }
+}
+/**
+ * Safeguard the data by doing a manual deep copy
+ * 
+ * At the time of the initial writing, the struct does not contain pointers. That doesn't
+ * mean it won't eventually contain one, however. To prevent memory leaks and erroneous
+ * aliasing, perform the copy function manually instead. Hence, this function.
+ * 
+ * If the definition of the wiegand_message struct changes, this function must also
+ * be updated to match.
+ */
+void message_datacopy(wiegand_message_t* src, wiegand_message_t* dest){
+  dest->Bot = src->Bot;
+  dest->Mid = src->Mid;
+  dest->Top = src->Top;
+  dest->Length = src->Length;
+}
+/**
+ *
+ * Yes, this is horribly inefficient for linear data. 
+ * The current code is a temporary measure to have a working function in place
+ * until all the bugs shaken from the block/chunk version of the code.
+ *
+ */
+uint64_t get_linear_field(wiegand_message_t* data, uint8_t firstBit, uint8_t length){
+  uint64_t result = 0;
+  for (uint8_t i = 0; i < length; i++ ) {
+    result = (result << 1) | get_bit_by_position(data, firstBit + i);
+  }
+  return result;
+}
+bool set_linear_field(wiegand_message_t* data, uint64_t value, uint8_t firstBit, uint8_t length){
+  wiegand_message_t tmpdata;
+  message_datacopy(data, &tmpdata);
+  bool result = true;
+  for (int i = 0; i < length; i++){
+    result &= set_bit_by_position(&tmpdata, (value >> ((length - i) - 1)) & 1, firstBit + i);
+  }
+  if (result) 
+      message_datacopy(&tmpdata, data);
+
+  return result;
+}
+
+uint64_t get_nonlinear_field(wiegand_message_t* data, uint8_t numBits, uint8_t* bits){
+  uint64_t result = 0;
+  for (int i = 0; i < numBits; i++){
+    result = (result << 1) | (get_bit_by_position(data, *(bits+i)) & 1);
+  }
+  return result;
+}
+bool set_nonlinear_field(wiegand_message_t* data, uint64_t value, uint8_t numBits, uint8_t* bits){
+    
+    wiegand_message_t tmpdata;
+    message_datacopy(data, &tmpdata);
+    
+    bool result = true;
+    for (int i = 0; i < numBits; i++){
+        result &= set_bit_by_position(&tmpdata, (value >> ((numBits - i) - 1)) & 1, *(bits + i));
+    }
+    
+    if (result)
+        message_datacopy(&tmpdata, data);
+
+    return result;
+}
+
+uint8_t get_length_from_header(wiegand_message_t* data) {
+  uint8_t len = 0;
+  uint32_t hfmt = 0; // for calculating card length
+  
+  if ((data->Top & 0x000FFFFF) > 0) { // > 64 bits
+    hfmt = data->Top & 0x000FFFFF;
+    len = 64;
+  } else if ((data->Mid & 0xFFFFFFC0) > 0) { // < 63-38 bits
+    hfmt = data->Mid & 0xFFFFFFC0;
+    len = 32;
+  } else if (data->Mid && (data->Mid & 0x00000020) == 0) { // 37 bits;
+    hfmt = 0;
+    len = 37;
+  } else if ((data->Mid & 0x0000001F) > 0){ // 36-32 bits
+  printf("a\n");
+    hfmt = data->Mid & 0x0000001F;
+    len = 32;
+  } else if (data->Top == 0 && data->Mid == 0) { //< 32 bits
+    hfmt = data->Bot;
+    len = 0;
+  } else {
+    hfmt = data->Bot;
+    len = 0;
+  }
+
+  while (hfmt > 1) {
+    hfmt >>= 1;
+    len++;
+  }
+  return len;
+}
+
+wiegand_message_t initialize_message_object(uint32_t top, uint32_t mid, uint32_t bot){
+  wiegand_message_t result;
+  memset(&result, 0, sizeof(wiegand_message_t));
+  
+  result.Top = top;
+  result.Mid = mid;
+  result.Bot = bot;
+  result.Length = get_length_from_header(&result);
+  return result;
+}
+
+bool add_HID_header(wiegand_message_t* data){
+  if (data->Length > 84 || data->Length == 0) return false; // Invalid value
+
+  if (data->Length >= 64){
+    data->Top |= 1 << (data->Length - 64); // leading 1: start bit
+    data->Top |= 0x09e00000; // Extended-length header
+  } else if (data->Length > 37){
+    data->Mid |= 1 << (data->Length - 32); // leading 1: start bit
+    data->Top |= 0x09e00000; // Extended-length header
+  } else if (data->Length == 37){
+    // No header bits added to 37-bit cards
+  } else if (data->Length >= 32){
+    data->Mid |= 0x20; // Bit 37; standard header
+    data->Mid |= 1 << (data->Length - 32); // leading 1: start bit
+  } else {
+    data->Mid |= 0x20; // Bit 37; standard header
+    data->Bot |= 1 << data->Length; // leading 1: start bit
+  }
+  return true;
+}

client/wiegand_formatutils.h

@@ -0,0 +1,49 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2018 grauerfuchs
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Weigand card format packing/unpacking support functions
+//-----------------------------------------------------------------------------
+
+#ifndef WIEGAND_FORMATUTILS_H__
+#define WIEGAND_FORMATUTILS_H__
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+// Structure for packed wiegand messages
+// Always align lowest value (last transmitted) bit to ordinal position 0 (lowest valued bit bottom)
+typedef struct {
+  uint8_t Length;   // Number of encoded bits in wiegand message (excluding headers and preamble)
+  uint32_t Top;     // Bits in x<<64 positions
+  uint32_t Mid;     // Bits in x<<32 positions
+  uint32_t Bot;     // Lowest ordinal positions
+} wiegand_message_t;
+
+// Structure for unpacked wiegand card, like HID prox
+typedef struct {
+  uint32_t FacilityCode;
+  uint64_t CardNumber;
+  uint32_t IssueLevel;
+  uint32_t OEM;
+  bool ParityValid; // Only valid for responses
+} wiegand_card_t;
+
+bool get_bit_by_position(wiegand_message_t* data, uint8_t pos);
+bool set_bit_by_position(wiegand_message_t* data, bool value, uint8_t pos);
+
+uint64_t get_linear_field(wiegand_message_t* data, uint8_t firstBit, uint8_t length);
+bool set_linear_field(wiegand_message_t* data, uint64_t value, uint8_t firstBit, uint8_t length);
+
+uint64_t get_nonlinear_field(wiegand_message_t* data, uint8_t numBits, uint8_t* bits);
+bool set_nonlinear_field(wiegand_message_t* data, uint64_t value, uint8_t numBits, uint8_t* bits);
+
+wiegand_message_t initialize_message_object(uint32_t top, uint32_t mid, uint32_t bot);
+
+bool add_HID_header(wiegand_message_t* data);
+
+#endif