static rfid_status icdrec_hf_reader_authenticate_mifare_classic(struct rfid_device * thiz, rfid_target * tag,uint8_t block, uint8_t key_type,void * custom)
{
rfid_status status= RFID_ESUCCESS;
RDBG("\n");
return status;
}
static struct dst_entry *ip6_dst_reroute(struct dst_entry *dst, struct sk_buff *skb)
{
/*
* FIXME
*/
RDBG(("ip6_dst_reroute(%p,%p)[%p] (AIEEE)\n", dst, skb,
__builtin_return_address(0)));
return NULL;
}
static rfid_status icdrec_hf_reader_writekey_to_eeprom(struct rfid_device * thiz, uint8_t eeprom_index, uint8_t key[6])
{
RDBG("\n");
if(!thiz || !key || eeprom_index >= HF_READER_MAX_EEPROM_KEY_STORED) return RFID_EINARG;
uint8_t metadata[7];
memcpy(metadata,key,6);
metadata[6]= eeprom_index;
return icdrec_hf_reader_generic_command(thiz,HF_READER_CMD_WRITEKEYEEPROM_MFC,metadata,7,0);
}
/*static */rfid_status icdrec_hf_reader_generic_command(struct rfid_device * thiz, uint8_t cmd,uint8_t * pmeta,size_t metalen,size_t resp_metalen)
{
if(!thiz || thiz->state != RFID_READER_AVAILABLE) {
return RFID_EINARG;
}
rfid_status status= RFID_ESUCCESS ;
//TODO: Test
HF_READER_NEW_REQ_PACKAGE(req,metalen);
GET_SZ_BUILT(req) = icdrec_hf_reader_build_package(cmd,pmeta,metalen,GET_PTR(req),GET_LEN(req));
RDBG(" CMD: 0x%X\n",cmd);
RFID_HEXDUMP(GET_PTR(req),GET_LEN(req),"pkg",0);
HF_READER_NEW_RESP_PACKAGE(res,resp_metalen);
status = icdrec_hf_reader_transceive_bytes(thiz,GET_PTR(req),GET_SZ_BUILT(req),GET_PTR(res),GET_LEN(res),&GET_SZ_RES(res),20);
switch (status) {
case RFID_ESUCCESS:
case RFID_EACK:
RDBG("Success\n");
break;
#if 1
case RFID_EIO:
RFATAL("IO error\n");
break;
case RFID_ENAK:
RFATAL("NAK error\n");
break;
case RFID_ETIMEOUT:
RFATAL("Time out\n");
break;
case RFID_ERESP:
RFATAL("Failed responding\n");
break;
#endif
default:
RFATAL("Unknown error\n");
break;
}
CLEAR_WARNING(req);
return status;
}
int main(int argc,char ** argv)
{
RDBG("\n");
rfid_device * rd= rfid_new_device(RFID_READER_HF_READER_ICDREC,RFID_READER_BUS_UART,(void *)argv[1]);
if(rd){
RDBG("\n");
if(rfid_init(rd) != RFID_ESUCCESS) return -1;
rfid_poll_target(rd);
#if 1
mifare_tag tag;
memset(&tag,0,sizeof(mifare_tag));
mifare_get_tag(rd,&tag);
tag.tag.type = MIFARE_CLASSIC_1K;
tag.tag.uid_len =4;
tag.reader_handler = rd;
mifare_classic_register_eeprom_key(&tag,1,MFC_KEY_A,31);
// mifare_classic_deregister_eeprom_key(&tag,1,MFC_KEY_A);
mifare_classic_authenticate(&tag,1,NULL,MFC_KEY_A);
#endif
rfid_deinit(rd);
}
RDBG("\n");
return 0;
}
static rfid_status icdrec_hf_reader_poll_target(struct rfid_device * thiz)
{
if(!thiz || thiz->state != RFID_READER_AVAILABLE) {
return RFID_EINARG;
}
//TODO: Test
#if 0
uint8_t pbtTx[1]={0x7F | 0x80},pbtRx[1];
size_t rxsz;
icdrec_hf_reader_write(thiz,pbtTx,1);
icdrec_hf_reader_read(thiz,pbtRx,&rxsz,1,1);
if(rxsz > 0){
RDBG("0x%X\n",pbtRx[0]);
}
#else
return icdrec_hf_reader_generic_command_no_meta(thiz,HF_READER_CMD_REQA);
#endif
}
rfid_status mifare_classic_authenticate (mifare_tag *tag, const mifare_classic_block_number block, const mifare_classic_key key, const mifare_classic_key_type key_type)
{
MIFARE_CLASSIC_ACTIVE_ASSERT(tag);
rfid_status status = RFID_ESUCCESS;
uint8_t sector =0;
// uint8_t trailer_blk =0;
switch (tag->reader_handler->reader_type) {
#if (READERS_SUPPORTED & READER_HF_READER_ICDREC)
case RFID_READER_HF_READER_ICDREC:
//FIXME: Only support mifare classic 1K
sector = MFC_SECTOR_OF_BLK(block);
if( tag->reader_handler->support_auth_crypto_1
&& tag->eeprom_used[sector + (key_type == MFC_KEY_A) ? 0:1] == 1
&& tag->eeprom_index[sector + (key_type == MFC_KEY_A) ? 0:1] < tag->reader_handler->max_eeprom_key
&& tag->reader_handler->rfid_authenticate_mifare_classic
&& tag->reader_handler->rfid_loadkey_from_eeprom
)
{
status=tag->reader_handler->rfid_loadkey_from_eeprom(tag->reader_handler,tag->eeprom_index[sector + (key_type == MFC_KEY_A) ? 0:1]);
if(status == RFID_ESUCCESS || status == RFID_EACK) {
RDBG("%d, %d, %d, %d\n",block,sector,tag->eeprom_index[sector + (key_type == MFC_KEY_A) ? 0:1], key_type);
return tag->reader_handler->rfid_authenticate_mifare_classic(tag->reader_handler,&tag->tag,block,key_type,(void*)&tag->eeprom_index[sector + (key_type == MFC_KEY_A) ? 0:1]);
}
return status;
} else {
//FIXME: Custom command
}
break;
#endif
#if (READERS_SUPPORTED & READER_CLRC663)
case RFID_READER_CLRC663:
break;
#endif
default:
break;
}
return status;
}
static rfid_status icdrec_hf_reader_loadkey_from_eeprom(struct rfid_device * thiz, uint8_t eeprom_index)
{
if(!thiz || eeprom_index >= HF_READER_MAX_EEPROM_KEY_STORED) return RFID_EINARG;
RDBG("\n");
return icdrec_hf_reader_generic_command(thiz,HF_READER_CMD_LOADKEYEEPROM_MFC,&eeprom_index,1,0);
}
