UNTESTED: Add lots of helper functions to get data into / out of saflok formats
* Small, testable functions * `set_` functions return boolean so they can indicate out-of-bounds values and similar failures. * const-correctness for all helper functions Note: The new functions are NOT used extensively yet ... they still need testing. But they should make the code more self-documenting / readable (if somewhat verbose).
This commit is contained in:
1 parent
4ce34c6c1e
commit
319339b4cd
1 file changed
+526
-73
+526
-73
@@ -20,6 +20,8 @@
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <assert.h>
|
||||
#include <inttypes.h>
|
||||
#include <time.h>
|
||||
#include "cliparser.h"
|
||||
#include "cmdparser.h"
|
||||
#include "comms.h"
|
||||
@@ -35,6 +37,7 @@
|
||||
// defining this structure makes it more clear what
|
||||
// is passed around, and avoids the need to pass lengths
|
||||
// to many of the functions.
|
||||
static const uint8_t days_in_month_lookup[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||||
|
||||
// TODO: consider separate structs for encrypted vs. decrypted
|
||||
// for even greater type safety.
|
||||
@@ -47,35 +50,514 @@ typedef struct _saflock_mfc_uid_t {
|
||||
typedef struct _saflok_mfc_key_t {
|
||||
uint8_t key[6];
|
||||
} saflok_mfc_key_t;
|
||||
typedef struct _saflok_mfc_datetime_t {
|
||||
uint16_t year;
|
||||
uint8_t month;
|
||||
uint8_t day;
|
||||
uint8_t hour;
|
||||
uint8_t minute;
|
||||
} saflok_mfc_datetime_t;
|
||||
typedef struct _saflok_mfc_datetime_offset_t {
|
||||
uint8_t years;
|
||||
uint8_t months;
|
||||
uint8_t days;
|
||||
uint8_t hours;
|
||||
uint8_t minutes;
|
||||
} saflok_mfc_datetime_offset_t;
|
||||
|
||||
#define KEY_LENGTH sizeof(saflok_mfc_key_t)
|
||||
|
||||
|
||||
// TODO: define inline helper functions to get/set named fields from saflok_mfc_data_t
|
||||
// Example:
|
||||
// inline uint32_t get_saflok_mfc_card_level(saflok_mfc_data_t *data) {
|
||||
// return extract_bits(data->raw, 0, 4);
|
||||
// }
|
||||
// inline void set_saflok_mfc_card_level(saflok_mfc_data_t *data, uint32_t level) {
|
||||
// insert_bits(data->raw, 0, 4, level);
|
||||
// }
|
||||
|
||||
// insert_bits(data, 0, 4, card_level );
|
||||
// insert_bits(data, 4, 4, card_type );
|
||||
// insert_bits(data, 8, 8, card_id );
|
||||
// insert_bits(data, 16, 2, opening_key );
|
||||
// insert_bits(data, 18, 14, lock_id );
|
||||
// insert_bits(data, 32, 12, pass_number );
|
||||
// insert_bits(data, 44, 12, sequence_and_combination);
|
||||
// insert_bits(data, 56, 1, deadbolt_override );
|
||||
// insert_bits(data, 57, 7, restricted_days );
|
||||
// insert_bits(data, 64, 24, expire_date );
|
||||
// insert_bits(data, 88, 28, card_creation_date );
|
||||
// insert_bits(data, 116, 12, property_id );
|
||||
//
|
||||
// And checksum as simple byte read/write of raw[16]...
|
||||
static uint32_t extract_bits(const saflok_mfc_data_t *data, size_t start_bit, size_t num_bits);
|
||||
static void insert_bits(saflok_mfc_data_t *data, size_t start_bit, size_t num_bits, uint32_t value);
|
||||
|
||||
|
||||
static const uint8_t c_aDecode[256] = {
|
||||
|
||||
#if 1 // getters and setters for each bitfield in saflok_mfc_data_t
|
||||
// TODO: consider update to setter functions to use smaller type for data?
|
||||
// avoiding for this commit, as larger change.
|
||||
//
|
||||
// card_level field is 4 bits
|
||||
// card_type field is 4 bits
|
||||
// card_id field is 8 bits
|
||||
// opening_key field is 2 bits
|
||||
// lock_id field is 14 bits
|
||||
// pass_number field is 12 bits
|
||||
// sequence_and_combination field is 12 bits
|
||||
// deadbolt_override field is 1 bits
|
||||
// restricted_days field is 7 bits
|
||||
// raw_expire_date field is 24 bits -- special set processing needed
|
||||
// raw_card_creation_date field is 28 bits -- special set processing needed
|
||||
// property_id field is 12 bits
|
||||
|
||||
static inline uint8_t get_saflok_mfc_card_level(const saflok_mfc_data_t *data) {
|
||||
return (uint8_t)extract_bits(data, 0, 4);
|
||||
}
|
||||
static inline bool set_saflok_mfc_card_level(saflok_mfc_data_t *data, uint32_t card_level) {
|
||||
if (card_level > 0xFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " card_level out of range (%08x)\n", card_level);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 0, 4, card_level);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t get_saflok_mfc_card_type(const saflok_mfc_data_t *data) {
|
||||
return (uint8_t)extract_bits(data, 4, 4);
|
||||
}
|
||||
static inline bool set_saflok_mfc_card_type(saflok_mfc_data_t *data, uint32_t card_type) {
|
||||
if (card_type > 0xFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " card_type out of range (%08x)\n", card_type);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 4, 4, card_type);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t get_saflok_mfc_card_id(const saflok_mfc_data_t *data) {
|
||||
return (uint8_t)extract_bits(data, 8, 8);
|
||||
}
|
||||
static inline bool set_saflok_mfc_card_id(saflok_mfc_data_t *data, uint32_t card_id) {
|
||||
if (card_id > 0xFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " card_id out of range (%08x)\n", card_id);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 8, 8, card_id);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t get_saflok_mfc_opening_key(const saflok_mfc_data_t *data) {
|
||||
return (uint8_t)extract_bits(data, 16, 2);
|
||||
}
|
||||
static inline bool set_saflok_mfc_opening_key(saflok_mfc_data_t *data, uint32_t opening_key) {
|
||||
if (opening_key > 0x3u) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " opening_key out of range (%08x)\n", opening_key);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 16, 2, opening_key);
|
||||
return true;
|
||||
}
|
||||
static inline uint16_t get_saflok_mfc_lock_id(const saflok_mfc_data_t *data) {
|
||||
return (uint16_t)extract_bits(data, 18, 14);
|
||||
}
|
||||
static inline bool set_saflok_mfc_lock_id(saflok_mfc_data_t *data, uint32_t lock_id) {
|
||||
if (lock_id > 0x3FFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " lock_id out of range (%08x)\n", lock_id);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 18, 14, lock_id);
|
||||
return true;
|
||||
}
|
||||
static inline uint16_t get_saflok_mfc_pass_number(const saflok_mfc_data_t *data) {
|
||||
return (uint16_t)extract_bits(data, 32, 12);
|
||||
}
|
||||
static inline bool set_saflok_mfc_pass_number(saflok_mfc_data_t *data, uint32_t pass_number) {
|
||||
if (pass_number > 0xFFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " pass_number out of range (%08x)\n", pass_number);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 32, 12, pass_number);
|
||||
return true;
|
||||
}
|
||||
static inline uint16_t get_saflok_mfc_sequence_and_combination(const saflok_mfc_data_t *data) {
|
||||
return (uint16_t)extract_bits(data, 44, 12);
|
||||
}
|
||||
static inline bool set_saflok_mfc_sequence_and_combination(saflok_mfc_data_t *data, uint32_t sequence_and_combination) {
|
||||
if (sequence_and_combination > 0xFFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " sequence_and_combination out of range (%08x)\n", sequence_and_combination);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 44, 12, sequence_and_combination);
|
||||
return true;
|
||||
}
|
||||
static inline bool get_saflok_mfc_deadbolt_override(const saflok_mfc_data_t *data) {
|
||||
uint32_t result = extract_bits(data, 56, 1);
|
||||
return (result != 0);
|
||||
}
|
||||
static inline bool set_saflok_mfc_deadbolt_override(saflok_mfc_data_t *data, uint32_t deadbolt_override) {
|
||||
insert_bits(data, 56, 1, deadbolt_override ? 0x1 : 0x0);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t get_saflok_mfc_restricted_days(const saflok_mfc_data_t *data) {
|
||||
return (uint8_t)extract_bits(data, 57, 7);
|
||||
}
|
||||
static inline bool set_saflok_mfc_restricted_days(saflok_mfc_data_t *data, uint32_t restricted_days) {
|
||||
if (restricted_days > 0x7Fu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " restricted_days out of range (%08x)\n", restricted_days);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 57, 7, restricted_days);
|
||||
return true;
|
||||
}
|
||||
static inline uint32_t get_saflok_mfc_raw_interval_date(const saflok_mfc_data_t *data) {
|
||||
return extract_bits(data, 64, 24);
|
||||
}
|
||||
static inline bool set_saflok_mfc_raw_interval_date(saflok_mfc_data_t *data, uint32_t raw_interval_date) {
|
||||
if (raw_interval_date > 0xFFFFFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " raw_interval_date out of range (%08x)\n", raw_interval_date);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 64, 24, raw_interval_date);
|
||||
return true;
|
||||
}
|
||||
static inline uint32_t get_saflok_mfc_raw_card_creation_date(const saflok_mfc_data_t *data) {
|
||||
return extract_bits(data, 88, 28);
|
||||
}
|
||||
static inline bool set_saflok_mfc_raw_card_creation_date(saflok_mfc_data_t *data, uint32_t raw_card_creation_date) {
|
||||
if (raw_card_creation_date > 0x0FFFFFFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " raw_card_creation_date out of range (%08x)\n", raw_card_creation_date);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 88, 28, raw_card_creation_date);
|
||||
return true;
|
||||
}
|
||||
static inline uint16_t get_saflok_mfc_property_id(const saflok_mfc_data_t *data) {
|
||||
return extract_bits(data, 116, 12);
|
||||
}
|
||||
static inline bool set_saflok_mfc_property_id(saflok_mfc_data_t *data, uint32_t property_id) {
|
||||
if (property_id > 0xFFFFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " property_id out of range (%08x)\n", property_id);
|
||||
return false;
|
||||
}
|
||||
insert_bits(data, 116, 12, property_id);
|
||||
return true;
|
||||
}
|
||||
#endif // getters and setters for each bitfield in saflok_mfc_data_t
|
||||
|
||||
#if 1 // helpers for get/set_saflok_mfc_card_creation_date() ... do not call these directly as does not validate...
|
||||
static inline uint16_t _get_saflok_mfc_card_creation_year_impl(const saflok_mfc_data_t *data) {
|
||||
uint8_t creation_year_bits_high = (data->raw[14] & 0xF0u);
|
||||
uint8_t creation_year_bits_low = (data->raw[11] & 0xF0u) >> 4;
|
||||
uint8_t creation_year_bits = creation_year_bits_high | creation_year_bits_low;
|
||||
uint16_t creation_year = 1980u + creation_year_bits; // automatically extends to uint16_t
|
||||
return creation_year;
|
||||
}
|
||||
static inline bool _set_saflok_mfc_card_creation_year_impl(saflok_mfc_data_t *data, uint16_t year) {
|
||||
if (year < 1980u || year > (1980u+0xFFu)) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " year out of range (%u)\n", year);
|
||||
return false;
|
||||
}
|
||||
uint16_t year_bits = year - 1980u;
|
||||
uint8_t creation_year_bits_high = year_bits & 0xF0u;
|
||||
uint8_t creation_year_bits_low = (year_bits & 0x0Fu) << 4;
|
||||
data->raw[14] = (data->raw[14] & 0x0Fu) | creation_year_bits_high;
|
||||
data->raw[11] = (data->raw[11] & 0x0Fu) | creation_year_bits_low;
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_card_creation_month_impl(const saflok_mfc_data_t *data) {
|
||||
// should be in range [1..12] ... value of zero is invalid
|
||||
return (data->raw[11] & 0x0Fu);
|
||||
}
|
||||
static inline bool _set_saflok_mfc_card_creation_month_impl(saflok_mfc_data_t *data, uint8_t month) {
|
||||
if (month < 1 || month > 12) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " month out of range (%u)\n", month);
|
||||
return false;
|
||||
}
|
||||
data->raw[11] = (data->raw[11] & 0xF0u) | (month & 0x0Fu);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_card_creation_day_impl(const saflok_mfc_data_t *data) {
|
||||
return ((data->raw[12] >> 3) & 0x1Fu);
|
||||
}
|
||||
static inline bool _set_saflok_mfc_card_creation_day_impl(saflok_mfc_data_t *data, uint8_t day) {
|
||||
data->raw[12] = (data->raw[12] & 0xE0u) | ((day & 0x1Fu) << 3);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_card_creation_hour_impl(const saflok_mfc_data_t *data) {
|
||||
// low three bits from raw[12]
|
||||
// high two bits from raw[13]
|
||||
return (((data->raw[12] & 0x07u) << 2) | (data->raw[13] >> 6));
|
||||
}
|
||||
static inline bool _set_saflok_mfc_card_creation_hour_impl(saflok_mfc_data_t *data, uint8_t hour) {
|
||||
data->raw[12] = (data->raw[12] & 0xF8u) | ((hour >> 2) & 0x07u);
|
||||
data->raw[13] = (data->raw[13] & 0x3Fu) | ((hour & 0x03u) << 6);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_card_creation_minute_impl(const saflok_mfc_data_t *data) {
|
||||
return (data->raw[13] & 0x3Fu);
|
||||
}
|
||||
static inline bool _set_saflok_mfc_card_creation_minute_impl(saflok_mfc_data_t *data, uint8_t minute) {
|
||||
data->raw[13] = (data->raw[13] & 0xC0u) | (minute & 0x3Fu);
|
||||
return true;
|
||||
}
|
||||
#endif // // helpers for get/set_saflok_mfc_card_creation_date() ... do not call these directly as does not validate...
|
||||
#if 1 // getters and setters for creation date
|
||||
|
||||
static inline bool is_saflok_mfc_datetime_valid(const saflok_mfc_datetime_t *date) {
|
||||
bool result = true;
|
||||
if ((date->year < 1980) || (date->year > (1980u+0xFFu)) ) {
|
||||
PrintAndLogEx(WARNING, "year out of range (%d)\n", date->year);
|
||||
result = false;
|
||||
}
|
||||
if ((date->month < 1) || (date->month > 12)) {
|
||||
PrintAndLogEx(WARNING, "month out of range (%d)\n", date->month);
|
||||
result = false;
|
||||
}
|
||||
uint8_t max_days = days_in_month_lookup[date->month];
|
||||
// Adjust for leap years
|
||||
if ((date->month == 2u) &&
|
||||
(date->year % 4u == 0u) &&
|
||||
((date->year % 100u != 0u) || (date->year % 400u == 0u))
|
||||
) {
|
||||
max_days = 29u;
|
||||
}
|
||||
if ((date->day < 1u) || (date->day > max_days)) {
|
||||
PrintAndLogEx(WARNING, "day out of range (%d) for month %d year %d\n", date->day, date->month, date->year);
|
||||
result = false;
|
||||
}
|
||||
if (date->hour > 23) {
|
||||
PrintAndLogEx(WARNING, "hour out of range (%d)\n", date->hour);
|
||||
result = false;
|
||||
}
|
||||
if (date->minute > 59) {
|
||||
PrintAndLogEx(WARNING, "minute out of range (%d)\n", date->minute);
|
||||
result = false;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
static inline saflok_mfc_datetime_t get_saflok_mfc_card_creation_datetime(
|
||||
const saflok_mfc_data_t *data
|
||||
) {
|
||||
saflok_mfc_datetime_t date = {
|
||||
.year = _get_saflok_mfc_card_creation_year_impl(data),
|
||||
.month = _get_saflok_mfc_card_creation_month_impl(data),
|
||||
.day = _get_saflok_mfc_card_creation_day_impl(data),
|
||||
.hour = _get_saflok_mfc_card_creation_hour_impl(data),
|
||||
.minute = _get_saflok_mfc_card_creation_minute_impl(data)
|
||||
};
|
||||
if (!is_saflok_mfc_datetime_valid(&date)) {
|
||||
PrintAndLogEx(WARNING, "Warning: creation date appears invalid: %04d-%02d-%02dT%02d:%02d\n",
|
||||
date.year, date.month, date.day, date.hour, date.minute
|
||||
);
|
||||
}
|
||||
return date;
|
||||
}
|
||||
static inline bool set_saflok_mfc_card_creation_datetime(saflok_mfc_data_t * data, const saflok_mfc_datetime_t * date) {
|
||||
if (!is_saflok_mfc_datetime_valid(date)) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " creation date is invalid\n");
|
||||
return false;
|
||||
}
|
||||
bool result =
|
||||
_set_saflok_mfc_card_creation_year_impl(data, date->year) &&
|
||||
_set_saflok_mfc_card_creation_month_impl(data, date->month) &&
|
||||
_set_saflok_mfc_card_creation_day_impl(data, date->day) &&
|
||||
_set_saflok_mfc_card_creation_hour_impl(data, date->hour) &&
|
||||
_set_saflok_mfc_card_creation_minute_impl(data, date->minute);
|
||||
if (!result) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " failed to set creation date of %04d-%02d-%02dT%02d:%02d\n",
|
||||
date->year, date->month, date->day, date->hour, date->minute
|
||||
);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
#endif // getters and setters for creation date components
|
||||
#if 1 // helpers for get/set_saflok_mfc_expiration_date()
|
||||
static inline uint8_t _get_saflok_mfc_interval_years_impl(const saflok_mfc_data_t *data) {
|
||||
// supports up to 15 year intervals(!)
|
||||
return (data->raw[8] >> 4);
|
||||
}
|
||||
static inline bool _set_saflok_mfc_interval_years_impl(saflok_mfc_data_t *data, uint32_t years) {
|
||||
if (years > 0xFu) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " interval years out of range (%u)\n", years);
|
||||
return false;
|
||||
}
|
||||
data->raw[8] = (data->raw[8] & 0x0Fu) | ((years & 0xFFu) << 4);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_interval_months_impl(const saflok_mfc_data_t *data) {
|
||||
uint8_t months = data->raw[8] & 0x0Fu;
|
||||
if (months >= 12u) {
|
||||
PrintAndLogEx(WARNING, "Warning: interval months appears invalid (%u)\n", months);
|
||||
}
|
||||
return months;
|
||||
}
|
||||
static inline bool _set_saflok_mfc_interval_months_impl(saflok_mfc_data_t *data, uint8_t months) {
|
||||
if (months >= 12u) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " interval months out of range (%u)\n", months);
|
||||
return false;
|
||||
}
|
||||
data->raw[8] = (data->raw[8] & 0xF0u) | (months & 0x0Fu);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_interval_days_impl(const saflok_mfc_data_t *data) {
|
||||
uint8_t days = (data->raw[9] >> 3) & 0x1Fu;
|
||||
if (days > 31u) {
|
||||
PrintAndLogEx(WARNING, "Warning: interval days appears invalid (%u)\n", days);
|
||||
}
|
||||
return days;
|
||||
}
|
||||
static inline bool _set_saflok_mfc_interval_days_impl(saflok_mfc_data_t *data, uint8_t days) {
|
||||
if (days > 31u) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " interval days out of range (%u)\n", days);
|
||||
return false;
|
||||
}
|
||||
data->raw[9] = (data->raw[9] & 0xC7u) | ((days & 0x1Fu) << 3);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_interval_hours_impl(const saflok_mfc_data_t *data) {
|
||||
// low three bits from raw[9]
|
||||
// top two bits from raw[10]
|
||||
uint8_t hours = ((data->raw[9] & 0x07u) << 2) | (data->raw[10] >> 6);
|
||||
if (hours > 23u) {
|
||||
PrintAndLogEx(WARNING, "Warning: interval hours appears invalid (%u)\n", hours);
|
||||
}
|
||||
return hours;
|
||||
}
|
||||
static inline bool _set_saflok_mfc_interval_hours_impl(saflok_mfc_data_t *data, uint8_t hours) {
|
||||
if (hours > 23u) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " interval hours out of range (%u)\n", hours);
|
||||
return false;
|
||||
}
|
||||
// five bit value split across two bytes:
|
||||
// three MSB go into the low three bits from raw[9]
|
||||
// two LSB go into the top two bits from raw[10]
|
||||
data->raw[9] = (data->raw[9] & 0xF8u) | ((hours >> 2) & 0x07u);
|
||||
data->raw[10] = (data->raw[10] & 0x3Fu) | ((hours & 0x03u) << 6);
|
||||
return true;
|
||||
}
|
||||
static inline uint8_t _get_saflok_mfc_interval_minutes_impl(const saflok_mfc_data_t *data) {
|
||||
uint8_t minutes = (data->raw[10] & 0x3Fu);
|
||||
if (minutes > 59u) {
|
||||
PrintAndLogEx(WARNING, "Warning: interval minutes appears invalid (%u)\n", minutes);
|
||||
}
|
||||
return minutes;
|
||||
}
|
||||
static inline bool _set_saflok_mfc_interval_minutes_impl(saflok_mfc_data_t *data, uint8_t minutes) {
|
||||
if (minutes > 59u) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " interval minutes out of range (%u)\n", minutes);
|
||||
return false;
|
||||
}
|
||||
data->raw[10] = (data->raw[10] & 0xC0u) | (minutes & 0x3Fu);
|
||||
return true;
|
||||
}
|
||||
#endif // getters for interval (expiration) components
|
||||
#if 1 // Setting the interval date is based on the creation date.
|
||||
|
||||
static inline saflok_mfc_datetime_offset_t get_saflok_mfc_interval(
|
||||
const saflok_mfc_data_t *data
|
||||
) {
|
||||
saflok_mfc_datetime_offset_t offset = {
|
||||
.years = _get_saflok_mfc_interval_years_impl(data),
|
||||
.months = _get_saflok_mfc_interval_months_impl(data),
|
||||
.days = _get_saflok_mfc_interval_days_impl(data),
|
||||
.hours = _get_saflok_mfc_interval_hours_impl(data),
|
||||
.minutes = _get_saflok_mfc_interval_minutes_impl(data)
|
||||
};
|
||||
return offset;
|
||||
}
|
||||
static inline bool set_saflok_mfc_interval(
|
||||
saflok_mfc_data_t *data,
|
||||
saflok_mfc_datetime_offset_t offset
|
||||
) {
|
||||
bool result =
|
||||
_set_saflok_mfc_interval_years_impl(data, offset.years) &&
|
||||
_set_saflok_mfc_interval_months_impl(data, offset.months) &&
|
||||
_set_saflok_mfc_interval_days_impl(data, offset.days) &&
|
||||
_set_saflok_mfc_interval_hours_impl(data, offset.hours) &&
|
||||
_set_saflok_mfc_interval_minutes_impl(data, offset.minutes);
|
||||
return result;
|
||||
}
|
||||
static inline saflok_mfc_datetime_t add_offset(
|
||||
const saflok_mfc_datetime_t *base,
|
||||
const saflok_mfc_datetime_offset_t offset
|
||||
) {
|
||||
// adding dates is non-trivial.
|
||||
// luckily, there's already a standard for this...
|
||||
struct tm tm = {
|
||||
.tm_year = base->year - 1900,
|
||||
.tm_mon = base->month - 1,
|
||||
.tm_mday = base->day,
|
||||
.tm_hour = base->hour,
|
||||
.tm_min = base->minute,
|
||||
.tm_sec = 30, // selecting midpoint to avoid leapseconds changing minute
|
||||
.tm_isdst = 0, // UTC has no DST
|
||||
};
|
||||
// add the offsets ... and it's OK for them to be out of range
|
||||
tm.tm_year += offset.years;
|
||||
tm.tm_mon += offset.months;
|
||||
tm.tm_mday += offset.days;
|
||||
tm.tm_hour += offset.hours;
|
||||
tm.tm_min += offset.minutes;
|
||||
// normalize into EPOCH ... which allows out-of-bounds values
|
||||
time_t fixed = timegm(&tm);
|
||||
// convert EPOCH back into a tm structure
|
||||
gmtime_r(&fixed, &tm);
|
||||
// and finally convert back into saflok_mfc_datetime_t
|
||||
saflok_mfc_datetime_t result = {
|
||||
.year = tm.tm_year + 1900,
|
||||
.month = tm.tm_mon + 1,
|
||||
.day = tm.tm_mday,
|
||||
.hour = tm.tm_hour,
|
||||
.minute = tm.tm_min
|
||||
};
|
||||
return result;
|
||||
}
|
||||
static inline saflok_mfc_datetime_offset_t get_datetime_offset(
|
||||
const saflok_mfc_datetime_t *start,
|
||||
const saflok_mfc_datetime_t *end
|
||||
) {
|
||||
// convert both to `struct tm`
|
||||
struct tm tm_start = {
|
||||
.tm_year = start->year - 1900,
|
||||
.tm_mon = start->month - 1,
|
||||
.tm_mday = start->day,
|
||||
.tm_hour = start->hour,
|
||||
.tm_min = start->minute,
|
||||
.tm_sec = 30, // selecting midpoint to avoid leapseconds changing minute
|
||||
.tm_isdst = 0, // UTC has no DST
|
||||
};
|
||||
struct tm tm_end = {
|
||||
.tm_year = end->year - 1900,
|
||||
.tm_mon = end->month - 1,
|
||||
.tm_mday = end->day,
|
||||
.tm_hour = end->hour,
|
||||
.tm_min = end->minute,
|
||||
.tm_sec = 30, // selecting midpoint to avoid leapseconds changing minute
|
||||
.tm_isdst = 0, // UTC has no DST
|
||||
};
|
||||
// convert both to EPOCH
|
||||
time_t epoch_start = timegm(&tm_start);
|
||||
time_t epoch_end = timegm(&tm_end);
|
||||
// subtract the epoch values to get delta in seconds
|
||||
if (epoch_end < epoch_start) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " end date is before start date\n");
|
||||
saflok_mfc_datetime_offset_t zero_offset = {0};
|
||||
return zero_offset;
|
||||
}
|
||||
time_t delta = epoch_end - epoch_start;
|
||||
// convert delta seconds back into `struct tm`
|
||||
struct tm result_tm = {0};
|
||||
gmtime_r(&delta, &result_tm);
|
||||
saflok_mfc_datetime_offset_t result = {
|
||||
.years = result_tm.tm_year,
|
||||
.months = result_tm.tm_mon,
|
||||
.days = result_tm.tm_mday,
|
||||
.hours = result_tm.tm_hour,
|
||||
.minutes = result_tm.tm_min
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline saflok_mfc_datetime_t get_saflok_mfc_card_expiration_datetime(
|
||||
const saflok_mfc_data_t *data
|
||||
) {
|
||||
saflok_mfc_datetime_t creation_date = get_saflok_mfc_card_creation_datetime(data);
|
||||
saflok_mfc_datetime_offset_t offset = get_saflok_mfc_interval(data);
|
||||
saflok_mfc_datetime_t expiration = add_offset(&creation_date, offset);
|
||||
return expiration;
|
||||
}
|
||||
static inline bool set_saflok_mfc_card_expiration_datetime(
|
||||
saflok_mfc_data_t *data,
|
||||
const saflok_mfc_datetime_t * expiration
|
||||
) {
|
||||
if (!is_saflok_mfc_datetime_valid(expiration)) {
|
||||
PrintAndLogEx(ERR, _RED_("ERROR:") " expiration date is invalid\n");
|
||||
return false;
|
||||
}
|
||||
saflok_mfc_datetime_t creation_datetime = get_saflok_mfc_card_creation_datetime(data);
|
||||
saflok_mfc_datetime_offset_t offset = get_datetime_offset(&creation_datetime, expiration);
|
||||
bool result = set_saflok_mfc_interval(data, offset);
|
||||
return result;
|
||||
}
|
||||
#endif // Setting the interval date is based on the creation date.
|
||||
|
||||
static const uint8_t c_aDecode[] = {
|
||||
234, 13, 217, 116, 78, 40, 253, 186, 123, 152,
|
||||
135, 120, 221, 141, 181, 26, 14, 48, 243, 47,
|
||||
106, 59, 172, 9, 185, 32, 110, 91, 43, 182,
|
||||
@@ -103,8 +585,9 @@ static const uint8_t c_aDecode[256] = {
|
||||
12, 124, 198, 189, 249, 125, 196, 145, 39, 137,
|
||||
50, 114, 51, 101, 104, 175
|
||||
};
|
||||
_Static_assert(ARRAYLEN(c_aDecode) == 256, "c_aDecode must have 256 elements");
|
||||
|
||||
static const uint8_t c_aEncode[256] = {
|
||||
static const uint8_t c_aEncode[] = {
|
||||
236, 116, 192, 99, 86, 153, 105, 100, 159, 23,
|
||||
38, 198, 240, 1, 16, 77, 202, 82, 138, 75,
|
||||
122, 175, 173, 32, 115, 162, 15, 194, 80, 120,
|
||||
@@ -132,8 +615,9 @@ static const uint8_t c_aEncode[256] = {
|
||||
74, 111, 239, 18, 129, 44, 180, 56, 90, 244,
|
||||
151, 64, 104, 6, 49, 103
|
||||
};
|
||||
_Static_assert(ARRAYLEN(c_aEncode) == 256, "c_aEncode must have 256 elements");
|
||||
|
||||
uint8_t magic_table[192] = {
|
||||
uint8_t magic_table[] = {
|
||||
0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0xF0, 0x57, 0xB3, 0x9E, 0xE3, 0xD8,
|
||||
0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x96, 0x9D, 0x95, 0x4A, 0xC1, 0x57,
|
||||
0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x8F, 0x43, 0x58, 0x0D, 0x2C, 0x9D,
|
||||
@@ -151,8 +635,9 @@ uint8_t magic_table[192] = {
|
||||
0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x5C, 0xD0, 0x05, 0xCF, 0xD9, 0x07,
|
||||
0x00, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x11, 0x8D, 0xD0, 0x01, 0x87, 0xD0,
|
||||
};
|
||||
_Static_assert(ARRAYLEN(magic_table) == 192, "magic_table must have 192 elements");
|
||||
|
||||
static const char *level_names[16] = {
|
||||
static const char *level_names[] = {
|
||||
"Guest Key", // Index 0
|
||||
"Connectors", // Index 1
|
||||
"Suite", // Index 2
|
||||
@@ -170,6 +655,7 @@ static const char *level_names[16] = {
|
||||
"Secondary Programming Key (SPK)", // Index 14
|
||||
"Primary Programming Key (PPK)", // Index 15
|
||||
};
|
||||
_Static_assert(ARRAYLEN(level_names) == 16, "level_names must have 16 elements");
|
||||
|
||||
|
||||
static int CmdHelp(const char *Cmd);
|
||||
@@ -334,40 +820,6 @@ static char *bytes_to_hex(const uint8_t *data, size_t len) {
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
static int pack_datetime_expr(char *expiration_datetime, saflok_mfc_data_t *data) {
|
||||
int year, month, day, hour, minute;
|
||||
|
||||
if (sscanf(expiration_datetime, "%4d-%2d-%2dT%2d:%2d",
|
||||
&year, &month, &day, &hour, &minute) != 5) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
data->raw[8] = ((year & 0x0F) << 4) | (month & 0x0F);
|
||||
data->raw[9] = ((day & 0x1F) << 3) | ((hour & 0x1C) >> 2);
|
||||
data->raw[10] = ((hour & 0x03) << 6) | (minute & 0x3F);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pack_datetime(char *datetime_str, saflok_mfc_data_t *data) {
|
||||
int year, month, day, hour, minute;
|
||||
|
||||
if (sscanf(datetime_str, "%4d-%2d-%2dT%2d:%2d",
|
||||
&year, &month, &day, &hour, &minute) != 5) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint8_t year_offset = year - 1980;
|
||||
|
||||
data->raw[11] = ((year_offset & 0x0F) << 4) | (month & 0x0F);
|
||||
data->raw[12] = ((day & 0x1F) << 3) | ((hour & 0x1C) >> 2);
|
||||
data->raw[13] = ((hour & 0x03) << 6) | (minute & 0x3F);
|
||||
data->raw[14] = (data->raw[14] & 0x0F) | ((year_offset & 0x70) << 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint8_t calculated_saflok_checksum(const saflok_mfc_data_t *data) {
|
||||
_Static_assert(ARRAYLEN(data->raw) == 17, "saflok_mfc_data_t raw size must be 17 bytes");
|
||||
int sum = 0;
|
||||
@@ -439,9 +891,8 @@ static void saflok_decode(const saflok_mfc_data_t *data) {
|
||||
}
|
||||
|
||||
// Handle day rollover
|
||||
static const uint8_t days_in_month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||||
while (true) {
|
||||
uint8_t max_days = days_in_month[expire_month - 1];
|
||||
uint8_t max_days = days_in_month_lookup[expire_month];
|
||||
// Adjust for leap years
|
||||
if (expire_month == 2 &&
|
||||
(expire_year % 4 == 0 && (expire_year % 100 != 0 || expire_year % 400 == 0))) {
|
||||
@@ -515,22 +966,24 @@ static void saflok_encode(
|
||||
insert_bits(data, 88, 28, card_creation_date);
|
||||
insert_bits(data, 116, 12, property_id);
|
||||
|
||||
int year, month, day, hour, minute;
|
||||
|
||||
// BUGBUG -- sscanf() occurs twice: once here, and once in pack_datetime
|
||||
if (sscanf(dt, "%4d-%2d-%2dT%2d:%2d",
|
||||
&year, &month, &day, &hour, &minute) == 5) {
|
||||
pack_datetime(dt, data);
|
||||
// Parsing date time string from "YYYY-MM-DDTHH:mm" into `saflok_mfc_datetime_t`
|
||||
static const char * fmt = "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu8 "T%2" SCNu8 ":%2" SCNu8;
|
||||
|
||||
saflok_mfc_datetime_t creation_dt = {0};
|
||||
if (sscanf(dt, fmt, &creation_dt.year, &creation_dt.month, &creation_dt.day, &creation_dt.hour, &creation_dt.minute) == 5) {
|
||||
// return value ignored ... function here is void(!)
|
||||
set_saflok_mfc_card_creation_datetime(data, &creation_dt);
|
||||
}
|
||||
//else{
|
||||
//insert_bits(data, 88, 28,card_creation_date);
|
||||
//PrintAndLogEx(SUCCESS, "DT BITS INSERTED");
|
||||
//}
|
||||
|
||||
// BUGBUG -- sscanf() occurs twice: once here, and once in pack_datetime_expr
|
||||
if (sscanf(dt_expiration, "%4d-%2d-%2dT%2d:%2d",
|
||||
&year, &month, &day, &hour, &minute) == 5) {
|
||||
pack_datetime_expr(dt_expiration, data);
|
||||
saflok_mfc_datetime_t expiration_dt = {0};
|
||||
if (sscanf(dt_expiration, fmt, &expiration_dt.year, &expiration_dt.month, &expiration_dt.day, &expiration_dt.hour, &expiration_dt.minute) == 5) {
|
||||
// return value ignored ... function here is void(!)
|
||||
set_saflok_mfc_card_expiration_datetime(data, &expiration_dt);
|
||||
}
|
||||
//else{
|
||||
//insert_bits(data, 64, 24, expire_date);
|
||||
|
||||
Reference in new issue
Block a user