/**************************************************************************************
Function Name : main
Description : Read and Write the Password in the EEPROM
Parameters : commandline arguments
Return : NULL
**************************************************************************************/
int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[129]; /* room for dummy report ID */
int err;
if(argc < 2){
usage(argv[0]);
exit(1);
}
if((dev = openDevice()) == NULL)
exit(1);
if(strcasecmp(argv[1], "read") == 0){
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}else{
hexdump(buffer + 1, sizeof(buffer) - 1);
}
}else if(strcasecmp(argv[1], "write") == 0){
memset(buffer, 0, sizeof(buffer));
int i = 1;
while(*argv[2] != '\0'){
buffer[i] += *argv[2]++;
i++;
}
if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}else{
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[4]; /* room for dummy report ID */
int err;
if(argc < 2){
usage(argv[0]);
exit(1);
}
if((dev = openDevice()) == NULL)
exit(1);
if(strcasecmp(argv[1], "read") == 0){
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}else{
hexdump(buffer + 1, sizeof(buffer) - 1);
}
}else if(strcasecmp(argv[1], "write") == 0){
int i, pos;
memset(buffer, 0, sizeof(buffer));
for(pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++){
pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos);
}
if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}else{
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
/** Free an enumeration Linked List*/
void USBRL_API usb_io_free_device_list(struct usb_io_device_info *dilist)
{
struct usb_io_internal_s *p = (struct usb_io_internal_s *)dilist;
while ( p ) {
struct usb_io_internal_s *q = (struct usb_io_internal_s *)((pusb_io_device_info_t)p)->next;
if ( p->usbh && ((USBDEVHANDLE)(-1)) != p->usbh ) {
usbhidCloseDevice(p->usbh);
p->usbh = 0;
}
free(p);
p = q;
}
return;
}
HIDDevice::~HIDDevice()
{
if (hHIDDev != NULL)
usbhidCloseDevice(hHIDDev);
}
int main(int argc, char **argv)
{
int option = 0; // For getopt temp option
usbDevice_t *dev;
ucp_cmd_t buffer; //room for dummy report ID
int err;
//Initialize globalArgs before we get to work
globalArgs.rFlag = 0; //False
globalArgs.iFlag = 0; //False
globalArgs.wFlag = 0; //False
globalArgs.fFlag = 0; //False
globalArgs.pFlag = 0; //False
globalArgs.hashFlag = 0; //False
globalArgs.kFlag = 0; //False
strncpy(globalArgs.pin,"0000",sizeof(globalArgs.pin)); //Default pin
globalArgs.offset = 0; //Default
globalArgs.size = 512; //Default
globalArgs.fileName = NULL;
globalArgs.file = NULL;
//Check if no arguments at all
if(argc==1) printUsage(argv[0]);
//If there's some argument, parse them
while((option = getopt(argc, argv, "rwif:o:p:Pk:s:h?")) !=-1){
//Check option flags
switch(option){
case 'r':
globalArgs.rFlag = 1; //True
break;
case 'w':
globalArgs.wFlag = 1; //True
break;
case 'i':
globalArgs.iFlag = 1; //True
break;
case 'f':
globalArgs.fFlag = 1; //True
globalArgs.fileName = optarg;
printf("File: %s\n",globalArgs.fileName);
break;
case 'o':
globalArgs.offset = atoi(optarg);
break;
case 'p':
globalArgs.pFlag = 1; //True
strncpy(globalArgs.pin,optarg, sizeof(globalArgs.pin));
break;
case 'P':
globalArgs.hashFlag=1; //True
break;
case 'k':
globalArgs.kFlag = 1; //True
globalArgs.keyboard = optarg;
printf("Keyboard: %s\n", globalArgs.keyboard);
case 's':
globalArgs.size = atoi(optarg);
break;
case 'h':
case '?':
printUsage(argv[0]);
break;
//Unknown flag, don't know what to do
default:
//After getopt prints the error
printUsage(argv[0]);
break;
}
}
//Check that only one action is done at a time
if(globalArgs.rFlag + globalArgs.wFlag + globalArgs.iFlag > 1) printUsage(argv[0]);
//Check that not set PIN and read HASH are given at a time
if(globalArgs.pFlag + globalArgs.hashFlag > 1) printUsage(argv[0]);
//Check that if write from file to device, we are given a file and a pin to encrypt!
if(globalArgs.wFlag && !globalArgs.fFlag) printUsage(argv[0]);
if(globalArgs.wFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Also check pin for read flag
if(globalArgs.rFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Try to open the device, exit if no device present.
if((dev = openDevice()) == NULL) exit(1);
//Clean the buffer before working with it
memset((void*)&buffer, 0, sizeof(buffer));
//Check and perform the desired commands
if(globalArgs.rFlag){ //READ COMMAND
buffer.cmd = UCP_CMD_READ;
deviceRead.offset = globalArgs.offset;
deviceRead.size = globalArgs.size;
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Reading from the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.wFlag){ //WRITE COMMAND
buffer.cmd = UCP_CMD_WRITE;
deviceRead.offset = globalArgs.offset;
deviceRead.size = readXML(globalArgs.fileName);
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Writing to the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.iFlag){ //INFO COMMAND
buffer.cmd = UCP_CMD_INFO;
}else if(globalArgs.hashFlag){ //READ PIN HASH COMMAND
buffer.cmd = UCP_CMD_READ_PIN;
}else if(globalArgs.pFlag){ //SET PIN COMMAND
buffer.cmd = UCP_CMD_SET_PIN;
buffer.buff[0] = 16; //sizeof hash in bytes
}else if(globalArgs.kFlag){
buffer.cmd = UCP_CMD_KEYBOARD;
}
//Add a dummy report ID and send data to device
buffer.reportid = 2;
if((err = usbhidSetReport(dev, (char*)&buffer, sizeof(buffer))) != 0)
fprintf(stderr, "Error sending data to device: %s\n", usbErrorMessage(err));
//Read back report
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 2, (char*)&buffer, &len)) != 0)
{ //... if not OK, print error
fprintf(stderr, "Error reading data from device: %s\n", usbErrorMessage(err));
}
else //... if OK, do things :)
{
fprintf( stderr, "\nMemType CMD Response: ");
hexdump( (void*)&buffer.cmd, sizeof(buffer.cmd)+sizeof(buffer.buff));
fprintf( stderr, "Received data from the device: \n");
switch(buffer.cmd)
{
case UCP_CMD_RESET:
fprintf( stderr, "RESET\n");
break;
case UCP_CMD_READ:
fprintf( stderr, "READ\n");
cmdRead(dev, deviceRead.size);
break;
case UCP_CMD_WRITE:
fprintf( stderr, "WRITE\n");
cmdWrite(dev, flashMemory, deviceRead.size);
fprintf(stderr, "[ENCRYPTION TEST] only hexdump");
break;
case UCP_CMD_SET_PIN:
fprintf(stderr, "SET PIN\n");
cmdSetPin(dev);
break;
case UCP_CMD_READ_PIN:
fprintf(stderr, "READ PIN HASH\n");
cmdReadPinHash(dev);
break;
case UCP_CMD_KEYBOARD:
fprintf(stderr, "KEYBOARD\n");
cmdKeyboard(dev);
break;
case UCP_CMD_DATA:
fprintf( stderr, "DATA\n");
break;
case UCP_CMD_INFO:
fprintf( stderr, "sizeof(info) -> %lu\n", sizeof(deviceInfo));
memcpy((void*)&deviceInfo, (void*)buffer.buff, sizeof(deviceInfo));
/* Call info */
cmdInfo(&deviceInfo);
break;
case UCP_CMD_ERROR: //Wait! the device returned one error!
switch( (unsigned char) buffer.buff[0] )
{
case UCP_ERR:
fprintf( stderr, "GENERIC ERROR\n");
break;
case UCP_ERR_PACKET:
fprintf( stderr, "PACKET ERROR\n");
break;
case UCP_ERR_CMD:
fprintf( stderr, "CMD ERROR\n");
break;
case UCP_ERR_ADDR:
fprintf( stderr, "ADDR ERROR\n");
break;
case UCP_ERR_SIZE:
fprintf( stderr, "SIZE ERRROR\n");
break;
case UCP_ERR_PROTOCOL:
fprintf( stderr, "PROTOCOL ERROR\n");
break;
case UCP_ERR_LOCKED:
fprintf( stderr, "DEVICE LOCKED ERROR\n");
break;
default:
fprintf( stderr, "UNKNOWN ERROR\n");
}
break;
default:
fprintf( stderr, "UNKNOWN CMD ERROR\n");
}
}
usbhidCloseDevice(dev);
return 0;
}
void hidtool_close(usb_dev_handle *dev){
usbhidCloseDevice(dev);
}
int main(int argc, char **argv) {
usbDevice_t *dev;
char buffer[REPORT_SIZE]; /* room for dummy report ID */
int err;
if (argc < 2) {
usage(argv[0]);
exit(1);
}
if ((dev = openDevice()) == NULL)
exit(1);
if (strcasecmp(argv[1], "read") == 0) {
int len = sizeof(buffer);
if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
} else {
int16dump(buffer + 1, sizeof(buffer) - 1);
}
} else if (strcasecmp(argv[1], "write") == 0) {
int i, pos;
memset(buffer, 0, sizeof(buffer));
for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos);
}
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else if (strcasecmp(argv[1], "writeinput") == 0) {
int i, pos;
// read initial positions
int len = sizeof(buffer);
if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}
// int16dump(buffer + 1, sizeof(buffer) - 1);
char input[1000];
int scanfEof;
do {
scanfEof = scanf("%[^\n]%*c", input);
// printf("[%i] %s\n", scanfEof, input);
int16read(buffer + 1, input, sizeof(buffer) - 1);
// int16dump(buffer + 1, sizeof(buffer) - 1);
buffer[0] ++;
int retry = 0;
do {
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}
} while (err != 0 && retry ++ < 3);
if (err != 0) {
// try to reconnect
usbhidCloseDevice(dev);
dev = openDevice();
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}
}
//usleep(20000);
} while (scanfEof > 0);
// for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
// pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos);
// }
// if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
// fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else {
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
// Enum function for building list of devices
static
int enumfunc(USBDEVHANDLE usbh, void *context)
{
static const char vendorName[] = USB_IO16_VENDOR_NAME;
static const char productName[] = USB_IO16_NAME;
int err;
char buffer[128 * sizeof(short)]; // max USB string is 128 UTF-16 chars
int i;
struct usb_io_internal_s *q;
struct enumctx_s *ectx = (struct enumctx_s *)context;
err = usbhidGetVendorString(usbh, buffer, sizeof(buffer));
if ( err )
{
goto next;
}
if ( 0 != strcmp(buffer, vendorName) )
{
goto next;
}
err = usbhidGetProductString(usbh, buffer, sizeof(buffer));
if ( err )
{
goto next;
}
if ( 0 != strcmp(buffer, productName) )
{
goto next;
}
/* Check the unique ID: USB_IO16_ID_STR_LEN bytes at offset 1 (just after the report id) */
err = d16_read_rep(usbh, 0, buffer);
if ( err < 0 )
{
dbgprintf("Error reading report 0: %s\n", usbErrorMessage(err));
goto next;
}
for ( i = 1; i <= USB_IO16_ID_STR_LEN; i++ )
{
unsigned char x = (unsigned char)buffer[i];
if ( x <= 0x20 || x >= 0x7F )
{
dbgprintf("Bad USBIO16 ID string!\n");
goto next;
}
}
dbgprintf("Device %s found: ID=[%.*s]\n", productName, USB_IO16_ID_STR_LEN, &buffer[1]);
// allocate & save info
q = (struct usb_io_internal_s *)calloc(1, sizeof(struct usb_io_internal_s));
if ( !q ) {
dbgprintf("Malloc err\n");
goto next; //$$$ revise
}
/* keep this device, continue */
q->usbh = usbh;
memcpy(q->idstr, &buffer[1], USB_IO16_ID_STR_LEN);
q->type = 16; // put # of pins for now...
q->urdi.serial_number = (void*)&q->idstr[0];
q->urdi.device_path = (char*)g_dummyPath;
if ( !ectx->head ) {
ectx->head = q;
ectx->tail = q;
} else {
ectx->tail->urdi.next = (pusb_io_device_info_t)q;
ectx->tail = q;
}
++ectx->numdevs;
return 1;
next:
/* Continue search */
usbhidCloseDevice(usbh);
return 1;
}
int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[65]; /* room for dummy report ID */
int err;
char quiet = 0;
if ( argc < 2) {
usage(argv[0]);
exit(1);
}
if ( (dev = openDevice()) == NULL)
exit(1);
if ( strcasecmp(argv[1], "read") == 0) {
int len = sizeof(buffer);
if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
} else {
hexdump(buffer + 1, sizeof(buffer) - 1);
}
} else if ( strcasecmp(argv[1], "write") == 0) {
int i, pos;
bzero(buffer, sizeof(buffer));
for ( pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos);
}
/*
printf("%d\n",buffer[0]);
printf("%d\n",buffer[1]);
printf("%d\n",buffer[2]);
printf("%d\n",buffer[3]);
*/
//if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
if ( (err = usbhidSetReport(dev, buffer, pos)) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else if ( strcasecmp( argv[1], "interactive" ) == 0 ) {
int t = 0;
for ( t = 0; t < argc; t++ )
if ( strcasecmp(argv[t], "quiet") == 0 )
quiet = 1;
char *help = "q = exit\nr = read\nw = write <Data separated by spaces as decimal or hex (8bit unsigned)>\n";
if ( !quiet )
printf("%s",help);
char exit = 0;
while ( exit != 1 )
{
int nbytes = 350;
if ( !quiet )
printf("> ");
char *input;
input = (char *) malloc (nbytes + 1);
int cnt = getline(&input, &nbytes, stdin);
if ( strncasecmp(input, "q", 1) == 0 )
{
if ( !quiet )
printf("bye.\n");
exit = 1;
} else if ( strncasecmp(input, "r", 1) == 0 ) {
if ( !quiet )
printf("reading...\n");
int len = sizeof(buffer) ;
if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0)
{
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
exit = 1;
} else {
hexdump(buffer + 1, sizeof(buffer) - 1);
}
} else if ( strncasecmp(input, "w ", 2) == 0 ) {
int i, pos;
input[0] = 32; // kommando durch leerzeichen ersetzen
bzero(buffer, sizeof(buffer));
if ( !quiet )
printf("sending data... ");
for ( pos = 1, i = 2; i < cnt -1 && pos < sizeof(buffer); i++) {
//printf(">%c\n", input[i]);
pos += hexread( buffer + pos, &input[i], sizeof(buffer) - pos);
}
if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) // add a dummy report ID
{
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
usbhidCloseDevice(dev);
if ( (dev = openDevice()) != NULL)
printf("reconnect...\n");
else
exit = 1;
} else {
if ( !quiet )
printf("ok.\n");
}
} else
printf("%s",help);
}
} else {
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
