static void boxkey_fn(const char *token, char *value, void *setting, FILE *f)
{
struct s_reader *rdr = setting;
if(value)
{
int32_t len = strlen(value);
if(len != 16 && len != 32)
{
memset(rdr->boxkey, 0, sizeof(rdr->boxkey));
}
else
{
if(key_atob_l(value, rdr->boxkey, len))
{
fprintf(stderr, "reader boxkey parse error, %s=%s\n", token, value);
memset(rdr->boxkey, 0, sizeof(rdr->boxkey));
}
}
return;
}
int32_t len = check_filled(rdr->boxkey, sizeof(rdr->boxkey));
if(len > 0)
{
if(len > 8) { len = 16; }
else { len = 8; }
char tmp[len * 2 + 1];
fprintf_conf(f, "boxkey", "%s\n", cs_hexdump(0, rdr->boxkey, len, tmp, sizeof(tmp)));
}
else if(cfg.http_full_cfg)
{ fprintf_conf(f, "boxkey", "\n"); }
}
int main(int argc, char **argv)
{
char *filename;
FILE *fd;
int left = (9*9)*9;
int count=0;
if (argc == 2) {
filename = argv[1];
} else {
filename = "fields.sud";
}
bf_backups = malloc(sizeof(struct bf_backups));
if (!(fd = fopen(filename, "r"))) {
printf("error opening file\n");
exit(1);
}
if(readfield(fd)) {
printf("error reading field\n");
exit(1);
}
if (initialize())
exit(1);
fill_all();
check_filled();
printfield(wfield, 1);
bruteforced = 0;
/* main loop */
while (left > 0) {
check_validity();
solve_run(&count);
check_validity();
left = get_left();
count++;
}
if (final_check()) {
winprintf(wtext, "\n\rSolved successfully\n\r");
} else {
winprintf(wtext, "\n\rThere are still some errors\n\r");
}
printfield(wfield, 1);
press_any_key();
endwin();
return(0);
}
static void rsakey_fn(const char *token, char *value, void *setting, FILE *f) {
struct s_reader *rdr = setting;
if (value) {
int32_t len = strlen(value);
if(len != 128 && len != 240) {
memset(rdr->rsa_mod, 0, 120);
} else {
if (key_atob_l(value, rdr->rsa_mod, len)) {
fprintf(stderr, "reader rsakey parse error, %s=%s\n", token, value);
memset(rdr->rsa_mod, 0, sizeof(rdr->rsa_mod));
}
}
return;
}
int32_t len = check_filled(rdr->rsa_mod, 120);
if (len > 0) {
if(len > 64) len = 120;
else len = 64;
char tmp[len*2+1];
fprintf_conf(f, "rsakey", "%s\n", cs_hexdump(0, rdr->rsa_mod, len, tmp, sizeof(tmp)));
} else if(cfg.http_full_cfg)
fprintf_conf(f, "rsakey", "\n");
}
void config_list_save_ex(FILE *f, const struct config_list *clist, void *config_data, int save_all,
bool (*check_func)(const struct config_list *clist, void *config_data, const char *setting))
{
const struct config_list *c;
for(c = clist; c->opt_type != OPT_UNKNOWN; c++)
{
void *var = config_data + c->var_offset;
if(check_func && c->opt_type != OPT_UNKNOWN)
{
if(!check_func(clist, config_data, c->config_name))
{ continue; }
}
switch(c->opt_type)
{
case OPT_INT8:
{
int8_t val = *(int8_t *)var;
if(save_all || val != c->def.d_int8)
{ fprintf_conf(f, c->config_name, "%d\n", val); }
continue;
}
case OPT_UINT8:
{
uint8_t val = *(uint8_t *)var;
if(save_all || val != c->def.d_uint8)
{ fprintf_conf(f, c->config_name, "%u\n", val); }
continue;
}
case OPT_INT32:
{
int32_t val;
memcpy(&val, var, sizeof(int32_t));
if(save_all || val != c->def.d_int32)
{ fprintf_conf(f, c->config_name, "%d\n", val); }
continue;
}
case OPT_UINT32:
{
uint32_t val;
memcpy(&val, var, sizeof(uint32_t));
if(save_all || val != c->def.d_uint32)
{ fprintf_conf(f, c->config_name, "%u\n", val); }
continue;
}
case OPT_STRING:
{
char **val = var;
if(save_all || !streq(*val, c->def.d_char))
{
fprintf_conf(f, c->config_name, "%s\n", *val ? *val : "");
}
continue;
}
case OPT_SSTRING:
{
char *val = var;
if(save_all || !streq(val, c->def.d_char))
{
fprintf_conf(f, c->config_name, "%s\n", val[0] ? val : "");
}
continue;
}
case OPT_HEX_ARRAY:
{
uint8_t *hex_array = var;
uint32_t ok = check_filled(hex_array, c->def.array_size);
if(save_all || ok)
{
fprintf_conf(f, c->config_name, "%s", ""); // it should not have \n at the end
if(ok)
{
for(ok = 0; ok < c->def.array_size; ok++)
{
fprintf(f, "%02X", hex_array[ok]);
}
}
fprintf(f, "\n");
}
continue;
}
case OPT_FUNC:
{
c->ops.process_fn((const char *)c->config_name, NULL, var, f);
continue;
}
case OPT_FUNC_EXTRA:
{
c->ops.process_fn_extra((const char *)c->config_name, NULL, var, c->def.d_extra, f);
continue;
}
case OPT_FIXUP_FUNC:
case OPT_SAVE_FUNC:
continue;
case OPT_UNKNOWN:
break;
}
}
}
static void mgencrypted_fn(const char *UNUSED(token), char *value, void *setting, FILE *UNUSED(f)) {
struct s_reader *rdr = setting;
if (value) {
uchar key[16];
uchar mac[6];
char tmp_dbg[13];
uchar *buf = NULL;
int32_t i, len = 0;
char *ptr, *saveptr1 = NULL;
memset(&key, 0, 16);
memset(&mac, 0, 6);
for (i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 2) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++) {
trim(ptr);
switch(i) {
case 0:
len = strlen(ptr) / 2 + (16 - (strlen(ptr) / 2) % 16);
if (!cs_malloc(&buf, len)) return;
key_atob_l(ptr, buf, strlen(ptr));
cs_log("enc %d: %s", len, ptr);
break;
case 1:
key_atob_l(ptr, mac, 12);
cs_log("mac: %s", ptr);
break;
}
}
if (!memcmp(mac, "\x00\x00\x00\x00\x00\x00", 6)) {
#if defined(__APPLE__) || defined(__FreeBSD__)
// no mac address specified so use mac of en0 on local box
struct ifaddrs *ifs, *current;
if (getifaddrs(&ifs) == 0)
{
for (current = ifs; current != 0; current = current->ifa_next)
{
if (current->ifa_addr->sa_family == AF_LINK && strcmp(current->ifa_name, "en0") == 0)
{
struct sockaddr_dl *sdl = (struct sockaddr_dl *)current->ifa_addr;
memcpy(mac, LLADDR(sdl), sdl->sdl_alen);
break;
}
}
freeifaddrs(ifs);
}
#elif defined(__SOLARIS__)
// no mac address specified so use first filled mac
int32_t j, sock, niccount;
struct ifreq nicnumber[16];
struct ifconf ifconf;
struct arpreq arpreq;
if ((sock=socket(AF_INET,SOCK_DGRAM,0)) > -1){
ifconf.ifc_buf = (caddr_t)nicnumber;
ifconf.ifc_len = sizeof(nicnumber);
if (!ioctl(sock,SIOCGIFCONF,(char*)&ifconf)){
niccount = ifconf.ifc_len/(sizeof(struct ifreq));
for(i = 0; i < niccount, ++i){
memset(&arpreq, 0, sizeof(arpreq));
((struct sockaddr_in*)&arpreq.arp_pa)->sin_addr.s_addr = ((struct sockaddr_in*)&nicnumber[i].ifr_addr)->sin_addr.s_addr;
if (!(ioctl(sock,SIOCGARP,(char*)&arpreq))){
for (j = 0; j < 6; ++j)
mac[j] = (unsigned char)arpreq.arp_ha.sa_data[j];
if(check_filled(mac, 6) > 0) break;
}
}
}
close(sock);
}
#else
// no mac address specified so use mac of eth0 on local box
int32_t fd = socket(PF_INET, SOCK_STREAM, 0);
struct ifreq ifreq;
memset(&ifreq, 0, sizeof(ifreq));
snprintf(ifreq.ifr_name, sizeof(ifreq.ifr_name), "eth0");
ioctl(fd, SIOCGIFHWADDR, &ifreq);
memcpy(mac, ifreq.ifr_ifru.ifru_hwaddr.sa_data, 6);
close(fd);
#endif
cs_debug_mask(D_TRACE, "Determined local mac address for mg-encrypted as %s", cs_hexdump(1, mac, 6, tmp_dbg, sizeof(tmp_dbg)));
}
static int32_t griffin_card_init(struct s_reader *rdr, ATR *newatr)
{
int32_t i;
get_atr
def_resp
if (atr_size < 10)
return ERROR;
// 0 1 2 3 4 5 6 7 8 9
// ATR: 3B 08 yy 01 xx xx xx xx 10 00
if (atr[0] != 0x3b || atr[1] != 0x08 || atr[3] != 0x01 || atr[9] != 0x00)
return ERROR;
if (!cs_malloc(&rdr->csystem_data, sizeof(struct griffin_data)))
return ERROR;
struct griffin_data *csystem_data = rdr->csystem_data;
rdr->nprov = 1;
memset(rdr->sa, 0, sizeof(rdr->sa));
memset(rdr->prid, 0, sizeof(rdr->prid));
memset(rdr->hexserial, 0, sizeof(rdr->hexserial));
rdr->caid = (0x55 << 8) | atr[2];
memcpy(rdr->hexserial, atr + 4, 4);
csystem_data->cmd_base = atr[8];
rdr_log_sensitive(rdr, "[griffin-reader] card detected, cmd_base: %02X caid: %04X hexserial: {%02X %02X %02X %02X}",
csystem_data->cmd_base,
rdr->caid,
rdr->hexserial[0], rdr->hexserial[1], rdr->hexserial[2], rdr->hexserial[3]
);
griffin_cmd(GRIFFIN_CMD_INIT, NULL, 0, 2);
csystem_data->cmd_base = cta_res[2]; // already set from ATR
griffin_cmd(GRIFFIN_CMD_GET_HEX_SERIAL, NULL, 0, 6);
memcpy(rdr->hexserial, cta_res + 2, 4);
char serial[16];
memset(serial, 0, sizeof(serial));
griffin_cmd(GRIFFIN_CMD_GET_ASCII_SERIAL, NULL, 0, 14);
memcpy(serial, cta_res + 2, 12);
griffin_cmd(GRIFFIN_CMD_GET_CAID, NULL, 0, 4);
rdr->caid = (cta_res[2] << 8) | cta_res[3];
griffin_cmd(GRIFFIN_CMD_GET_CARD_ADDRESS, NULL, 0, 48);
for (i = 1 ; i < CS_MAXPROV; i++) {
if (3 + (i * 16) + 4 > cta_lr)
break;
memcpy(rdr->sa[i - 1], cta_res + 3 + (i * 16), 4);
}
// Unknown commands
griffin_cmd(0x22, NULL, 0, 2);
griffin_cmd(0x10, NULL, 0, 2);
griffin_cmd(0x14, NULL, 0, 2);
//griffin_cmd(0x2a, NULL, 0, 2);
//griffin_cmd(0x30, NULL, 0, 2);
for (i = 0 ; i < CS_MAXPROV; i++) {
if (check_filled(rdr->sa[i], 4)) {
rdr_log_sensitive(rdr, "CAID: 0x%04X, Serial: {%s}, HexSerial: {%02X %02X %02X %02X} Addr: {%02X %02X %02X %02X}",
rdr->caid, serial,
rdr->hexserial[0], rdr->hexserial[1], rdr->hexserial[2], rdr->hexserial[3],
rdr->sa[i][0], rdr->sa[i][1], rdr->sa[i][2], rdr->sa[i][3]);
}
}
rdr_log(rdr, "Ready for requests.");
return OK;
}
void chk_reader(char *token, char *value, struct s_reader *rdr)
{
int32_t i;
char *ptr, *ptr2, *ptr3, *saveptr1 = NULL;
/*
* case sensitive first
*/
if (!strcmp(token, "device")) {
for (i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 3) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++) {
trim(ptr);
switch(i) {
case 0:
cs_strncpy(rdr->device, ptr, sizeof(rdr->device));
break;
case 1:
rdr->r_port = atoi(ptr);
break;
case 2:
rdr->l_port = atoi(ptr);
break;
}
}
return;
}
#ifdef WITH_LIBUSB
if (!strcmp(token, "device_out_endpoint")) {
if (strlen(value) > 0) {
sscanf(value, "0x%2X", &i);
rdr->device_endpoint = i;
} else {
rdr->device_endpoint = 0;
}
return;
}
#endif
if (!strcmp(token, "key")) {
if (strlen(value) == 0){
return;
} else if (key_atob_l(value, rdr->ncd_key, 28)) {
fprintf(stderr, "Configuration newcamd: Error in Key\n");
memset(rdr->ncd_key, 0, sizeof(rdr->ncd_key));
}
return;
}
if (!strcmp(token, "password")) {
cs_strncpy(rdr->r_pwd, value, sizeof(rdr->r_pwd));
return;
}
if (!strcmp(token, "user")) {
cs_strncpy(rdr->r_usr, value, sizeof(rdr->r_usr));
return;
}
#ifdef WEBIF
if (!strcmp(token, "description")) {
NULLFREE(rdr->description);
if(strlen(value) > 0 && cs_malloc(&rdr->description, strlen(value)+1, -1)){
cs_strncpy(rdr->description, value, strlen(value)+1);
}
return;
}
#endif
if (!strcmp(token, "mg-encrypted")) {
uchar key[16];
uchar mac[6];
char tmp_dbg[13];
uchar *buf = NULL;
int32_t len = 0;
memset(&key, 0, 16);
memset(&mac, 0, 6);
for (i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 2) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++) {
trim(ptr);
switch(i) {
case 0:
len = strlen(ptr) / 2 + (16 - (strlen(ptr) / 2) % 16);
if(!cs_malloc(&buf,len, -1)) return;
key_atob_l(ptr, buf, strlen(ptr));
cs_log("enc %d: %s", len, ptr);
break;
case 1:
key_atob_l(ptr, mac, 12);
cs_log("mac: %s", ptr);
break;
}
}
if (!memcmp(mac, "\x00\x00\x00\x00\x00\x00", 6)) {
#if defined(__APPLE__) || defined(__FreeBSD__)
// no mac address specified so use mac of en0 on local box
struct ifaddrs *ifs, *current;
if (getifaddrs(&ifs) == 0)
{
for (current = ifs; current != 0; current = current->ifa_next)
{
if (current->ifa_addr->sa_family == AF_LINK && strcmp(current->ifa_name, "en0") == 0)
{
struct sockaddr_dl *sdl = (struct sockaddr_dl *)current->ifa_addr;
memcpy(mac, LLADDR(sdl), sdl->sdl_alen);
break;
}
}
freeifaddrs(ifs);
}
#elif defined(__SOLARIS__)
// no mac address specified so use first filled mac
int32_t j, sock, niccount;
struct ifreq nicnumber[16];
struct ifconf ifconf;
struct arpreq arpreq;
if ((sock=socket(AF_INET,SOCK_DGRAM,0)) > -1){
ifconf.ifc_buf = (caddr_t)nicnumber;
ifconf.ifc_len = sizeof(nicnumber);
if (!ioctl(sock,SIOCGIFCONF,(char*)&ifconf)){
niccount = ifconf.ifc_len/(sizeof(struct ifreq));
for(i = 0; i < niccount, ++i){
memset(&arpreq, 0, sizeof(arpreq));
((struct sockaddr_in*)&arpreq.arp_pa)->sin_addr.s_addr = ((struct sockaddr_in*)&nicnumber[i].ifr_addr)->sin_addr.s_addr;
if (!(ioctl(sock,SIOCGARP,(char*)&arpreq))){
for (j = 0; j < 6; ++j)
mac[j] = (unsigned char)arpreq.arp_ha.sa_data[j];
if(check_filled(mac, 6) > 0) break;
}
}
}
close(sock);
}
