diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 18aef6274..c3bac6f2d 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -519,8 +519,10 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/parsers/parsenortic.c ${PM3_ROOT}/client/src/parsers/parsetransit.c ${PM3_ROOT}/client/src/parsers/parsebip.c + ${PM3_ROOT}/client/src/parsers/parsecalypso.c ${PM3_ROOT}/client/src/parsers/parsecharlie.c ${PM3_ROOT}/client/src/parsers/parseclipper.c + ${PM3_ROOT}/client/src/parsers/parseintercode.c ${PM3_ROOT}/client/src/parsers/parseintertic.c ${PM3_ROOT}/client/src/parsers/parseitso.c ${PM3_ROOT}/client/src/parsers/parsekazan.c @@ -530,7 +532,9 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/parsers/parsenol.c ${PM3_ROOT}/client/src/parsers/parseoctopus.c ${PM3_ROOT}/client/src/parsers/parseopal.c + ${PM3_ROOT}/client/src/parsers/parseopus.c ${PM3_ROOT}/client/src/parsers/parseplantain.c + ${PM3_ROOT}/client/src/parsers/parseravkav.c ${PM3_ROOT}/client/src/parsers/parserenfe.c ${PM3_ROOT}/client/src/parsers/parsesmartrider.c ${PM3_ROOT}/client/src/parsers/parsesuica.c diff --git a/client/Makefile b/client/Makefile index 089f6b4b8..90d8888ec 100644 --- a/client/Makefile +++ b/client/Makefile @@ -926,8 +926,10 @@ SRCS = mifare/aiddesfire.c \ parsers/parsenortic.c \ parsers/parsetransit.c \ parsers/parsebip.c \ + parsers/parsecalypso.c \ parsers/parsecharlie.c \ parsers/parseclipper.c \ + parsers/parseintercode.c \ parsers/parseintertic.c \ parsers/parseitso.c \ parsers/parsekazan.c \ @@ -937,7 +939,9 @@ SRCS = mifare/aiddesfire.c \ parsers/parsenol.c \ parsers/parseoctopus.c \ parsers/parseopal.c \ + parsers/parseopus.c \ parsers/parseplantain.c \ + parsers/parseravkav.c \ parsers/parserenfe.c \ parsers/parsesmartrider.c \ parsers/parsesuica.c \ diff --git a/client/experimental_lib/CMakeLists.txt b/client/experimental_lib/CMakeLists.txt index 098a4a3cf..c9ed5aad4 100644 --- a/client/experimental_lib/CMakeLists.txt +++ b/client/experimental_lib/CMakeLists.txt @@ -446,8 +446,10 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/parsers/parsenortic.c ${PM3_ROOT}/client/src/parsers/parsetransit.c ${PM3_ROOT}/client/src/parsers/parsebip.c + ${PM3_ROOT}/client/src/parsers/parsecalypso.c ${PM3_ROOT}/client/src/parsers/parsecharlie.c ${PM3_ROOT}/client/src/parsers/parseclipper.c + ${PM3_ROOT}/client/src/parsers/parseintercode.c ${PM3_ROOT}/client/src/parsers/parseintertic.c ${PM3_ROOT}/client/src/parsers/parseitso.c ${PM3_ROOT}/client/src/parsers/parsekazan.c @@ -457,7 +459,9 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/parsers/parsenol.c ${PM3_ROOT}/client/src/parsers/parseoctopus.c ${PM3_ROOT}/client/src/parsers/parseopal.c + ${PM3_ROOT}/client/src/parsers/parseopus.c ${PM3_ROOT}/client/src/parsers/parseplantain.c + ${PM3_ROOT}/client/src/parsers/parseravkav.c ${PM3_ROOT}/client/src/parsers/parserenfe.c ${PM3_ROOT}/client/src/parsers/parsesmartrider.c ${PM3_ROOT}/client/src/parsers/parsesuica.c diff --git a/client/src/cmdhfcalypso.c b/client/src/cmdhfcalypso.c index 26f2dde5f..fad58a3f1 100644 --- a/client/src/cmdhfcalypso.c +++ b/client/src/cmdhfcalypso.c @@ -2066,7 +2066,8 @@ static bool calypso_read_transit_record(uint8_t sfi, uint8_t record, transit_cal } // Contracts, events and counters for the transit parsers, by SFI in the selected application -static void calypso_run_transit_parsers(const calypso_select_result_t *selected, const uint8_t *env, size_t env_len) { +static void calypso_run_transit_parsers(const calypso_select_result_t *selected, const uint8_t *icc, size_t icc_len, + const uint8_t *env, size_t env_len) { transit_calypso_card_t card; memset(&card, 0, sizeof(card)); @@ -2075,6 +2076,11 @@ static void calypso_run_transit_parsers(const calypso_select_result_t *selected, card.has_serial = true; } + if (icc != NULL) { + card.icc.len = (uint8_t)MIN(icc_len, sizeof(card.icc.data)); + memcpy(card.icc.data, icc, card.icc.len); + } + card.env.len = (uint8_t)MIN(env_len, sizeof(card.env.data)); memcpy(card.env.data, env, card.env.len); @@ -2088,6 +2094,17 @@ static void calypso_run_transit_parsers(const calypso_select_result_t *selected, } card.contract_count++; } + // second contracts file, only after a full first one + for (uint8_t i = 4; card.contract_count == 4 && i < TRANSIT_CALYPSO_MAX_CONTRACTS; i++) { + if (calypso_read_transit_record(0x06, i - 3, &card.contracts[i]) == false) { + break; + } + card.contract_count++; + } + // per contract counters, Rav-Kav keeps its stored value here + for (uint8_t i = 0; i < ARRAYLEN(card.contract_counters); i++) { + (void)calypso_read_transit_record(0x0A + i, 1, &card.contract_counters[i]); + } for (uint8_t i = 0; i < TRANSIT_CALYPSO_MAX_EVENTS; i++) { if (calypso_read_transit_record(0x08, i + 1, &card.events[i]) == false) { break; @@ -4910,7 +4927,7 @@ static int CmdHFCalypsoInfo(const char *Cmd) { res = calypso_read_ticketing_environment(ticket_env, sizeof(ticket_env), &ticket_env_len, &ticket_env_sw); if (res == PM3_SUCCESS && ticket_env_sw == ISO7816_OK) { calypso_print_ticketing_environment(ticket_env, ticket_env_len, verbose); - calypso_run_transit_parsers(&selected, ticket_env, ticket_env_len); + calypso_run_transit_parsers(&selected, (icc_valid || icc_read_ok) ? icc : NULL, icc_len, ticket_env, ticket_env_len); } else if (verbose) { PrintAndLogEx(INFO, ""); PrintAndLogEx(INFO, "Ticketing environment unavailable (%04X - %s)", ticket_env_sw, GetAPDUCodeDescription(ticket_env_sw >> 8, ticket_env_sw & 0xFF)); diff --git a/client/src/parsers/parsecalypso.c b/client/src/parsers/parsecalypso.c new file mode 100644 index 000000000..dd2df0e25 --- /dev/null +++ b/client/src/parsers/parsecalypso.c @@ -0,0 +1,333 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// EN 1545 structure walker and Calypso helpers shared by the Calypso parsers +//----------------------------------------------------------------------------- + +#include "parsecalypso.h" + +#include +#include + +#include "commonutil.h" // ARRAYLEN, MemBeToUint4byte +#include "ui.h" // PrintAndLogEx +#include "util.h" // sprint_hex_inrow + +//----------------------------------------------------------------------------- +// Walker +//----------------------------------------------------------------------------- + +static void en1545_store(en1545_parsed_t *out, const char *name, uint8_t idx, size_t off, uint16_t bits, uint64_t value) { + if (out->count >= EN1545_MAX_VALUES) { + return; + } + en1545_value_t *v = &out->v[out->count++]; + v->name = name; + v->idx = idx; + v->off = (uint16_t)off; + v->bits = bits; + v->value = value; +} + +static size_t en1545_walk(const uint8_t *buf, size_t buflen, size_t off, const en1545_field_t *f, uint8_t idx, en1545_parsed_t *out) { + size_t total = buflen * 8; + + switch (f->kind) { + case EN1545_K_INT: { + if (f->bits > 0 && off + f->bits <= total) { + uint64_t v = (f->bits <= 64) ? transit_bits_be(buf, buflen, off, (uint8_t)f->bits) : 0; + en1545_store(out, f->name, idx, off, f->bits, v); + } + return off + f->bits; + } + case EN1545_K_BITMAP: { + if (off + f->nsub > total) { + return off + f->nsub; + } + uint64_t mask = transit_bits_be(buf, buflen, off, f->nsub); + off += f->nsub; + for (uint8_t i = 0; i < f->nsub; i++) { + if ((mask >> i) & 1) { + off = en1545_walk(buf, buflen, off, &f->sub[i], idx, out); + } + } + return off; + } + case EN1545_K_CONTAINER: { + for (uint8_t i = 0; i < f->nsub; i++) { + off = en1545_walk(buf, buflen, off, &f->sub[i], idx, out); + } + return off; + } + case EN1545_K_REPEAT: { + if (off + f->bits > total) { + return off + f->bits; + } + uint64_t cnt = transit_bits_be(buf, buflen, off, (uint8_t)f->bits); + off += f->bits; + for (uint64_t i = 0; i < cnt && off < total; i++) { + off = en1545_walk(buf, buflen, off, f->sub, (uint8_t)i, out); + } + return off; + } + } + return off; +} + +size_t en1545_parse(const uint8_t *buf, size_t buflen, size_t off, const en1545_field_t *f, en1545_parsed_t *out) { + memset(out, 0, sizeof(*out)); + if (buf == NULL || f == NULL) { + return off; + } + return en1545_walk(buf, buflen, off, f, 0, out); +} + +bool en1545_get(const en1545_parsed_t *p, const char *name, uint8_t idx, uint64_t *value) { + for (uint8_t i = 0; i < p->count; i++) { + if (p->v[i].idx == idx && strcmp(p->v[i].name, name) == 0) { + if (value != NULL) { + *value = p->v[i].value; + } + return true; + } + } + return false; +} + +uint64_t en1545_get_or(const en1545_parsed_t *p, const char *name, uint8_t idx, uint64_t def) { + uint64_t v = def; + (void)en1545_get(p, name, idx, &v); + return v; +} + +void en1545_date_str(char *out, size_t outlen, uint64_t days) { + if (days == 0) { + snprintf(out, outlen, "-"); + return; + } + transit_date_str(out, outlen, (int32_t)days + TRANSIT_DAYS_TO_1997); +} + +void en1545_datetime_str(char *out, size_t outlen, uint64_t days, uint64_t minutes) { + if (days == 0 && minutes == 0) { + snprintf(out, outlen, "-"); + return; + } + char d[16]; + transit_date_str(d, sizeof(d), (int32_t)days + TRANSIT_DAYS_TO_1997); + snprintf(out, outlen, "%s %02u:%02u", d, (unsigned)((minutes / 60) % 24), (unsigned)(minutes % 60)); +} + +//----------------------------------------------------------------------------- +// Intercode ticketing environment, holder part left out +//----------------------------------------------------------------------------- + +static const en1545_field_t env_data[] = { + EN1545_INT("EnvCardStatus", 1), + EN1545_INT("EnvExtra", 0), +}; + +static const en1545_field_t env_bitmap[] = { + EN1545_INT("EnvNetworkId", 24), + EN1545_INT("EnvApplicationIssuerId", 8), + EN1545_INT("EnvApplicationValidityEndDate", 14), + EN1545_INT("EnvPayMethod", 11), + EN1545_INT("EnvAuthenticator", 16), + EN1545_INT("EnvSelectList", 32), + EN1545_CONTAINER(env_data), +}; + +static const en1545_field_t env_fields[] = { + EN1545_INT("EnvVersionNumber", 6), + EN1545_BITMAP(env_bitmap), +}; + +const en1545_field_t calypso_intercode_env = EN1545_CONTAINER(env_fields); + +//----------------------------------------------------------------------------- +// Calypso helpers +//----------------------------------------------------------------------------- + +uint32_t calypso_intercode_network(const transit_calypso_card_t *card) { + if (card == NULL || card->env.len < 5) { + return 0; + } + // version 6 bits and a 7 bit bitmap whose lowest bit is the network id + if ((transit_bits_be(card->env.data, card->env.len, 6, 7) & 1) == 0) { + return 0; + } + return (uint32_t)transit_bits_be(card->env.data, card->env.len, 13, 24); +} + +bool calypso_record_empty(const transit_calypso_record_t *rec) { + return (rec == NULL || rec->len == 0 || transit_is_zero(rec->data, rec->len)); +} + +bool calypso_contract_counter(const transit_calypso_card_t *card, uint8_t recno, uint32_t *value) { + if (card == NULL || recno == 0 || recno > 4) { + return false; + } + // counters file 2069 holds three bytes per contract + if (card->counters.len >= (recno * 3)) { + *value = (uint32_t)transit_bits_be(card->counters.data, card->counters.len, (recno - 1) * 24, 24); + return true; + } + const transit_calypso_record_t *own = &card->contract_counters[recno - 1]; + if (own->len >= 3) { + *value = (uint32_t)transit_bits_be(own->data, own->len, 0, 24); + return true; + } + return false; +} + +const char *calypso_transport_str(uint8_t transport) { + static const char *names[] = { + "unspecified", "urban bus", "interurban bus", "metro", "tram", "train", + "ferry", "toll", "parking", "taxi", "high speed train", "rural bus", + "express train", "para transit", "self drive", "coach" + }; + return (transport < ARRAYLEN(names)) ? names[transport] : "other"; +} + +const char *calypso_event_action_str(uint8_t action) { + switch (action) { + case 0x1: + return "entry"; + case 0x2: + return "exit"; + case 0x3: + return "validation"; + case 0x4: + return "inspection"; + case 0x5: + return "test validation"; + case 0x6: + return "entry (interchange)"; + case 0x7: + return "exit (interchange)"; + case 0x9: + return "validation cancelled"; + case 0xA: + return "entry (public road)"; + case 0xB: + return "exit (public road)"; + case 0xD: + return "distribution"; + case 0xF: + return "invalidation"; + default: + return "unknown"; + } +} + +bool calypso_icc_card_number(const transit_calypso_card_t *card, char *out, size_t outlen) { + if (card == NULL || card->icc.len < 20) { + return false; + } + const uint8_t *d = card->icc.data; + + // OuRA! prints ten hex digits from byte 20, skipping the first nibble + if (calypso_intercode_network(card) == 0x250502 && card->icc.len >= 26) { + char hex[13]; + snprintf(hex, sizeof(hex), "%s", sprint_hex_inrow(d + 20, 6)); + snprintf(out, outlen, "%.10s", hex + 1); + return true; + } + + uint32_t num = MemBeToUint4byte(d + 16); + if (num == 0) { + num = MemBeToUint4byte(d); + } + if (num == 0) { + return false; + } + snprintf(out, outlen, "%u", num); + return true; +} + +void calypso_print_serial(const transit_calypso_card_t *card, bool use_icc) { + char num[16]; + if (use_icc && calypso_icc_card_number(card, num, sizeof(num))) { + transit_print_kv("Card number", _YELLOW_("%s"), num); + return; + } + if (card->has_serial == false) { + return; + } + transit_print_kv("Serial", _YELLOW_("%s") " ( %u )", sprint_hex_inrow(card->serial, sizeof(card->serial)), + (uint32_t)transit_bits_be(card->serial, sizeof(card->serial), 32, 32)); +} + +//----------------------------------------------------------------------------- +// Walker self test +//----------------------------------------------------------------------------- + +static const en1545_field_t st_rep_item[] = { + EN1545_INT("A", 4), + EN1545_INT("B", 3), +}; + +static const en1545_field_t st_rep_bm[] = { + EN1545_BITMAP(st_rep_item), +}; + +static const en1545_field_t st_fields[] = { + EN1545_INT("Head", 5), + EN1545_REPEAT(2, st_rep_bm), + EN1545_INT("Wide", 100), + EN1545_INT("Tail", 8), +}; + +static const en1545_field_t st_struct = EN1545_CONTAINER(st_fields); + +bool en1545_selftest(void) { + PrintAndLogEx(INFO, ""); + PrintAndLogEx(INFO, "Testing EN 1545 walker"); + + // Head=0x15, two repeats: (A=0x9) and (B=0x5), wide field skipped, Tail=0xC3 + uint8_t buf[20] = {0}; + size_t off = 0; + transit_set_bits_be(buf, sizeof(buf), off, 5, 0x15); + off += 5; + transit_set_bits_be(buf, sizeof(buf), off, 2, 2); + off += 2; + transit_set_bits_be(buf, sizeof(buf), off, 2, 0x1); // bitmap: A only + off += 2; + transit_set_bits_be(buf, sizeof(buf), off, 4, 0x9); + off += 4; + transit_set_bits_be(buf, sizeof(buf), off, 2, 0x2); // bitmap: B only + off += 2; + transit_set_bits_be(buf, sizeof(buf), off, 3, 0x5); + off += 3 + 100; + transit_set_bits_be(buf, sizeof(buf), off, 8, 0xC3); + off += 8; + + en1545_parsed_t p; + size_t end = en1545_parse(buf, sizeof(buf), 0, &st_struct, &p); + + bool ok = true; + ok &= transit_check("walker end offset", end, off); + ok &= transit_check("Head", en1545_get_or(&p, "Head", 0, 0xFF), 0x15); + ok &= transit_check("repeat 0 A", en1545_get_or(&p, "A", 0, 0xFF), 0x9); + ok &= transit_check("repeat 0 has no B", en1545_get(&p, "B", 0, NULL), false); + ok &= transit_check("repeat 1 B", en1545_get_or(&p, "B", 1, 0xFF), 0x5); + ok &= transit_check("wide field marked", en1545_get(&p, "Wide", 0, NULL), true); + ok &= transit_check("Tail", en1545_get_or(&p, "Tail", 0, 0xFF), 0xC3); + + // truncated: tail no longer fits and must not be stored + (void)en1545_parse(buf, 15, 0, &st_struct, &p); + ok &= transit_check("truncated tail dropped", en1545_get(&p, "Tail", 0, NULL), false); + return ok; +} diff --git a/client/src/parsers/parsecalypso.h b/client/src/parsers/parsecalypso.h new file mode 100644 index 000000000..715eb8917 --- /dev/null +++ b/client/src/parsers/parsecalypso.h @@ -0,0 +1,95 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// EN 1545 structure walker and Calypso helpers shared by the Calypso parsers +// +// Bitmap driven field layout after Metrodroid's En1545Parser (GPLv3). +//----------------------------------------------------------------------------- + +#ifndef PARSECALYPSO_H__ +#define PARSECALYPSO_H__ + +#include "common.h" +#include "parsetransit.h" + +typedef enum { + EN1545_K_INT, // fixed width field, wider than 64 bits is only marked present + EN1545_K_BITMAP, // presence bitmap, one bit per child, lowest bit first + EN1545_K_CONTAINER, // children in sequence + EN1545_K_REPEAT, // counter of `bits` width, then the single child that many times +} en1545_kind_t; + +typedef struct en1545_field { + en1545_kind_t kind; + uint16_t bits; + const char *name; + const struct en1545_field *sub; + uint8_t nsub; +} en1545_field_t; + +#define EN1545_INT(n, b) { EN1545_K_INT, (b), (n), NULL, 0 } +#define EN1545_BITMAP(a) { EN1545_K_BITMAP, 0, NULL, (a), (uint8_t)(sizeof(a) / sizeof((a)[0])) } +#define EN1545_CONTAINER(a) { EN1545_K_CONTAINER, 0, NULL, (a), (uint8_t)(sizeof(a) / sizeof((a)[0])) } +#define EN1545_REPEAT(c, a) { EN1545_K_REPEAT, (c), NULL, (a), 1 } + +#define EN1545_MAX_VALUES 64 + +typedef struct { + const char *name; + uint8_t idx; // iteration of the enclosing repeat, 0 outside one + uint16_t off; + uint16_t bits; + uint64_t value; +} en1545_value_t; + +typedef struct { + uint8_t count; + en1545_value_t v[EN1545_MAX_VALUES]; +} en1545_parsed_t; + +// Walk buf from bit off, returns the bit offset after the structure. +// Fields running past the buffer are not stored. +size_t en1545_parse(const uint8_t *buf, size_t buflen, size_t off, const en1545_field_t *f, en1545_parsed_t *out); + +bool en1545_get(const en1545_parsed_t *p, const char *name, uint8_t idx, uint64_t *value); +uint64_t en1545_get_or(const en1545_parsed_t *p, const char *name, uint8_t idx, uint64_t def); + +// EN 1545 day 0 is 1997-01-01, day 0 prints as "-" +void en1545_date_str(char *out, size_t outlen, uint64_t days); +void en1545_datetime_str(char *out, size_t outlen, uint64_t days, uint64_t minutes); + +// Intercode ticketing environment, also used by Opus +extern const en1545_field_t calypso_intercode_env; + +// EnvNetworkId of an Intercode style environment, 0 when not read +uint32_t calypso_intercode_network(const transit_calypso_card_t *card); + +bool calypso_record_empty(const transit_calypso_record_t *rec); + +// Counter of a contract, 1 based record number: 2069 first, then its own 202A..202D +bool calypso_contract_counter(const transit_calypso_card_t *card, uint8_t recno, uint32_t *value); + +// Event code high nibble is the transport, low nibble what happened +const char *calypso_transport_str(uint8_t transport); +const char *calypso_event_action_str(uint8_t action); + +// Card number from the ICC record (Intercode / Opus), else the FCI serial +bool calypso_icc_card_number(const transit_calypso_card_t *card, char *out, size_t outlen); +void calypso_print_serial(const transit_calypso_card_t *card, bool use_icc); + +// Walker checks shared by the Calypso parser self tests +bool en1545_selftest(void); + +#endif diff --git a/client/src/parsers/parseintercode.c b/client/src/parsers/parseintercode.c new file mode 100644 index 000000000..14279e0d1 --- /dev/null +++ b/client/src/parsers/parseintercode.c @@ -0,0 +1,724 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Intercode (French Calypso networks) parser, Navigo included +//----------------------------------------------------------------------------- + +#include "parseintercode.h" + +#include +#include + +#include "commonutil.h" // ARRAYLEN +#include "ui.h" // PrintAndLogEx +#include "parsecalypso.h" + +// Navigo service providers whose metro / tram locations are sector + station +#define NAVIGO_PROVIDER_SNCF 2 +#define NAVIGO_PROVIDER_RATP 3 + +//----------------------------------------------------------------------------- +// Layouts +//----------------------------------------------------------------------------- + +static const en1545_field_t ev_data[] = { + EN1545_INT("EventFirstStampDate", 14), + EN1545_INT("EventFirstStampTime", 11), + EN1545_INT("EventDataSimulation", 1), + EN1545_INT("EventDataTrip", 2), + EN1545_INT("EventDataRouteDirection", 2), +}; + +static const en1545_field_t ev_bitmap[] = { + EN1545_INT("EventDisplayData", 8), + EN1545_INT("EventNetworkId", 24), + EN1545_INT("EventCode", 8), + EN1545_INT("EventResult", 8), + EN1545_INT("EventServiceProvider", 8), + EN1545_INT("EventNotOkCounter", 8), + EN1545_INT("EventSerialNumber", 24), + EN1545_INT("EventDestination", 16), + EN1545_INT("EventLocationId", 16), + EN1545_INT("EventLocationGate", 8), + EN1545_INT("EventDevice", 16), + EN1545_INT("EventRouteNumber", 16), + EN1545_INT("EventRouteVariant", 8), + EN1545_INT("EventJourneyRun", 16), + EN1545_INT("EventVehicleId", 16), + EN1545_INT("EventVehiculeClass", 8), + EN1545_INT("EventLocationType", 5), + EN1545_INT("EventEmployee", 240), + EN1545_INT("EventLocationReference", 16), + EN1545_INT("EventJourneyInterchanges", 8), + EN1545_INT("EventPeriodJourneys", 16), + EN1545_INT("EventTotalJourneys", 16), + EN1545_INT("EventJourneyDistance", 16), + EN1545_INT("EventPriceAmount", 16), + EN1545_INT("EventPriceUnit", 16), + EN1545_INT("EventContractPointer", 5), + EN1545_INT("EventAuthenticator", 16), + EN1545_BITMAP(ev_data), +}; + +static const en1545_field_t ev_fields[] = { + EN1545_INT("EventDate", 14), + EN1545_INT("EventTime", 11), + EN1545_BITMAP(ev_bitmap), +}; + +static const en1545_field_t intercode_event = EN1545_CONTAINER(ev_fields); + +static const en1545_field_t cl_item[] = { + EN1545_INT("ContractsNetworkId", 24), + EN1545_INT("ContractsTariff", 16), + EN1545_INT("ContractsPointer", 5), +}; + +static const en1545_field_t cl_bitmap[] = { + EN1545_BITMAP(cl_item), +}; + +static const en1545_field_t intercode_contract_list = EN1545_REPEAT(4, cl_bitmap); + +// Contract type FF, the full Intercode layout +static const en1545_field_t ff_customer[] = { + EN1545_INT("ContractCustomerProfile", 6), + EN1545_INT("ContractCustomerNumber", 32), +}; +static const en1545_field_t ff_passenger[] = { + EN1545_INT("ContractPassengerClass", 8), + EN1545_INT("ContractPassengerTotal", 8), +}; +static const en1545_field_t ff_restrict[] = { + EN1545_INT("ContractRestrictStart", 11), + EN1545_INT("ContractRestrictEnd", 11), + EN1545_INT("ContractRestrictDay", 8), + EN1545_INT("ContractRestrictTimeCode", 8), + EN1545_INT("ContractRestrictCode", 8), + EN1545_INT("ContractRestrictProduct", 16), + EN1545_INT("ContractRestrictLocation", 16), +}; +static const en1545_field_t ff_validity[] = { + EN1545_INT("ContractStartDate", 14), + EN1545_INT("ContractStartTime", 11), + EN1545_INT("ContractEndDate", 14), + EN1545_INT("ContractEndTime", 11), + EN1545_INT("ContractDuration", 8), + EN1545_INT("ContractLimitDate", 14), + EN1545_INT("ContractZones", 8), + EN1545_INT("ContractJourneys", 16), + EN1545_INT("ContractPeriodJourneys", 16), +}; +static const en1545_field_t ff_journey[] = { + EN1545_INT("ContractOrigin1", 16), + EN1545_INT("ContractDestination1", 16), + EN1545_INT("ContractRouteNumbers", 16), + EN1545_INT("ContractRouteVariants", 8), + EN1545_INT("ContractRun", 16), + EN1545_INT("ContractVia1", 16), + EN1545_INT("ContractDistance", 16), + EN1545_INT("ContractInterchange", 8), +}; +static const en1545_field_t ff_sale[] = { + EN1545_INT("ContractSaleDate", 14), + EN1545_INT("ContractSaleTime", 11), + EN1545_INT("ContractSaleAgent", 8), + EN1545_INT("ContractSaleDevice", 16), +}; +static const en1545_field_t ff_fields[] = { + EN1545_INT("ContractNetworkId", 24), + EN1545_INT("ContractProvider", 8), + EN1545_INT("ContractTariff", 16), + EN1545_INT("ContractSerialNumber", 32), + EN1545_BITMAP(ff_customer), + EN1545_BITMAP(ff_passenger), + EN1545_INT("ContractVehiculeClassAllowed", 6), + EN1545_INT("ContractPaymentPointer", 32), + EN1545_INT("ContractPayMethod", 11), + EN1545_INT("ContractServices", 16), + EN1545_INT("ContractPriceAmount", 16), + EN1545_INT("ContractPriceUnit", 16), + EN1545_BITMAP(ff_restrict), + EN1545_BITMAP(ff_validity), + EN1545_BITMAP(ff_journey), + EN1545_BITMAP(ff_sale), + EN1545_INT("ContractStatus", 8), + EN1545_INT("ContractLoyaltyPoints", 16), + EN1545_INT("ContractAuthenticator", 16), + EN1545_INT("ContractExtra", 0), +}; +static const en1545_field_t contract_ff = EN1545_BITMAP(ff_fields); + +// Types 20 and 46 share a common head and a bitmap of optional parts +static const en1545_field_t cm_dates[] = { + EN1545_INT("ContractStartDate", 14), + EN1545_INT("ContractEndDate", 14), +}; +static const en1545_field_t c_ovd1[] = { + EN1545_INT("ContractOrigin1", 16), + EN1545_INT("ContractVia1", 16), + EN1545_INT("ContractDestination1", 16), +}; +static const en1545_field_t c_od2[] = { + EN1545_INT("ContractOrigin2", 16), + EN1545_INT("ContractDestination2", 16), +}; +static const en1545_field_t c_sale[] = { + EN1545_INT("ContractSaleDate", 14), + EN1545_INT("ContractSaleDevice", 16), + EN1545_INT("ContractSaleAgent", 8), +}; +static const en1545_field_t c_pay[] = { + EN1545_INT("ContractPayMethod", 11), + EN1545_INT("ContractPriceAmount", 16), + EN1545_INT("ContractReceiptDelivered", 1), +}; +static const en1545_field_t c_period[] = { + EN1545_INT("ContractEndPeriod", 14), + EN1545_INT("ContractSoldPeriod", 6), +}; +static const en1545_field_t c_sold[] = { + EN1545_INT("ContractSold", 8), + EN1545_INT("ContractDebitSold", 5), +}; + +static const en1545_field_t t20_extra[] = { + EN1545_CONTAINER(c_ovd1), + EN1545_CONTAINER(c_od2), + EN1545_INT("ContractZones", 16), + EN1545_CONTAINER(c_sale), + EN1545_CONTAINER(c_pay), + EN1545_INT("ContractPassengerTotal", 6), + EN1545_CONTAINER(c_period), + EN1545_CONTAINER(c_sold), + EN1545_INT("ContractVehiculeClassAllowed", 4), + EN1545_INT("LinkedContract", 5), +}; + +static const en1545_field_t t46_extra[] = { + EN1545_CONTAINER(c_ovd1), + EN1545_CONTAINER(c_od2), + EN1545_INT("ContractZones", 16), + EN1545_CONTAINER(c_sale), + EN1545_CONTAINER(c_pay), + EN1545_INT("ContractPassengerTotal", 6), + EN1545_CONTAINER(c_period), + EN1545_CONTAINER(c_sold), + EN1545_INT("ContractVehiculeClassAllowed", 4), + EN1545_INT("LinkedContract", 5), + EN1545_INT("ContractStartTime", 11), + EN1545_INT("ContractEndTime", 11), + EN1545_INT("ContractDataEndInhibitionDate", 14), + EN1545_INT("ContractDataValidityLimitDate", 14), + EN1545_INT("ContractDataGeoLine", 28), + EN1545_INT("ContractJourneys", 16), + EN1545_INT("ContractDataSaleSecureDevice", 32), +}; + +#define INTERCODE_COMMON_HEAD \ + EN1545_INT("ContractProvider", 8), \ + EN1545_INT("ContractTariff", 16), \ + EN1545_INT("ContractSerialNumber", 32), \ + EN1545_INT("ContractPassengerClass", 8), \ + EN1545_BITMAP(cm_dates), \ + EN1545_INT("ContractStatus", 8) + +static const en1545_field_t t20_fields[] = { INTERCODE_COMMON_HEAD, EN1545_BITMAP(t20_extra) }; +static const en1545_field_t t46_fields[] = { INTERCODE_COMMON_HEAD, EN1545_BITMAP(t46_extra) }; +static const en1545_field_t tother_fields[] = { INTERCODE_COMMON_HEAD, EN1545_INT("ContractData", 0) }; + +static const en1545_field_t contract_20 = EN1545_BITMAP(t20_fields); +static const en1545_field_t contract_46 = EN1545_BITMAP(t46_fields); +static const en1545_field_t contract_other = EN1545_BITMAP(tother_fields); + +//----------------------------------------------------------------------------- +// Names +//----------------------------------------------------------------------------- + +typedef struct { + uint32_t id; + const char *name; +} intercode_name_t; + +static const intercode_name_t intercode_networks[] = { + { 0x250000, "Pass Pass (Hauts-de-France)" }, + { 0x250064, "TaM (Montpellier)" }, + { 0x250502, "OuRA! (Auvergne-Rhone-Alpes)" }, + { 0x250901, "Navigo (Ile-de-France)" }, + { 0x250908, "KorriGo (Bretagne)" }, + { 0x250916, "Tisseo (Toulouse)" }, + { 0x250920, "Envibus (Sophia Antipolis)" }, + { 0x250921, "TransGironde (Gironde)" }, +}; + +static const intercode_name_t navigo_tariffs[] = { + { 0, "Navigo Mois" }, + { 1, "Navigo Semaine" }, + { 2, "Navigo Annuel" }, + { 3, "Navigo Jour" }, + { 5, "Imagine R Etudiant" }, + { 4096, "Liberte+" }, + { 16384, "Navigo Mois 75%" }, + { 16385, "Navigo Semaine 75%" }, + { 20480, "Ticket t+" }, + { 20488, "Metro-Train-RER" }, + { 32771, "Solidarite gratuite" }, +}; + +// Paris metro sectors, the station id is local to its sector +static const char *navigo_sectors[] = { + NULL, "Cite", "Rennes", "Villette", "Montparnasse", "Nation", "Saint-Lazare", "Auteuil", + "Republique", "Austerlitz", "Invalides", "Sentier", "Ile Saint-Louis", "Daumesnil", + "Italie", "Denfert", "Felix Faure", "Passy", "Etoile", "Clichy - Saint Ouen", + "Montmartre", "Lafayette", "Buttes Chaumont", "Belleville", "Pere Lachaise", + "Charenton", "Ivry - Villejuif", "Vanves", "Issy", "Levallois", "Pereire", "Pigalle" +}; + +static const char *intercode_lookup(const intercode_name_t *t, size_t n, uint32_t id) { + for (size_t i = 0; i < n; i++) { + if (t[i].id == id) { + return t[i].name; + } + } + return NULL; +} + +static const char *intercode_contract_status_str(uint64_t status) { + switch (status) { + case 0x00: + return "valid, never used"; + case 0x01: + return "valid, used"; + case 0x03: + return "renewal required"; + case 0x0D: + return "not validable"; + case 0x13: + return "blocked"; + case 0x3F: + return "suspended"; + case 0x58: + return "invalid"; + case 0x7F: + return "refunded"; + case 0xFF: + return "erasable"; + default: + return "unknown"; + } +} + +//----------------------------------------------------------------------------- +// Printing +//----------------------------------------------------------------------------- + +static void intercode_print_env(const transit_calypso_card_t *card) { + en1545_parsed_t env; + (void)en1545_parse(card->env.data, card->env.len, 0, &calypso_intercode_env, &env); + + char buf[32]; + uint64_t v; + transit_print_kv("Env version", "%" PRIu64, en1545_get_or(&env, "EnvVersionNumber", 0, 0)); + if (en1545_get(&env, "EnvNetworkId", 0, &v)) { + transit_print_kv("Network", "%06" PRIX64, v); + } + if (en1545_get(&env, "EnvApplicationIssuerId", 0, &v)) { + transit_print_kv("Issuer", "%" PRIu64, v); + } + if (en1545_get(&env, "EnvApplicationValidityEndDate", 0, &v)) { + en1545_date_str(buf, sizeof(buf), v); + transit_print_kv("Valid until", _YELLOW_("%s"), buf); + } + if (en1545_get(&env, "EnvPayMethod", 0, &v)) { + transit_print_kv("Pay method", "%" PRIu64, v); + } +} + +// Remaining trips per Metrodroid IntercodeSubscription +static bool intercode_trips(const en1545_parsed_t *c, bool navigo, bool has_ctr, uint32_t ctr, uint32_t *left, uint32_t *total) { + uint64_t sold = en1545_get_or(c, "ContractSold", 0, 0); + uint64_t debit = en1545_get_or(c, "ContractDebitSold", 0, 0); + uint64_t journeys = en1545_get_or(c, "ContractJourneys", 0, 0); + + if (sold != 0 && debit != 0) { + if (has_ctr == false) { + return false; + } + *left = ctr / (uint32_t)debit; + *total = (uint32_t)(sold / debit); + return true; + } + if (journeys == 0 || has_ctr == false) { + return false; + } + if (navigo) { + // counter: 6 bit count then 18 bit relative first stamp + *left = ctr >> 18; + *total = (uint32_t)(journeys & 0xFFF); + } else { + *left = ctr; + *total = (uint32_t)journeys; + } + return true; +} + +// Zone bitmask, lowest bit is zone 1, as "1,2,5" +static void intercode_zones_str(char *out, size_t outlen, uint64_t mask) { + size_t n = 0; + for (uint8_t z = 0; z < 16 && n + 4 < outlen; z++) { + if (((mask >> z) & 1) == 0) { + continue; + } + uint8_t zone = z + 1; + if (n > 0) { + out[n++] = ','; + } + if (zone >= 10) { + out[n++] = (char)('0' + (zone / 10)); + } + out[n++] = (char)('0' + (zone % 10)); + } + if (outlen > 0) { + out[n] = '\0'; + } +} + +static void intercode_print_contract(const transit_calypso_card_t *card, uint8_t recno, const en1545_parsed_t *list, bool navigo) { + const transit_calypso_record_t *rec = &card->contracts[recno - 1]; + + // the contract list names the layout through its tariff, Navigo cards use FF + uint8_t type = 0xFF; + bool listed = false; + for (uint8_t i = 0; i < 4; i++) { + uint64_t ptr; + if (en1545_get(list, "ContractsPointer", i, &ptr) && ptr == recno) { + uint64_t t; + if (en1545_get(list, "ContractsTariff", i, &t)) { + type = (uint8_t)((t >> 4) & 0xFF); + listed = true; + } + break; + } + } + + const en1545_field_t *layout = &contract_ff; + if (type == 0x20) { + layout = &contract_20; + } else if (type == 0x46) { + layout = &contract_46; + } else if (type != 0xFF) { + layout = &contract_other; + } + + en1545_parsed_t c; + (void)en1545_parse(rec->data, rec->len, 0, layout, &c); + + char label[24]; + char buf[48]; + char buf2[48]; + uint64_t v, w; + + uint64_t tariff = en1545_get_or(&c, "ContractTariff", 0, 0); + const char *tname = navigo ? intercode_lookup(navigo_tariffs, ARRAYLEN(navigo_tariffs), (uint32_t)tariff) : NULL; + snprintf(label, sizeof(label), "Contract %u", recno); + transit_print_kv(label, "tariff " _YELLOW_("%" PRIu64) " ( %s ) layout %02X%s", tariff, + tname ? tname : "unknown", type, listed ? "" : ", not in contract list"); + + if (en1545_get(&c, "ContractProvider", 0, &v)) { + transit_print_kv(" Provider", "%" PRIu64, v); + } + if (en1545_get(&c, "ContractSerialNumber", 0, &v)) { + transit_print_kv(" Serial", "%" PRIu64, v); + } + if (en1545_get(&c, "ContractStartDate", 0, &v)) { + en1545_date_str(buf, sizeof(buf), v); + en1545_date_str(buf2, sizeof(buf2), en1545_get_or(&c, "ContractEndDate", 0, 0)); + transit_print_kv(" Validity", _YELLOW_("%s") " .. " _YELLOW_("%s"), buf, buf2); + } else if (en1545_get(&c, "ContractEndDate", 0, &v)) { + en1545_date_str(buf, sizeof(buf), v); + transit_print_kv(" Valid until", _YELLOW_("%s"), buf); + } + if (en1545_get(&c, "ContractZones", 0, &v) && v != 0) { + intercode_zones_str(buf, sizeof(buf), v); + transit_print_kv(" Zones", "%s", buf); + } + if (en1545_get(&c, "ContractPriceAmount", 0, &v)) { + transit_money_str(buf, sizeof(buf), (int64_t)v, 2, "EUR"); + transit_print_kv(" Price", "%s", buf); + } + if (en1545_get(&c, "ContractSaleDate", 0, &v)) { + en1545_date_str(buf, sizeof(buf), v); + transit_print_kv(" Sold", "%s, agent %" PRIu64 ", device %" PRIu64, buf, + en1545_get_or(&c, "ContractSaleAgent", 0, 0), en1545_get_or(&c, "ContractSaleDevice", 0, 0)); + } + if (en1545_get(&c, "ContractStatus", 0, &v)) { + transit_print_kv(" Status", "%02" PRIX64 " ( %s )", v, intercode_contract_status_str(v)); + } + if (en1545_get(&c, "ContractOrigin1", 0, &v) && en1545_get(&c, "ContractDestination1", 0, &w)) { + transit_print_kv(" Route", "%" PRIu64 " -> %" PRIu64, v, w); + } + + uint32_t ctr = 0, left = 0, total = 0; + bool has_ctr = calypso_contract_counter(card, recno, &ctr); + if (intercode_trips(&c, navigo, has_ctr, ctr, &left, &total)) { + transit_print_kv(" Trips", _GREEN_("%u") " of %u left", left, total); + } else if (has_ctr && ctr != 0) { + transit_print_kv(" Counter", "%06X", ctr); + } +} + +static void intercode_print_event(const transit_calypso_card_t *card, uint8_t n, bool navigo) { + en1545_parsed_t e; + (void)en1545_parse(card->events[n].data, card->events[n].len, 0, &intercode_event, &e); + + char when[32]; + char where[64]; + char label[16]; + uint64_t code = en1545_get_or(&e, "EventCode", 0, 0); + uint64_t provider = en1545_get_or(&e, "EventServiceProvider", 0, 0); + uint8_t transport = (uint8_t)(code >> 4); + + en1545_datetime_str(when, sizeof(when), en1545_get_or(&e, "EventDate", 0, 0), en1545_get_or(&e, "EventTime", 0, 0)); + + where[0] = '\0'; + uint64_t loc; + if (en1545_get(&e, "EventLocationId", 0, &loc)) { + uint32_t sector = (uint32_t)(loc >> 9); + if (navigo && (provider == NAVIGO_PROVIDER_RATP || provider == NAVIGO_PROVIDER_SNCF) && (transport == 3 || transport == 4)) { + const char *sname = (sector < ARRAYLEN(navigo_sectors)) ? navigo_sectors[sector] : NULL; + snprintf(where, sizeof(where), ", sector %u ( %s ) station %u", sector, + sname ? sname : "unknown", (uint32_t)((loc >> 4) & 0x1F)); + } else { + snprintf(where, sizeof(where), ", location %" PRIu64, loc); + } + } + + snprintf(label, sizeof(label), "Event %u", n + 1); + transit_print_kv(label, _YELLOW_("%s") " %s %s, provider %" PRIu64 "%s", when, + calypso_transport_str(transport), calypso_event_action_str(code & 0x0F), provider, where); + + uint64_t v; + if (en1545_get(&e, "EventRouteNumber", 0, &v)) { + transit_print_kv(" Route", "%" PRIu64, v); + } + if (en1545_get(&e, "EventContractPointer", 0, &v)) { + transit_print_kv(" Contract", "%" PRIu64, v); + } + if (en1545_get(&e, "EventResult", 0, &v) && v != 0) { + transit_print_kv(" Result", "%02" PRIX64, v); + } + if (en1545_get(&e, "EventPriceAmount", 0, &v)) { + char buf[32]; + transit_money_str(buf, sizeof(buf), (int64_t)v, 2, "EUR"); + transit_print_kv(" Price", "%s", buf); + } +} + +static int intercode_print(const transit_calypso_card_t *card, bool navigo) { + uint32_t net = calypso_intercode_network(card); + const char *name = intercode_lookup(intercode_networks, ARRAYLEN(intercode_networks), net); + + char title[64]; + if (name != NULL) { + snprintf(title, sizeof(title), "%s", name); + } else { + snprintf(title, sizeof(title), "Intercode network %06X", net); + } + transit_print_header(title); + calypso_print_serial(card, true); + intercode_print_env(card); + + en1545_parsed_t list; + (void)en1545_parse(card->contract_list.data, card->contract_list.len, 0, &intercode_contract_list, &list); + + for (uint8_t i = 0; i < card->contract_count && i < TRANSIT_CALYPSO_MAX_CONTRACTS; i++) { + if (calypso_record_empty(&card->contracts[i]) == false) { + intercode_print_contract(card, i + 1, &list, navigo); + } + } + for (uint8_t i = 0; i < card->event_count && i < TRANSIT_CALYPSO_MAX_EVENTS; i++) { + if (calypso_record_empty(&card->events[i]) == false) { + intercode_print_event(card, i, navigo); + } + } + return PM3_SUCCESS; +} + +//----------------------------------------------------------------------------- +// Entry points +//----------------------------------------------------------------------------- + +bool is_valid_navigo_card(const transit_calypso_card_t *card) { + return calypso_intercode_network(card) == INTERCODE_NETWORK_NAVIGO; +} + +int navigo_parser_parse(const transit_calypso_card_t *card) { + if (is_valid_navigo_card(card) == false) { + return PM3_EINVARG; + } + return intercode_print(card, true); +} + +bool is_valid_intercode_card(const transit_calypso_card_t *card) { + uint32_t net = calypso_intercode_network(card); + return ((net >> 12) == INTERCODE_COUNTRY_FRANCE) && (net != INTERCODE_NETWORK_NAVIGO); +} + +int intercode_parser_parse(const transit_calypso_card_t *card) { + if (is_valid_intercode_card(card) == false) { + return PM3_EINVARG; + } + return intercode_print(card, false); +} + +//----------------------------------------------------------------------------- +// Self tests, records built from the layouts above +//----------------------------------------------------------------------------- + +// env: version 1, bitmap {network, validity end} +static void intercode_build_env(transit_calypso_record_t *r, uint32_t net, uint16_t end) { + memset(r, 0, sizeof(*r)); + r->len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(r->data, r->len, 0, 6, 1); + transit_set_bits_be(r->data, r->len, 6, 7, 0x05); + transit_set_bits_be(r->data, r->len, 13, 24, net); + transit_set_bits_be(r->data, r->len, 37, 14, end); +} + +static bool intercode_selftest_common(bool navigo) { + transit_calypso_card_t card; + memset(&card, 0, sizeof(card)); + + uint32_t net = navigo ? INTERCODE_NETWORK_NAVIGO : 0x250916; + intercode_build_env(&card.env, net, 10000); + + // contract list entry 0: bitmap {tariff, pointer}, tariff 0x0FF0 -> layout FF, pointer 1 + transit_calypso_record_t *cl = &card.contract_list; + cl->len = TRANSIT_CALYPSO_REC_LEN; + size_t off = 0; + transit_set_bits_be(cl->data, cl->len, off, 4, 1); + off += 4; + transit_set_bits_be(cl->data, cl->len, off, 3, 0x6); + off += 3; + transit_set_bits_be(cl->data, cl->len, off, 16, 0x0FF0); + off += 16; + transit_set_bits_be(cl->data, cl->len, off, 5, 1); + + // contract FF: bitmap {provider, tariff, validity}, validity {start, end, journeys} + transit_calypso_record_t *c = &card.contracts[0]; + c->len = TRANSIT_CALYPSO_REC_LEN; + off = 0; + transit_set_bits_be(c->data, c->len, off, 20, (1u << 1) | (1u << 2) | (1u << 13)); + off += 20; + transit_set_bits_be(c->data, c->len, off, 8, 3); + off += 8; + transit_set_bits_be(c->data, c->len, off, 16, 20480); + off += 16; + transit_set_bits_be(c->data, c->len, off, 9, (1u << 0) | (1u << 2) | (1u << 7)); + off += 9; + transit_set_bits_be(c->data, c->len, off, 14, 9800); + off += 14; + transit_set_bits_be(c->data, c->len, off, 14, 9830); + off += 14; + transit_set_bits_be(c->data, c->len, off, 16, 10); + card.contract_count = 1; + + // counter for contract 1: 7 trips left + card.counters.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.counters.data, card.counters.len, 0, 24, navigo ? (7u << 18) : 7u); + + // event: 2023-11-15 08:30, bitmap {code, provider, location, contract pointer} + transit_calypso_record_t *e = &card.events[0]; + e->len = TRANSIT_CALYPSO_REC_LEN; + off = 0; + transit_set_bits_be(e->data, e->len, off, 14, 9814); + off += 14; + transit_set_bits_be(e->data, e->len, off, 11, 510); + off += 11; + transit_set_bits_be(e->data, e->len, off, 28, (1u << 2) | (1u << 4) | (1u << 8) | (1u << 25)); + off += 28; + transit_set_bits_be(e->data, e->len, off, 8, 0x31); + off += 8; + transit_set_bits_be(e->data, e->len, off, 8, NAVIGO_PROVIDER_RATP); + off += 8; + transit_set_bits_be(e->data, e->len, off, 16, (8u << 9) | (5u << 4)); + off += 16; + transit_set_bits_be(e->data, e->len, off, 5, 1); + card.event_count = 1; + + bool ok = true; + ok &= transit_check("network id", calypso_intercode_network(&card), net); + ok &= transit_check("navigo detect", is_valid_navigo_card(&card), navigo); + ok &= transit_check("intercode detect", is_valid_intercode_card(&card), navigo == false); + + en1545_parsed_t env; + (void)en1545_parse(card.env.data, card.env.len, 0, &calypso_intercode_env, &env); + char buf[32]; + en1545_date_str(buf, sizeof(buf), en1545_get_or(&env, "EnvApplicationValidityEndDate", 0, 0)); + ok &= transit_check_str("env validity end", buf, "2024-05-19"); + + en1545_parsed_t list; + (void)en1545_parse(cl->data, cl->len, 0, &intercode_contract_list, &list); + ok &= transit_check("list pointer", en1545_get_or(&list, "ContractsPointer", 0, 0), 1); + + en1545_parsed_t cp; + (void)en1545_parse(c->data, c->len, 0, &contract_ff, &cp); + ok &= transit_check("contract tariff", en1545_get_or(&cp, "ContractTariff", 0, 0), 20480); + en1545_date_str(buf, sizeof(buf), en1545_get_or(&cp, "ContractEndDate", 0, 0)); + ok &= transit_check_str("contract end", buf, "2023-12-01"); + intercode_zones_str(buf, sizeof(buf), 0x801F); + ok &= transit_check_str("zones", buf, "1,2,3,4,5,16"); + + uint32_t ctr = 0, left = 0, total = 0; + bool has = calypso_contract_counter(&card, 1, &ctr); + ok &= transit_check("trips decoded", intercode_trips(&cp, navigo, has, ctr, &left, &total), true); + ok &= transit_check("trips left", left, 7); + ok &= transit_check("trips total", total, 10); + + en1545_parsed_t ep; + (void)en1545_parse(e->data, e->len, 0, &intercode_event, &ep); + en1545_datetime_str(buf, sizeof(buf), en1545_get_or(&ep, "EventDate", 0, 0), en1545_get_or(&ep, "EventTime", 0, 0)); + ok &= transit_check_str("event time", buf, "2023-11-15 08:30"); + ok &= transit_check("event location", en1545_get_or(&ep, "EventLocationId", 0, 0), (8u << 9) | (5u << 4)); + ok &= transit_check("event contract ptr", en1545_get_or(&ep, "EventContractPointer", 0, 0), 1); + + // card number from ICC bytes 16..19, falling back to bytes 0..3 + card.icc.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.icc.data, card.icc.len, 0, 32, 87654321); + ok &= transit_check("icc number fallback", calypso_icc_card_number(&card, buf, sizeof(buf)), true); + ok &= transit_check_str("icc bytes 0..3", buf, "87654321"); + transit_set_bits_be(card.icc.data, card.icc.len, 128, 32, 12345678); + (void)calypso_icc_card_number(&card, buf, sizeof(buf)); + ok &= transit_check_str("icc bytes 16..19", buf, "12345678"); + + if (ok) { + ok &= (intercode_print(&card, navigo) == PM3_SUCCESS); + } + return ok; +} + +int navigo_selftest(void) { + PrintAndLogEx(INFO, ""); + PrintAndLogEx(INFO, "Testing Navigo decode"); + bool ok = en1545_selftest(); + ok &= intercode_selftest_common(true); + return transit_selftest_result("Navigo", ok); +} + +int intercode_selftest(void) { + PrintAndLogEx(INFO, ""); + PrintAndLogEx(INFO, "Testing Intercode decode"); + return transit_selftest_result("Intercode", intercode_selftest_common(false)); +} diff --git a/client/src/parsers/parseintercode.h b/client/src/parsers/parseintercode.h new file mode 100644 index 000000000..2a636d23a --- /dev/null +++ b/client/src/parsers/parseintercode.h @@ -0,0 +1,42 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Intercode (French Calypso networks) parser, Navigo included +// +// Layouts from Metrodroid transit/intercode (GPLv3), cross checked against +// Metroflip api/calypso/cards/intercode.c (GPLv3). +//----------------------------------------------------------------------------- + +#ifndef PARSEINTERCODE_H__ +#define PARSEINTERCODE_H__ + +#include "common.h" +#include "parsetransit.h" + +// Country 250 (France) in the top 12 bits of EnvNetworkId +#define INTERCODE_COUNTRY_FRANCE 0x250 +#define INTERCODE_NETWORK_NAVIGO 0x250901 + +// Navigo, Ile-de-France Mobilites +bool is_valid_navigo_card(const transit_calypso_card_t *card); +int navigo_parser_parse(const transit_calypso_card_t *card); +int navigo_selftest(void); + +// Any other French Intercode network +bool is_valid_intercode_card(const transit_calypso_card_t *card); +int intercode_parser_parse(const transit_calypso_card_t *card); +int intercode_selftest(void); + +#endif diff --git a/client/src/parsers/parseopus.c b/client/src/parsers/parseopus.c new file mode 100644 index 000000000..a6557e274 --- /dev/null +++ b/client/src/parsers/parseopus.c @@ -0,0 +1,280 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Opus (Montreal / Quebec) Calypso parser +//----------------------------------------------------------------------------- + +#include "parseopus.h" + +#include +#include + +#include "ui.h" // PrintAndLogEx +#include "parsecalypso.h" + +//----------------------------------------------------------------------------- +// Layouts, the unknown fields are only there to keep the offsets right +//----------------------------------------------------------------------------- + +static const en1545_field_t oc_dates[] = { + EN1545_INT("ContractStartDate", 14), + EN1545_INT("ContractEndDate", 14), +}; + +static const en1545_field_t oc_tail[] = { + EN1545_INT("ContractUnknownB", 17), + EN1545_INT("ContractSaleDate", 14), + EN1545_INT("ContractSaleTime", 11), + EN1545_INT("ContractUnknownC", 36), + EN1545_INT("ContractStatus", 8), + EN1545_INT("ContractUnknownD", 36), +}; + +static const en1545_field_t oc_bitmap[] = { + EN1545_INT("ContractProvider", 8), + EN1545_INT("ContractTariff", 16), + EN1545_BITMAP(oc_dates), + EN1545_CONTAINER(oc_tail), +}; + +static const en1545_field_t oc_fields[] = { + EN1545_INT("ContractUnknownA", 3), + EN1545_BITMAP(oc_bitmap), +}; + +static const en1545_field_t opus_contract = EN1545_CONTAINER(oc_fields); + +static const en1545_field_t oe_data[] = { + EN1545_INT("EventFirstStampDate", 14), + EN1545_INT("EventFirstStampTime", 11), + EN1545_INT("EventDataSimulation", 1), + EN1545_INT("EventUnknownF", 4), + EN1545_INT("EventUnknownG", 4), + EN1545_INT("EventUnknownH", 4), + EN1545_INT("EventUnknownI", 4), +}; + +static const en1545_field_t oe_bitmap[] = { + EN1545_INT("EventUnknownA", 8), + EN1545_INT("EventUnknownB", 8), + EN1545_INT("EventServiceProvider", 8), + EN1545_INT("EventUnknownC", 16), + EN1545_INT("EventRouteNumber", 16), + EN1545_INT("EventUnknownD", 16), + EN1545_INT("EventUnknownE", 16), + EN1545_INT("EventContractPointer", 5), + EN1545_BITMAP(oe_data), +}; + +static const en1545_field_t oe_fields[] = { + EN1545_INT("EventDate", 14), + EN1545_INT("EventTime", 11), + EN1545_INT("EventUnknownX", 19), + EN1545_BITMAP(oe_bitmap), +}; + +static const en1545_field_t opus_event = EN1545_CONTAINER(oe_fields); + +static const char *opus_tariff_str(uint64_t tariff) { + switch (tariff) { + case 0xB1: + return "monthly subscription"; + case 0xB2: + case 0xC9: + return "weekly subscription"; + case 0x1C7: + return "single trips"; + default: + return "unknown"; + } +} + +//----------------------------------------------------------------------------- +// Printing +//----------------------------------------------------------------------------- + +static void opus_print_contract(const transit_calypso_card_t *card, uint8_t recno) { + en1545_parsed_t c; + const transit_calypso_record_t *rec = &card->contracts[recno - 1]; + (void)en1545_parse(rec->data, rec->len, 0, &opus_contract, &c); + + char label[24]; + char buf[32]; + char buf2[32]; + uint64_t v; + + uint64_t tariff = en1545_get_or(&c, "ContractTariff", 0, 0); + snprintf(label, sizeof(label), "Contract %u", recno); + transit_print_kv(label, "tariff " _YELLOW_("%03" PRIX64) " ( %s ), provider %" PRIu64, tariff, + opus_tariff_str(tariff), en1545_get_or(&c, "ContractProvider", 0, 0)); + + bool has_end = en1545_get(&c, "ContractEndDate", 0, &v); + if (en1545_get(&c, "ContractStartDate", 0, &v) || has_end) { + en1545_date_str(buf, sizeof(buf), en1545_get_or(&c, "ContractStartDate", 0, 0)); + en1545_date_str(buf2, sizeof(buf2), en1545_get_or(&c, "ContractEndDate", 0, 0)); + transit_print_kv(" Validity", _YELLOW_("%s") " .. " _YELLOW_("%s"), buf, buf2); + } + if (en1545_get(&c, "ContractSaleDate", 0, &v)) { + en1545_datetime_str(buf, sizeof(buf), v, en1545_get_or(&c, "ContractSaleTime", 0, 0)); + transit_print_kv(" Sold", "%s", buf); + } + if (en1545_get(&c, "ContractStatus", 0, &v)) { + transit_print_kv(" Status", "%02" PRIX64, v); + } + + // a counter without an end date is a trip count + uint32_t ctr; + if (calypso_contract_counter(card, recno, &ctr)) { + if (en1545_get_or(&c, "ContractEndDate", 0, 0) == 0) { + transit_print_kv(" Trips left", _GREEN_("%u"), ctr); + } else { + transit_print_kv(" Counter", "%06X", ctr); + } + } +} + +static void opus_print_event(const transit_calypso_card_t *card, uint8_t n) { + en1545_parsed_t e; + (void)en1545_parse(card->events[n].data, card->events[n].len, 0, &opus_event, &e); + + char when[32]; + char label[16]; + en1545_datetime_str(when, sizeof(when), en1545_get_or(&e, "EventDate", 0, 0), en1545_get_or(&e, "EventTime", 0, 0)); + snprintf(label, sizeof(label), "Event %u", n + 1); + transit_print_kv(label, _YELLOW_("%s") " provider %" PRIu64 ", route %" PRIu64 ", contract %" PRIu64, when, + en1545_get_or(&e, "EventServiceProvider", 0, 0), en1545_get_or(&e, "EventRouteNumber", 0, 0), + en1545_get_or(&e, "EventContractPointer", 0, 0)); + + uint64_t v; + if (en1545_get(&e, "EventFirstStampDate", 0, &v)) { + en1545_datetime_str(when, sizeof(when), v, en1545_get_or(&e, "EventFirstStampTime", 0, 0)); + transit_print_kv(" First stamp", "%s", when); + } +} + +bool is_valid_opus_card(const transit_calypso_card_t *card) { + return calypso_intercode_network(card) == OPUS_NETWORK_ID; +} + +int opus_parser_parse(const transit_calypso_card_t *card) { + if (is_valid_opus_card(card) == false) { + return PM3_EINVARG; + } + + transit_print_header("Opus (Montreal / Quebec)"); + calypso_print_serial(card, true); + + en1545_parsed_t env; + (void)en1545_parse(card->env.data, card->env.len, 0, &calypso_intercode_env, &env); + char buf[32]; + transit_print_kv("Env version", "%" PRIu64, en1545_get_or(&env, "EnvVersionNumber", 0, 0)); + transit_print_kv("Network", "%06X", OPUS_NETWORK_ID); + uint64_t v; + if (en1545_get(&env, "EnvApplicationValidityEndDate", 0, &v)) { + en1545_date_str(buf, sizeof(buf), v); + transit_print_kv("Valid until", _YELLOW_("%s"), buf); + } + + for (uint8_t i = 0; i < card->contract_count && i < TRANSIT_CALYPSO_MAX_CONTRACTS; i++) { + if (calypso_record_empty(&card->contracts[i]) == false) { + opus_print_contract(card, i + 1); + } + } + for (uint8_t i = 0; i < card->event_count && i < TRANSIT_CALYPSO_MAX_EVENTS; i++) { + if (calypso_record_empty(&card->events[i]) == false) { + opus_print_event(card, i); + } + } + return PM3_SUCCESS; +} + +//----------------------------------------------------------------------------- +// Self test, records built from the layouts above +//----------------------------------------------------------------------------- + +int opus_selftest(void) { + PrintAndLogEx(INFO, ""); + PrintAndLogEx(INFO, "Testing Opus decode"); + + transit_calypso_card_t card; + memset(&card, 0, sizeof(card)); + + // env: version 1, bitmap {network} + card.env.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.env.data, card.env.len, 0, 6, 1); + transit_set_bits_be(card.env.data, card.env.len, 6, 7, 0x01); + transit_set_bits_be(card.env.data, card.env.len, 13, 24, OPUS_NETWORK_ID); + + // contract: 3 unknown bits, bitmap {provider, tariff}, no dates -> trip counter + transit_calypso_record_t *c = &card.contracts[0]; + c->len = TRANSIT_CALYPSO_REC_LEN; + size_t off = 3; + transit_set_bits_be(c->data, c->len, off, 4, 0x3); + off += 4; + transit_set_bits_be(c->data, c->len, off, 8, 2); + off += 8; + transit_set_bits_be(c->data, c->len, off, 16, 0x1C7); + card.contract_count = 1; + + card.counters.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.counters.data, card.counters.len, 0, 24, 9); + + // event: 2023-11-15 17:45, bitmap {provider, route, contract pointer} + transit_calypso_record_t *e = &card.events[0]; + e->len = TRANSIT_CALYPSO_REC_LEN; + off = 0; + transit_set_bits_be(e->data, e->len, off, 14, 9814); + off += 14; + transit_set_bits_be(e->data, e->len, off, 11, 1065); + off += 11 + 19; + transit_set_bits_be(e->data, e->len, off, 9, (1u << 2) | (1u << 4) | (1u << 7)); + off += 9; + transit_set_bits_be(e->data, e->len, off, 8, 2); + off += 8; + transit_set_bits_be(e->data, e->len, off, 16, 747); + off += 16; + transit_set_bits_be(e->data, e->len, off, 5, 1); + card.event_count = 1; + + bool ok = true; + ok &= transit_check("detect", is_valid_opus_card(&card), true); + + en1545_parsed_t cp; + (void)en1545_parse(c->data, c->len, 0, &opus_contract, &cp); + ok &= transit_check("contract provider", en1545_get_or(&cp, "ContractProvider", 0, 0), 2); + ok &= transit_check("contract tariff", en1545_get_or(&cp, "ContractTariff", 0, 0), 0x1C7); + ok &= transit_check("no end date", en1545_get(&cp, "ContractEndDate", 0, NULL), false); + + en1545_parsed_t ep; + (void)en1545_parse(e->data, e->len, 0, &opus_event, &ep); + char buf[32]; + en1545_datetime_str(buf, sizeof(buf), en1545_get_or(&ep, "EventDate", 0, 0), en1545_get_or(&ep, "EventTime", 0, 0)); + ok &= transit_check_str("event time", buf, "2023-11-15 17:45"); + ok &= transit_check("event route", en1545_get_or(&ep, "EventRouteNumber", 0, 0), 747); + ok &= transit_check("event contract ptr", en1545_get_or(&ep, "EventContractPointer", 0, 0), 1); + + // no ICC record, the FCI serial is used instead + ok &= transit_check("no icc, no card number", calypso_icc_card_number(&card, buf, sizeof(buf)), false); + + // an Intercode card must not be taken for Opus + transit_set_bits_be(card.env.data, card.env.len, 13, 24, 0x250901); + ok &= transit_check("rejects Navigo env", is_valid_opus_card(&card), false); + transit_set_bits_be(card.env.data, card.env.len, 13, 24, OPUS_NETWORK_ID); + + if (ok) { + ok &= (opus_parser_parse(&card) == PM3_SUCCESS); + } + return transit_selftest_result("Opus", ok); +} diff --git a/client/src/parsers/parseopus.h b/client/src/parsers/parseopus.h new file mode 100644 index 000000000..d14300fdf --- /dev/null +++ b/client/src/parsers/parseopus.h @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Opus (Montreal / Quebec) Calypso parser +// +// Layouts from Metrodroid transit/opus (GPLv3). +//----------------------------------------------------------------------------- + +#ifndef PARSEOPUS_H__ +#define PARSEOPUS_H__ + +#include "common.h" +#include "parsetransit.h" + +// Country 124 (Canada), network 001, Intercode style environment +#define OPUS_NETWORK_ID 0x124001 + +bool is_valid_opus_card(const transit_calypso_card_t *card); +int opus_parser_parse(const transit_calypso_card_t *card); +int opus_selftest(void); + +#endif diff --git a/client/src/parsers/parseravkav.c b/client/src/parsers/parseravkav.c new file mode 100644 index 000000000..6f16465e3 --- /dev/null +++ b/client/src/parsers/parseravkav.c @@ -0,0 +1,340 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Rav-Kav (Israel) Calypso parser +//----------------------------------------------------------------------------- + +#include "parseravkav.h" + +#include +#include + +#include "ui.h" // PrintAndLogEx +#include "parsecalypso.h" + +// Event and contract times are seconds since 1997-01-01 UTC +#define RAVKAV_SECS_TO_1997 ((int64_t)TRANSIT_DAYS_TO_1997 * 86400) + +#define RAVKAV_EVENT_CANCELLED 9 + +//----------------------------------------------------------------------------- +// Layouts +//----------------------------------------------------------------------------- + +// Holder birth date and id number follow, left out on purpose +static const en1545_field_t rk_env_fields[] = { + EN1545_INT("EnvVersionNumber", 3), + EN1545_INT("EnvNetworkId", 20), + EN1545_INT("EnvUnknownA", 26), + EN1545_INT("EnvApplicationIssueDate", 14), + EN1545_INT("EnvApplicationValidityEndDate", 14), + EN1545_INT("EnvPayMethod", 3), + EN1545_INT("HolderBirthDate", 32), + EN1545_INT("EnvUnknownB", 44), + EN1545_INT("HolderIdNumber", 30), +}; + +static const en1545_field_t ravkav_env = EN1545_CONTAINER(rk_env_fields); + +static const en1545_field_t rk_c_bitmap[] = { + EN1545_INT("ContractUnknownA", 5), + EN1545_INT("ContractRestrictCode", 5), + EN1545_INT("ContractRestrictDuration", 6), + EN1545_INT("ContractEndDate", 14), + EN1545_INT("ContractDuration", 8), + EN1545_INT("ContractUnknownB", 32), + EN1545_INT("ContractUnknownC", 6), + EN1545_INT("ContractUnknownD", 32), + EN1545_INT("ContractUnknownE", 32), +}; + +static const en1545_field_t rk_c_fields[] = { + EN1545_INT("ContractVersion", 3), + EN1545_INT("ContractStartDate", 14), + EN1545_INT("ContractProvider", 8), + EN1545_INT("ContractTariff", 11), + EN1545_INT("ContractSaleDate", 14), + EN1545_INT("ContractSaleDevice", 12), + EN1545_INT("ContractSaleNumber", 10), + EN1545_INT("ContractInterchange", 1), + EN1545_BITMAP(rk_c_bitmap), +}; + +static const en1545_field_t ravkav_contract = EN1545_CONTAINER(rk_c_fields); + +static const en1545_field_t rk_e_loc[] = { + EN1545_INT("EventLocationId", 16), + EN1545_INT("EventRouteNumber", 16), + EN1545_INT("EventStopEnRoute", 8), + EN1545_INT("EventUnknownA", 12), + EN1545_INT("EventVehicleId", 14), + EN1545_INT("EventUnknownB", 4), + EN1545_INT("EventUnknownC", 8), +}; + +static const en1545_field_t rk_e_fare[] = { + EN1545_INT("EventRouteSystem", 10), + EN1545_INT("EventFareCode", 8), + EN1545_INT("EventPriceAmount", 16), +}; + +static const en1545_field_t rk_e_ext[] = { + EN1545_CONTAINER(rk_e_fare), + EN1545_INT("EventUnknownD", 32), + EN1545_INT("EventUnknownE", 32), +}; + +static const en1545_field_t rk_e_fields[] = { + EN1545_INT("EventVersion", 3), + EN1545_INT("EventServiceProvider", 8), + EN1545_INT("EventContractPointer", 4), + EN1545_INT("EventCode", 8), + EN1545_INT("EventDateTime", 30), + EN1545_INT("EventTransferFlag", 1), + EN1545_INT("EventFirstStampDateTime", 30), + EN1545_INT("EventContractPrefs", 32), + EN1545_BITMAP(rk_e_loc), + EN1545_BITMAP(rk_e_ext), +}; + +static const en1545_field_t ravkav_event = EN1545_CONTAINER(rk_e_fields); + +//----------------------------------------------------------------------------- +// Printing +//----------------------------------------------------------------------------- + +static void ravkav_secs_str(char *out, size_t outlen, uint64_t secs) { + if (secs == 0) { + snprintf(out, outlen, "-"); + return; + } + transit_datetime_str(out, outlen, (int64_t)secs + RAVKAV_SECS_TO_1997); +} + +// Tariff bits 6..8 say what the contract counter holds +static uint8_t ravkav_counter_use(uint64_t tariff) { + return (uint8_t)((tariff >> 6) & 0x7); +} + +static void ravkav_print_contract(const transit_calypso_card_t *card, uint8_t recno) { + en1545_parsed_t c; + const transit_calypso_record_t *rec = &card->contracts[recno - 1]; + (void)en1545_parse(rec->data, rec->len, 0, &ravkav_contract, &c); + + char label[24]; + char buf[32]; + char buf2[32]; + uint64_t v; + + uint64_t tariff = en1545_get_or(&c, "ContractTariff", 0, 0); + snprintf(label, sizeof(label), "Contract %u", recno); + transit_print_kv(label, "tariff " _YELLOW_("%" PRIu64) "%s, provider %" PRIu64, tariff, + (tariff == 641) ? " ( generic trips )" : "", en1545_get_or(&c, "ContractProvider", 0, 0)); + + en1545_date_str(buf, sizeof(buf), en1545_get_or(&c, "ContractStartDate", 0, 0)); + if (en1545_get(&c, "ContractEndDate", 0, &v)) { + en1545_date_str(buf2, sizeof(buf2), v); + transit_print_kv(" Validity", _YELLOW_("%s") " .. " _YELLOW_("%s"), buf, buf2); + } else { + transit_print_kv(" Valid from", _YELLOW_("%s"), buf); + } + en1545_date_str(buf, sizeof(buf), en1545_get_or(&c, "ContractSaleDate", 0, 0)); + transit_print_kv(" Sold", "%s, device %" PRIu64 ", sale %" PRIu64, buf, + en1545_get_or(&c, "ContractSaleDevice", 0, 0), en1545_get_or(&c, "ContractSaleNumber", 0, 0)); + + uint32_t ctr; + if (calypso_contract_counter(card, recno, &ctr)) { + uint8_t use = ravkav_counter_use(tariff); + if (use == 3) { + transit_money_str(buf, sizeof(buf), ctr, 2, "ILS"); + transit_print_kv(" Balance", _GREEN_("%s"), buf); + } else if (use == 2) { + transit_print_kv(" Trips left", _GREEN_("%u"), ctr); + } else { + transit_print_kv(" Counter", "%06X", ctr); + } + } +} + +static void ravkav_print_event(const transit_calypso_card_t *card, uint8_t n) { + en1545_parsed_t e; + (void)en1545_parse(card->events[n].data, card->events[n].len, 0, &ravkav_event, &e); + + uint64_t code = en1545_get_or(&e, "EventCode", 0, 0); + if ((code & 0x0F) == RAVKAV_EVENT_CANCELLED) { + return; + } + + char when[32]; + char label[16]; + ravkav_secs_str(when, sizeof(when), en1545_get_or(&e, "EventDateTime", 0, 0)); + snprintf(label, sizeof(label), "Event %u", n + 1); + transit_print_kv(label, _YELLOW_("%s") " UTC %s, provider %" PRIu64 ", contract %" PRIu64, when, + calypso_event_action_str(code & 0x0F), en1545_get_or(&e, "EventServiceProvider", 0, 0), + en1545_get_or(&e, "EventContractPointer", 0, 0)); + + uint64_t v; + if (en1545_get(&e, "EventRouteNumber", 0, &v)) { + transit_print_kv(" Route", "%" PRIu64, v); + } + if (en1545_get(&e, "EventLocationId", 0, &v)) { + transit_print_kv(" Location", "%" PRIu64, v); + } + if (en1545_get(&e, "EventPriceAmount", 0, &v)) { + char buf[32]; + transit_money_str(buf, sizeof(buf), (int64_t)v, 2, "ILS"); + transit_print_kv(" Price", "%s", buf); + } +} + +bool is_valid_ravkav_card(const transit_calypso_card_t *card) { + if (card == NULL || card->env.len < 3) { + return false; + } + uint32_t net = (uint32_t)transit_bits_be(card->env.data, card->env.len, 3, 20); + return (net >> 8) == RAVKAV_COUNTRY_ISRAEL; +} + +int ravkav_parser_parse(const transit_calypso_card_t *card) { + if (is_valid_ravkav_card(card) == false) { + return PM3_EINVARG; + } + + en1545_parsed_t env; + (void)en1545_parse(card->env.data, card->env.len, 0, &ravkav_env, &env); + + transit_print_header("Rav-Kav (Israel)"); + calypso_print_serial(card, false); + + char buf[32]; + transit_print_kv("Env version", "%" PRIu64, en1545_get_or(&env, "EnvVersionNumber", 0, 0)); + transit_print_kv("Network", "%05" PRIX64, en1545_get_or(&env, "EnvNetworkId", 0, 0)); + en1545_date_str(buf, sizeof(buf), en1545_get_or(&env, "EnvApplicationIssueDate", 0, 0)); + transit_print_kv("Issued", "%s", buf); + en1545_date_str(buf, sizeof(buf), en1545_get_or(&env, "EnvApplicationValidityEndDate", 0, 0)); + transit_print_kv("Valid until", _YELLOW_("%s"), buf); + transit_print_kv("Card type", "%s", (en1545_get_or(&env, "HolderIdNumber", 0, 0) != 0) ? "personal" : "anonymous"); + + for (uint8_t i = 0; i < card->contract_count && i < TRANSIT_CALYPSO_MAX_CONTRACTS; i++) { + if (calypso_record_empty(&card->contracts[i]) == false) { + ravkav_print_contract(card, i + 1); + } + } + for (uint8_t i = 0; i < card->event_count && i < TRANSIT_CALYPSO_MAX_EVENTS; i++) { + if (calypso_record_empty(&card->events[i]) == false) { + ravkav_print_event(card, i); + } + } + return PM3_SUCCESS; +} + +//----------------------------------------------------------------------------- +// Self test, records built from the layouts above +//----------------------------------------------------------------------------- + +int ravkav_selftest(void) { + PrintAndLogEx(INFO, ""); + PrintAndLogEx(INFO, "Testing Rav-Kav decode"); + + transit_calypso_card_t card; + memset(&card, 0, sizeof(card)); + + // env: version 1, network 37602, issued 2020-01-01, valid to 2026-01-01 + card.env.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.env.data, card.env.len, 0, 3, 1); + transit_set_bits_be(card.env.data, card.env.len, 3, 20, 0x37602); + transit_set_bits_be(card.env.data, card.env.len, 49, 14, 8400); + transit_set_bits_be(card.env.data, card.env.len, 63, 14, 10592); + + // contract: stored value, tariff counter use 3 + transit_calypso_record_t *c = &card.contracts[0]; + c->len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(c->data, c->len, 3, 14, 9800); + transit_set_bits_be(c->data, c->len, 17, 8, 3); + transit_set_bits_be(c->data, c->len, 25, 11, (3u << 6) | 1); + card.contract_count = 1; + + // Rav-Kav has no 2069, the purse sits in the contract's own counter 202A + card.contract_counters[0].len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(card.contract_counters[0].data, card.contract_counters[0].len, 0, 24, 4250); + + // event: entry at 2023-11-15 06:30:00 UTC, bitmap {route}, price 5.50 + transit_calypso_record_t *e = &card.events[0]; + e->len = TRANSIT_CALYPSO_REC_LEN; + size_t off = 3; + transit_set_bits_be(e->data, e->len, off, 8, 3); + off += 8; + transit_set_bits_be(e->data, e->len, off, 4, 1); + off += 4; + transit_set_bits_be(e->data, e->len, off, 8, 0x01); + off += 8; + transit_set_bits_be(e->data, e->len, off, 30, (9814ull * 86400) + (6 * 3600) + (30 * 60)); + off += 30 + 1 + 30 + 32; + transit_set_bits_be(e->data, e->len, off, 7, 0x02); + off += 7; + transit_set_bits_be(e->data, e->len, off, 16, 480); + off += 16; + transit_set_bits_be(e->data, e->len, off, 3, 0x01); + off += 3 + 10 + 8; + transit_set_bits_be(e->data, e->len, off, 16, 550); + card.event_count = 1; + + bool ok = true; + ok &= transit_check("detect", is_valid_ravkav_card(&card), true); + + en1545_parsed_t env; + (void)en1545_parse(card.env.data, card.env.len, 0, &ravkav_env, &env); + char buf[32]; + en1545_date_str(buf, sizeof(buf), en1545_get_or(&env, "EnvApplicationValidityEndDate", 0, 0)); + ok &= transit_check_str("env validity end", buf, "2026-01-01"); + + en1545_parsed_t cp; + (void)en1545_parse(c->data, c->len, 0, &ravkav_contract, &cp); + ok &= transit_check("counter use", ravkav_counter_use(en1545_get_or(&cp, "ContractTariff", 0, 0)), 3); + ok &= transit_check("contract provider", en1545_get_or(&cp, "ContractProvider", 0, 0), 3); + + en1545_parsed_t ep; + (void)en1545_parse(e->data, e->len, 0, &ravkav_event, &ep); + ravkav_secs_str(buf, sizeof(buf), en1545_get_or(&ep, "EventDateTime", 0, 0)); + ok &= transit_check_str("event time", buf, "2023-11-15 06:30:00"); + ok &= transit_check("event route", en1545_get_or(&ep, "EventRouteNumber", 0, 0), 480); + ok &= transit_check("event price", en1545_get_or(&ep, "EventPriceAmount", 0, 0), 550); + + uint32_t ctr = 0; + ok &= transit_check("own counter used", calypso_contract_counter(&card, 1, &ctr), true); + ok &= transit_check("own counter value", ctr, 4250); + ok &= transit_check("no counter for 2", calypso_contract_counter(&card, 2, &ctr), false); + + // 2069 wins when both are present + transit_calypso_card_t both = card; + both.counters.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(both.counters.data, both.counters.len, 0, 24, 77); + (void)calypso_contract_counter(&both, 1, &ctr); + ok &= transit_check("2069 first", ctr, 77); + + // a French Intercode environment must not match + transit_calypso_card_t fr; + memset(&fr, 0, sizeof(fr)); + fr.env.len = TRANSIT_CALYPSO_REC_LEN; + transit_set_bits_be(fr.env.data, fr.env.len, 0, 6, 1); + transit_set_bits_be(fr.env.data, fr.env.len, 6, 7, 0x01); + transit_set_bits_be(fr.env.data, fr.env.len, 13, 24, 0x250901); + ok &= transit_check("rejects Navigo env", is_valid_ravkav_card(&fr), false); + + if (ok) { + ok &= (ravkav_parser_parse(&card) == PM3_SUCCESS); + } + return transit_selftest_result("Rav-Kav", ok); +} diff --git a/client/src/parsers/parseravkav.h b/client/src/parsers/parseravkav.h new file mode 100644 index 000000000..182dfa597 --- /dev/null +++ b/client/src/parsers/parseravkav.h @@ -0,0 +1,36 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// 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. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// Rav-Kav (Israel) Calypso parser +// +// Layouts from Metrodroid transit/ravkav (GPLv3), cross checked against +// Metroflip api/calypso/cards/ravkav.c (GPLv3). +//----------------------------------------------------------------------------- + +#ifndef PARSERAVKAV_H__ +#define PARSERAVKAV_H__ + +#include "common.h" +#include "parsetransit.h" + +// Rav-Kav keeps its own environment: version 3 bits, then country 376 and +// an 8 bit issuer as a 20 bit network id +#define RAVKAV_COUNTRY_ISRAEL 0x376 + +bool is_valid_ravkav_card(const transit_calypso_card_t *card); +int ravkav_parser_parse(const transit_calypso_card_t *card); +int ravkav_selftest(void); + +#endif diff --git a/client/src/parsers/parsetransit.c b/client/src/parsers/parsetransit.c index b919f9cbc..b50868609 100644 --- a/client/src/parsers/parsetransit.c +++ b/client/src/parsers/parsetransit.c @@ -27,6 +27,7 @@ #include "parsebip.h" #include "parsecharlie.h" #include "parseclipper.h" +#include "parseintercode.h" #include "parseintertic.h" #include "parseitso.h" #include "parsekazan.h" @@ -36,7 +37,9 @@ #include "parsenol.h" #include "parseoctopus.h" #include "parseopal.h" +#include "parseopus.h" #include "parseplantain.h" +#include "parseravkav.h" #include "parserenfe.h" #include "parsesmartrider.h" #include "parsesuica.h" @@ -386,6 +389,10 @@ static const transit_felica_parser_t felica_parsers[] = { }; static const transit_calypso_parser_t calypso_parsers[] = { + {"Navigo", is_valid_navigo_card, navigo_parser_parse, navigo_selftest}, + {"Intercode", is_valid_intercode_card, intercode_parser_parse, intercode_selftest}, + {"Opus", is_valid_opus_card, opus_parser_parse, opus_selftest}, + {"Rav-Kav", is_valid_ravkav_card, ravkav_parser_parse, ravkav_selftest}, {NULL, NULL, NULL, NULL} }; diff --git a/client/src/parsers/parsetransit.h b/client/src/parsers/parsetransit.h index e59898d99..34d0a631c 100644 --- a/client/src/parsers/parsetransit.h +++ b/client/src/parsers/parsetransit.h @@ -131,11 +131,13 @@ typedef struct { typedef struct { uint8_t serial[8]; bool has_serial; + transit_calypso_record_t icc; // SFI 02, 0002 transit_calypso_record_t env; // SFI 07, 2001 transit_calypso_record_t contract_list; // SFI 1E, 2050 transit_calypso_record_t counters; // SFI 19, 2069 uint8_t contract_count; - transit_calypso_record_t contracts[TRANSIT_CALYPSO_MAX_CONTRACTS]; // SFI 09, 2020 + transit_calypso_record_t contracts[TRANSIT_CALYPSO_MAX_CONTRACTS]; // SFI 09 then 06, 2020 / 2030 + transit_calypso_record_t contract_counters[4]; // SFI 0A..0D, 202A..202D uint8_t event_count; transit_calypso_record_t events[TRANSIT_CALYPSO_MAX_EVENTS]; // SFI 08, 2010 } transit_calypso_card_t;