libcacard/vscclient.c

   1 /*
   2  * Tester for VSCARD protocol, client side.
   3  *
   4  * Can be used with ccid-card-passthru.
   5  *
   6  * Copyright (c) 2011 Red Hat.
   7  * Written by Alon Levy.
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  */
  12
  13 #include <netdb.h>
  14
  15 #include "qemu-common.h"
  16 #include "qemu-thread.h"
  17 #include "qemu_socket.h"
  18
  19 #include "vscard_common.h"
  20
  21 #include "vreader.h"
  22 #include "vcard_emul.h"
  23 #include "vevent.h"
  24
  25 int verbose;
  26
  27 int sock;
  28
  29 static void
  30 print_byte_array(
  31     uint8_t *arrBytes,
  32     unsigned int nSize
  33 ) {
  34     int i;
  35     for (i = 0; i < nSize; i++) {
  36         printf("%02X ", arrBytes[i]);
  37     }
  38     printf("\n");
  39 }
  40
  41 static void
  42 print_usage(void) {
  43     printf("vscclient [-c <certname> .. -e <emul_args> -d <level>%s] "
  44             "<host> <port>\n",
  45 #ifdef USE_PASSTHRU
  46     " -p");
  47     printf(" -p use passthrough mode\n");
  48 #else
  49    "");
  50 #endif
  51     vcard_emul_usage();
  52 }
  53
  54 static QemuMutex write_lock;
  55
  56 static int
  57 send_msg(
  58     VSCMsgType type,
  59     uint32_t reader_id,
  60     const void *msg,
  61     unsigned int length
  62 ) {
  63     int rv;
  64     VSCMsgHeader mhHeader;
  65
  66     qemu_mutex_lock(&write_lock);
  67
  68     if (verbose > 10) {
  69         printf("sending type=%d id=%u, len =%u (0x%x)\n",
  70                type, reader_id, length, length);
  71     }
  72
  73     mhHeader.type = htonl(type);
  74     mhHeader.reader_id = 0;
  75     mhHeader.length = htonl(length);
  76     rv = write(sock, &mhHeader, sizeof(mhHeader));
  77     if (rv < 0) {
  78         /* Error */
  79         fprintf(stderr, "write header error\n");
  80         close(sock);
  81         qemu_mutex_unlock(&write_lock);
  82         return 16;
  83     }
  84     rv = write(sock, msg, length);
  85     if (rv < 0) {
  86         /* Error */
  87         fprintf(stderr, "write error\n");
  88         close(sock);
  89         qemu_mutex_unlock(&write_lock);
  90         return 16;
  91     }
  92     qemu_mutex_unlock(&write_lock);
  93
  94     return 0;
  95 }
  96
  97 static VReader *pending_reader;
  98 static QemuMutex pending_reader_lock;
  99 static QemuCond pending_reader_condition;
 100
 101 #define MAX_ATR_LEN 40
 102 static void *
 103 event_thread(void *arg)
 104 {
 105     unsigned char atr[MAX_ATR_LEN];
 106     int atr_len = MAX_ATR_LEN;
 107     VEvent *event = NULL;
 108     unsigned int reader_id;
 109
 110
 111     while (1) {
 112         const char *reader_name;
 113
 114         event = vevent_wait_next_vevent();
 115         if (event == NULL) {
 116             break;
 117         }
 118         reader_id = vreader_get_id(event->reader);
 119         if (reader_id == VSCARD_UNDEFINED_READER_ID &&
 120             event->type != VEVENT_READER_INSERT) {
 121             /* ignore events from readers qemu has rejected */
 122             /* if qemu is still deciding on this reader, wait to see if need to
 123              * forward this event */
 124             qemu_mutex_lock(&pending_reader_lock);
 125             if (!pending_reader || (pending_reader != event->reader)) {
 126                 /* wasn't for a pending reader, this reader has already been
 127                  * rejected by qemu */
 128                 qemu_mutex_unlock(&pending_reader_lock);
 129                 vevent_delete(event);
 130                 continue;
 131             }
 132             /* this reader hasn't been told its status from qemu yet, wait for
 133              * that status */
 134             while (pending_reader != NULL) {
 135                 qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
 136             }
 137             qemu_mutex_unlock(&pending_reader_lock);
 138             /* now recheck the id */
 139             reader_id = vreader_get_id(event->reader);
 140             if (reader_id == VSCARD_UNDEFINED_READER_ID) {
 141                 /* this reader was rejected */
 142                 vevent_delete(event);
 143                 continue;
 144             }
 145             /* reader was accepted, now forward the event */
 146         }
 147         switch (event->type) {
 148         case VEVENT_READER_INSERT:
 149             /* tell qemu to insert a new CCID reader */
 150             /* wait until qemu has responded to our first reader insert
 151              * before we send a second. That way we won't confuse the responses
 152              * */
 153             qemu_mutex_lock(&pending_reader_lock);
 154             while (pending_reader != NULL) {
 155                 qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
 156             }
 157             pending_reader = vreader_reference(event->reader);
 158             qemu_mutex_unlock(&pending_reader_lock);
 159             reader_name = vreader_get_name(event->reader);
 160             if (verbose > 10) {
 161                 printf(" READER INSERT: %s\n", reader_name);
 162             }
 163             send_msg(VSC_ReaderAdd,
 164                 reader_id, /* currerntly VSCARD_UNDEFINED_READER_ID */
 165                 NULL, 0 /* TODO reader_name, strlen(reader_name) */);
 166             break;
 167         case VEVENT_READER_REMOVE:
 168             /* future, tell qemu that an old CCID reader has been removed */
 169             if (verbose > 10) {
 170                 printf(" READER REMOVE: %u\n", reader_id);
 171             }
 172             send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
 173             break;
 174         case VEVENT_CARD_INSERT:
 175             /* get the ATR (intended as a response to a power on from the
 176              * reader */
 177             atr_len = MAX_ATR_LEN;
 178             vreader_power_on(event->reader, atr, &atr_len);
 179             /* ATR call functions as a Card Insert event */
 180             if (verbose > 10) {
 181                 printf(" CARD INSERT %u: ", reader_id);
 182                 print_byte_array(atr, atr_len);
 183             }
 184             send_msg(VSC_ATR, reader_id, atr, atr_len);
 185             break;
 186         case VEVENT_CARD_REMOVE:
 187             /* Card removed */
 188             if (verbose > 10) {
 189                 printf(" CARD REMOVE %u:\n", reader_id);
 190             }
 191             send_msg(VSC_CardRemove, reader_id, NULL, 0);
 192             break;
 193         default:
 194             break;
 195         }
 196         vevent_delete(event);
 197     }
 198     return NULL;
 199 }
 200
 201
 202 static unsigned int
 203 get_id_from_string(char *string, unsigned int default_id)
 204 {
 205     unsigned int id = atoi(string);
 206
 207     /* don't accidentally swith to zero because no numbers have been supplied */
 208     if ((id == 0) && *string != '0') {
 209         return default_id;
 210     }
 211     return id;
 212 }
 213
 214 static void
 215 do_command(void)
 216 {
 217     char inbuf[255];
 218     char *string;
 219     VCardEmulError error;
 220     static unsigned int default_reader_id;
 221     unsigned int reader_id;
 222     VReader *reader = NULL;
 223
 224     reader_id = default_reader_id;
 225     string = fgets(inbuf, sizeof(inbuf), stdin);
 226     if (string != NULL) {
 227         if (strncmp(string, "exit", 4) == 0) {
 228             /* remove all the readers */
 229             VReaderList *list = vreader_get_reader_list();
 230             VReaderListEntry *reader_entry;
 231             printf("Active Readers:\n");
 232             for (reader_entry = vreader_list_get_first(list); reader_entry;
 233                  reader_entry = vreader_list_get_next(reader_entry)) {
 234                 VReader *reader = vreader_list_get_reader(reader_entry);
 235                 vreader_id_t reader_id;
 236                 reader_id = vreader_get_id(reader);
 237                 if (reader_id == -1) {
 238                     continue;
 239                 }
 240                 /* be nice and signal card removal first (qemu probably should
 241                  * do this itself) */
 242                 if (vreader_card_is_present(reader) == VREADER_OK) {
 243                     send_msg(VSC_CardRemove, reader_id, NULL, 0);
 244                 }
 245                 send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
 246             }
 247             exit(0);
 248         } else if (strncmp(string, "insert", 6) == 0) {
 249             if (string[6] == ' ') {
 250                 reader_id = get_id_from_string(&string[7], reader_id);
 251             }
 252             reader = vreader_get_reader_by_id(reader_id);
 253             if (reader != NULL) {
 254                 error = vcard_emul_force_card_insert(reader);
 255                 printf("insert %s, returned %d\n",
 256                        reader ? vreader_get_name(reader)
 257                        : "invalid reader", error);
 258             } else {
 259                 printf("no reader by id %u found\n", reader_id);
 260             }
 261         } else if (strncmp(string, "remove", 6) == 0) {
 262             if (string[6] == ' ') {
 263                 reader_id = get_id_from_string(&string[7], reader_id);
 264             }
 265             reader = vreader_get_reader_by_id(reader_id);
 266             if (reader != NULL) {
 267                 error = vcard_emul_force_card_remove(reader);
 268                 printf("remove %s, returned %d\n",
 269                         reader ? vreader_get_name(reader)
 270                         : "invalid reader", error);
 271             } else {
 272                 printf("no reader by id %u found\n", reader_id);
 273             }
 274         } else if (strncmp(string, "select", 6) == 0) {
 275             if (string[6] == ' ') {
 276                 reader_id = get_id_from_string(&string[7],
 277                                                VSCARD_UNDEFINED_READER_ID);
 278             }
 279             if (reader_id != VSCARD_UNDEFINED_READER_ID) {
 280                 reader = vreader_get_reader_by_id(reader_id);
 281             }
 282             if (reader) {
 283                 printf("Selecting reader %u, %s\n", reader_id,
 284                         vreader_get_name(reader));
 285                 default_reader_id = reader_id;
 286             } else {
 287                 printf("Reader with id %u not found\n", reader_id);
 288             }
 289         } else if (strncmp(string, "debug", 5) == 0) {
 290             if (string[5] == ' ') {
 291                 verbose = get_id_from_string(&string[6], 0);
 292             }
 293             printf("debug level = %d\n", verbose);
 294         } else if (strncmp(string, "list", 4) == 0) {
 295             VReaderList *list = vreader_get_reader_list();
 296             VReaderListEntry *reader_entry;
 297             printf("Active Readers:\n");
 298             for (reader_entry = vreader_list_get_first(list); reader_entry;
 299                  reader_entry = vreader_list_get_next(reader_entry)) {
 300                 VReader *reader = vreader_list_get_reader(reader_entry);
 301                 vreader_id_t reader_id;
 302                 reader_id = vreader_get_id(reader);
 303                 if (reader_id == -1) {
 304                     continue;
 305                 }
 306                 printf("%3u %s %s\n", reader_id,
 307                        vreader_card_is_present(reader) == VREADER_OK ?
 308                        "CARD_PRESENT" : "            ",
 309                        vreader_get_name(reader));
 310             }
 311             printf("Inactive Readers:\n");
 312             for (reader_entry = vreader_list_get_first(list); reader_entry;
 313                  reader_entry = vreader_list_get_next(reader_entry)) {
 314                 VReader *reader = vreader_list_get_reader(reader_entry);
 315                 vreader_id_t reader_id;
 316                 reader_id = vreader_get_id(reader);
 317                 if (reader_id != -1) {
 318                     continue;
 319                 }
 320
 321                 printf("INA %s %s\n",
 322                        vreader_card_is_present(reader) == VREADER_OK ?
 323                        "CARD_PRESENT" : "            ",
 324                        vreader_get_name(reader));
 325             }
 326         } else if (*string != 0) {
 327             printf("valid commands:\n");
 328             printf("insert [reader_id]\n");
 329             printf("remove [reader_id]\n");
 330             printf("select reader_id\n");
 331             printf("list\n");
 332             printf("debug [level]\n");
 333             printf("exit\n");
 334         }
 335     }
 336     vreader_free(reader);
 337     printf("> ");
 338     fflush(stdout);
 339 }
 340
 341
 342 #define APDUBufSize 270
 343
 344 /* just for ease of parsing command line arguments. */
 345 #define MAX_CERTS 100
 346
 347 static int
 348 connect_to_qemu(
 349     const char *host,
 350     const char *port
 351 ) {
 352     struct addrinfo hints;
 353     struct addrinfo *server;
 354     int ret;
 355
 356     sock = qemu_socket(AF_INET, SOCK_STREAM, 0);
 357     if (sock < 0) {
 358         /* Error */
 359         fprintf(stderr, "Error opening socket!\n");
 360         return -1;
 361     }
 362
 363     memset(&hints, 0, sizeof(struct addrinfo));
 364     hints.ai_family = AF_UNSPEC;
 365     hints.ai_socktype = SOCK_STREAM;
 366     hints.ai_flags = 0;
 367     hints.ai_protocol = 0;          /* Any protocol */
 368
 369     ret = getaddrinfo(host, port, &hints, &server);
 370
 371     if (ret != 0) {
 372         /* Error */
 373         fprintf(stderr, "getaddrinfo failed\n");
 374         return -1;
 375     }
 376
 377     if (connect(sock, server->ai_addr, server->ai_addrlen) < 0) {
 378         /* Error */
 379         fprintf(stderr, "Could not connect\n");
 380         return -1;
 381     }
 382     if (verbose) {
 383         printf("Connected (sizeof Header=%zd)!\n", sizeof(VSCMsgHeader));
 384     }
 385     return sock;
 386 }
 387
 388 static int on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming)
 389 {
 390     uint32_t *capabilities = (incoming->capabilities);
 391     int num_capabilities =
 392         1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t));
 393     int i;
 394     int rv;
 395     pthread_t thread_id;
 396
 397     incoming->version = ntohl(incoming->version);
 398     if (incoming->version != VSCARD_VERSION) {
 399         if (verbose > 0) {
 400             printf("warning: host has version %d, we have %d\n",
 401                 verbose, VSCARD_VERSION);
 402         }
 403     }
 404     if (incoming->magic != VSCARD_MAGIC) {
 405         printf("unexpected magic: got %d, expected %d\n",
 406             incoming->magic, VSCARD_MAGIC);
 407         return -1;
 408     }
 409     for (i = 0 ; i < num_capabilities; ++i) {
 410         capabilities[i] = ntohl(capabilities[i]);
 411     }
 412     /* Future: check capabilities */
 413     /* remove whatever reader might be left in qemu,
 414      * in case of an unclean previous exit. */
 415     send_msg(VSC_ReaderRemove, VSCARD_MINIMAL_READER_ID, NULL, 0);
 416     /* launch the event_thread. This will trigger reader adds for all the
 417      * existing readers */
 418     rv = pthread_create(&thread_id, NULL, event_thread, NULL);
 419     if (rv < 0) {
 420         perror("pthread_create");
 421         return rv;
 422     }
 423     return 0;
 424 }
 425
 426 int
 427 main(
 428     int argc,
 429     char *argv[]
 430 ) {
 431     char *qemu_host;
 432     char *qemu_port;
 433     VSCMsgHeader mhHeader;
 434     VSCMsgError *error_msg;
 435
 436     int rv;
 437     int dwSendLength;
 438     int dwRecvLength;
 439     uint8_t pbRecvBuffer[APDUBufSize];
 440     uint8_t pbSendBuffer[APDUBufSize];
 441      VReaderStatus reader_status;
 442     VReader *reader = NULL;
 443     VCardEmulOptions *command_line_options = NULL;
 444
 445     char *cert_names[MAX_CERTS];
 446     char *emul_args = NULL;
 447     int cert_count = 0;
 448     int c;
 449
 450     while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
 451         switch (c) {
 452         case 'c':
 453             if (cert_count >= MAX_CERTS) {
 454                 printf("too many certificates (max = %d)\n", MAX_CERTS);
 455                 exit(5);
 456             }
 457             cert_names[cert_count++] = optarg;
 458             break;
 459         case 'e':
 460             emul_args = optarg;
 461             break;
 462         case 'p':
 463             print_usage();
 464             exit(4);
 465             break;
 466         case 'd':
 467             verbose = get_id_from_string(optarg, 1);
 468             break;
 469         }
 470     }
 471
 472     if (argc - optind != 2) {
 473         print_usage();
 474         exit(4);
 475     }
 476
 477     if (cert_count > 0) {
 478         char *new_args;
 479         int len, i;
 480         /* if we've given some -c options, we clearly we want do so some
 481          * software emulation.  add that emulation now. this is NSS Emulator
 482          * specific */
 483         if (emul_args == NULL) {
 484             emul_args = (char *)"db=\"/etc/pki/nssdb\"";
 485         }
 486 #define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
 487              /* 2 == close paren & null */
 488         len = strlen(emul_args) + strlen(SOFT_STRING) + 2;
 489         for (i = 0; i < cert_count; i++) {
 490             len += strlen(cert_names[i])+1; /* 1 == comma */
 491         }
 492         new_args = g_malloc(len);
 493         strcpy(new_args, emul_args);
 494         strcat(new_args, SOFT_STRING);
 495         for (i = 0; i < cert_count; i++) {
 496             strcat(new_args, cert_names[i]);
 497             strcat(new_args, ",");
 498         }
 499         strcat(new_args, ")");
 500         emul_args = new_args;
 501     }
 502     if (emul_args) {
 503         command_line_options = vcard_emul_options(emul_args);
 504     }
 505
 506     qemu_host = strdup(argv[argc - 2]);
 507     qemu_port = strdup(argv[argc - 1]);
 508     sock = connect_to_qemu(qemu_host, qemu_port);
 509     if (sock == -1) {
 510         fprintf(stderr, "error opening socket, exiting.\n");
 511         exit(5);
 512     }
 513
 514     qemu_mutex_init(&write_lock);
 515     qemu_mutex_init(&pending_reader_lock);
 516     qemu_cond_init(&pending_reader_condition);
 517
 518     vcard_emul_init(command_line_options);
 519
 520     printf("> ");
 521     fflush(stdout);
 522
 523     /* Send init message, Host responds (and then we send reader attachments) */
 524     VSCMsgInit init = {
 525         .version = htonl(VSCARD_VERSION),
 526         .magic = VSCARD_MAGIC,
 527         .capabilities = {0}
 528     };
 529     send_msg(VSC_Init, mhHeader.reader_id, &init, sizeof(init));
 530
 531     do {
 532         fd_set fds;
 533
 534         FD_ZERO(&fds);
 535         FD_SET(1, &fds);
 536         FD_SET(sock, &fds);
 537
 538         /* waiting on input from the socket */
 539         rv = select(sock+1, &fds, NULL, NULL, NULL);
 540         if (rv < 0) {
 541             /* handle error */
 542             perror("select");
 543             return 7;
 544         }
 545         if (FD_ISSET(1, &fds)) {
 546             do_command();
 547         }
 548         if (!FD_ISSET(sock, &fds)) {
 549             continue;
 550         }
 551
 552         rv = read(sock, &mhHeader, sizeof(mhHeader));
 553         if (rv < sizeof(mhHeader)) {
 554             /* Error */
 555             if (rv < 0) {
 556                 perror("header read error\n");
 557             } else {
 558                 fprintf(stderr, "header short read %d\n", rv);
 559             }
 560             return 8;
 561         }
 562         mhHeader.type = ntohl(mhHeader.type);
 563         mhHeader.reader_id = ntohl(mhHeader.reader_id);
 564         mhHeader.length = ntohl(mhHeader.length);
 565         if (verbose) {
 566             printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
 567                     mhHeader.type, mhHeader.reader_id, mhHeader.length,
 568                                                mhHeader.length);
 569         }
 570         switch (mhHeader.type) {
 571         case VSC_APDU:
 572         case VSC_Flush:
 573         case VSC_Error:
 574         case VSC_Init:
 575             rv = read(sock, pbSendBuffer, mhHeader.length);
 576             break;
 577         default:
 578             fprintf(stderr, "Unexpected message of type 0x%X\n", mhHeader.type);
 579             return 0;
 580         }
 581         switch (mhHeader.type) {
 582         case VSC_APDU:
 583             if (rv < 0) {
 584                 /* Error */
 585                 fprintf(stderr, "read error\n");
 586                 close(sock);
 587                 return 8;
 588             }
 589             if (verbose) {
 590                 printf(" recv APDU: ");
 591                 print_byte_array(pbSendBuffer, mhHeader.length);
 592             }
 593             /* Transmit received APDU */
 594             dwSendLength = mhHeader.length;
 595             dwRecvLength = sizeof(pbRecvBuffer);
 596             reader = vreader_get_reader_by_id(mhHeader.reader_id);
 597             reader_status = vreader_xfr_bytes(reader,
 598                 pbSendBuffer, dwSendLength,
 599                 pbRecvBuffer, &dwRecvLength);
 600             if (reader_status == VREADER_OK) {
 601                 mhHeader.length = dwRecvLength;
 602                 if (verbose) {
 603                     printf(" send response: ");
 604                     print_byte_array(pbRecvBuffer, mhHeader.length);
 605                 }
 606                 send_msg(VSC_APDU, mhHeader.reader_id,
 607                          pbRecvBuffer, dwRecvLength);
 608             } else {
 609                 rv = reader_status; /* warning: not meaningful */
 610                 send_msg(VSC_Error, mhHeader.reader_id, &rv, sizeof(uint32_t));
 611             }
 612             vreader_free(reader);
 613             reader = NULL; /* we've freed it, don't use it by accident
 614                               again */
 615             break;
 616         case VSC_Flush:
 617             /* TODO: actually flush */
 618             send_msg(VSC_FlushComplete, mhHeader.reader_id, NULL, 0);
 619             break;
 620         case VSC_Error:
 621             error_msg = (VSCMsgError *) pbSendBuffer;
 622             if (error_msg->code == VSC_SUCCESS) {
 623                 qemu_mutex_lock(&pending_reader_lock);
 624                 if (pending_reader) {
 625                     vreader_set_id(pending_reader, mhHeader.reader_id);
 626                     vreader_free(pending_reader);
 627                     pending_reader = NULL;
 628                     qemu_cond_signal(&pending_reader_condition);
 629                 }
 630                 qemu_mutex_unlock(&pending_reader_lock);
 631                 break;
 632             }
 633             printf("warning: qemu refused to add reader\n");
 634             if (error_msg->code == VSC_CANNOT_ADD_MORE_READERS) {
 635                 /* clear pending reader, qemu can't handle any more */
 636                 qemu_mutex_lock(&pending_reader_lock);
 637                 if (pending_reader) {
 638                     pending_reader = NULL;
 639                     /* make sure the event loop doesn't hang */
 640                     qemu_cond_signal(&pending_reader_condition);
 641                 }
 642                 qemu_mutex_unlock(&pending_reader_lock);
 643             }
 644             break;
 645         case VSC_Init:
 646             if (on_host_init(&mhHeader, (VSCMsgInit *)pbSendBuffer) < 0) {
 647                 return -1;
 648             }
 649             break;
 650         default:
 651             printf("Default\n");
 652             return 0;
 653         }
 654     } while (rv >= 0);
 655
 656     return 0;
 657 }