transit parsers: Calypso card systems

Run from hf calypso info. parsecalypso.c is a table driven EN 1545 walker
(fixed fields, presence bitmaps, repeated containers) after Metrodroid's
En1545Parser, shared by the network parsers:

  Navigo (Paris, 250901)          Metrodroid transit/intercode
  Intercode, other 250xxx         Metrodroid transit/intercode
  Opus (Montreal, 124001)         Metrodroid transit/opus
  Rav-Kav (Israel, 376xxx)        Metrodroid transit/ravkav

hf calypso info additionally hands over the ICC record, so Intercode and
Opus print the card number as issued, reads the second contracts file
(SFI 06) after a full first one, and reads the per contract counters at
SFI 0A..0D, where Rav-Kav keeps its stored value.

Holder data is deliberately not decoded. Self tests are synthetic,
neither Metrodroid nor Metroflip ships real record hex for these.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
iceman1001andClaude Opus 5.5 committed 2026-11-10 10:05:13 +07:00
1 parent 8b2f4f9cf6
commit 070972f47e
14 files changed
+1925 -3

No files matched your search

+4
View File
@@ -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
+4
View File
@@ -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 \
+4
View File
@@ -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
+19 -2
View File
@@ -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));
+333
View File
@@ -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 <stdio.h>
#include <string.h>
#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;
}
+95
View File
@@ -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
+724
View File
@@ -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 <stdio.h>
#include <string.h>
#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));
}
+42
View File
@@ -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
+280
View File
@@ -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 <stdio.h>
#include <string.h>
#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);
}
+34
View File
@@ -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
+340
View File
@@ -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 <stdio.h>
#include <string.h>
#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);
}
+36
View File
@@ -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
+7
View File
@@ -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}
};
+3 -1
View File
@@ -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;