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/sockets.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 int
 215 on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming)
 216 {
 217     uint32_t *capabilities = (incoming->capabilities);
 218     int num_capabilities =
 219         1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t));
 220     int i;
 221     QemuThread thread_id;
 222
 223     incoming->version = ntohl(incoming->version);
 224     if (incoming->version != VSCARD_VERSION) {
 225         if (verbose > 0) {
 226             printf("warning: host has version %d, we have %d\n",
 227                 verbose, VSCARD_VERSION);
 228         }
 229     }
 230     if (incoming->magic != VSCARD_MAGIC) {
 231         printf("unexpected magic: got %d, expected %d\n",
 232             incoming->magic, VSCARD_MAGIC);
 233         return -1;
 234     }
 235     for (i = 0 ; i < num_capabilities; ++i) {
 236         capabilities[i] = ntohl(capabilities[i]);
 237     }
 238     /* Future: check capabilities */
 239     /* remove whatever reader might be left in qemu,
 240      * in case of an unclean previous exit. */
 241     send_msg(VSC_ReaderRemove, VSCARD_MINIMAL_READER_ID, NULL, 0);
 242     /* launch the event_thread. This will trigger reader adds for all the
 243      * existing readers */
 244     qemu_thread_create(&thread_id, event_thread, NULL, 0);
 245     return 0;
 246 }
 247
 248 #define APDUBufSize 270
 249
 250 static int
 251 do_socket_read(void)
 252 {
 253     int rv;
 254     int dwSendLength;
 255     int dwRecvLength;
 256     uint8_t pbRecvBuffer[APDUBufSize];
 257     uint8_t pbSendBuffer[APDUBufSize];
 258     VReaderStatus reader_status;
 259     VReader *reader = NULL;
 260     VSCMsgHeader mhHeader;
 261     VSCMsgError *error_msg;
 262
 263     rv = read(sock, &mhHeader, sizeof(mhHeader));
 264     if (rv < sizeof(mhHeader)) {
 265         /* Error */
 266         if (rv < 0) {
 267             perror("header read error\n");
 268         } else {
 269             fprintf(stderr, "header short read %d\n", rv);
 270         }
 271         return -1;
 272     }
 273     mhHeader.type = ntohl(mhHeader.type);
 274     mhHeader.reader_id = ntohl(mhHeader.reader_id);
 275     mhHeader.length = ntohl(mhHeader.length);
 276     if (verbose) {
 277         printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
 278                mhHeader.type, mhHeader.reader_id, mhHeader.length,
 279                mhHeader.length);
 280     }
 281     switch (mhHeader.type) {
 282     case VSC_APDU:
 283     case VSC_Flush:
 284     case VSC_Error:
 285     case VSC_Init:
 286         rv = read(sock, pbSendBuffer, mhHeader.length);
 287         break;
 288     default:
 289         fprintf(stderr, "Unexpected message of type 0x%X\n", mhHeader.type);
 290         return -1;
 291     }
 292     switch (mhHeader.type) {
 293     case VSC_APDU:
 294         if (rv < 0) {
 295             /* Error */
 296             fprintf(stderr, "read error\n");
 297             close(sock);
 298             return -1;
 299         }
 300         if (verbose) {
 301             printf(" recv APDU: ");
 302             print_byte_array(pbSendBuffer, mhHeader.length);
 303         }
 304         /* Transmit received APDU */
 305         dwSendLength = mhHeader.length;
 306         dwRecvLength = sizeof(pbRecvBuffer);
 307         reader = vreader_get_reader_by_id(mhHeader.reader_id);
 308         reader_status = vreader_xfr_bytes(reader,
 309                                           pbSendBuffer, dwSendLength,
 310                                           pbRecvBuffer, &dwRecvLength);
 311         if (reader_status == VREADER_OK) {
 312             mhHeader.length = dwRecvLength;
 313             if (verbose) {
 314                 printf(" send response: ");
 315                 print_byte_array(pbRecvBuffer, mhHeader.length);
 316             }
 317             send_msg(VSC_APDU, mhHeader.reader_id,
 318                      pbRecvBuffer, dwRecvLength);
 319         } else {
 320             rv = reader_status; /* warning: not meaningful */
 321             send_msg(VSC_Error, mhHeader.reader_id, &rv, sizeof(uint32_t));
 322         }
 323         vreader_free(reader);
 324         reader = NULL; /* we've freed it, don't use it by accident
 325                           again */
 326         break;
 327     case VSC_Flush:
 328         /* TODO: actually flush */
 329         send_msg(VSC_FlushComplete, mhHeader.reader_id, NULL, 0);
 330         break;
 331     case VSC_Error:
 332         error_msg = (VSCMsgError *) pbSendBuffer;
 333         if (error_msg->code == VSC_SUCCESS) {
 334             qemu_mutex_lock(&pending_reader_lock);
 335             if (pending_reader) {
 336                 vreader_set_id(pending_reader, mhHeader.reader_id);
 337                 vreader_free(pending_reader);
 338                 pending_reader = NULL;
 339                 qemu_cond_signal(&pending_reader_condition);
 340             }
 341             qemu_mutex_unlock(&pending_reader_lock);
 342             break;
 343         }
 344         printf("warning: qemu refused to add reader\n");
 345         if (error_msg->code == VSC_CANNOT_ADD_MORE_READERS) {
 346             /* clear pending reader, qemu can't handle any more */
 347             qemu_mutex_lock(&pending_reader_lock);
 348             if (pending_reader) {
 349                 pending_reader = NULL;
 350                 /* make sure the event loop doesn't hang */
 351                 qemu_cond_signal(&pending_reader_condition);
 352             }
 353             qemu_mutex_unlock(&pending_reader_lock);
 354         }
 355         break;
 356     case VSC_Init:
 357         if (on_host_init(&mhHeader, (VSCMsgInit *)pbSendBuffer) < 0) {
 358             return -1;
 359         }
 360         break;
 361     default:
 362         printf("Default\n");
 363         return -1;
 364     }
 365
 366     return 0;
 367 }
 368
 369 static void
 370 do_command(void)
 371 {
 372     char inbuf[255];
 373     char *string;
 374     VCardEmulError error;
 375     static unsigned int default_reader_id;
 376     unsigned int reader_id;
 377     VReader *reader = NULL;
 378
 379     reader_id = default_reader_id;
 380     string = fgets(inbuf, sizeof(inbuf), stdin);
 381     if (string != NULL) {
 382         if (strncmp(string, "exit", 4) == 0) {
 383             /* remove all the readers */
 384             VReaderList *list = vreader_get_reader_list();
 385             VReaderListEntry *reader_entry;
 386             printf("Active Readers:\n");
 387             for (reader_entry = vreader_list_get_first(list); reader_entry;
 388                  reader_entry = vreader_list_get_next(reader_entry)) {
 389                 VReader *reader = vreader_list_get_reader(reader_entry);
 390                 vreader_id_t reader_id;
 391                 reader_id = vreader_get_id(reader);
 392                 if (reader_id == -1) {
 393                     continue;
 394                 }
 395                 /* be nice and signal card removal first (qemu probably should
 396                  * do this itself) */
 397                 if (vreader_card_is_present(reader) == VREADER_OK) {
 398                     send_msg(VSC_CardRemove, reader_id, NULL, 0);
 399                 }
 400                 send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
 401             }
 402             exit(0);
 403         } else if (strncmp(string, "insert", 6) == 0) {
 404             if (string[6] == ' ') {
 405                 reader_id = get_id_from_string(&string[7], reader_id);
 406             }
 407             reader = vreader_get_reader_by_id(reader_id);
 408             if (reader != NULL) {
 409                 error = vcard_emul_force_card_insert(reader);
 410                 printf("insert %s, returned %d\n",
 411                        reader ? vreader_get_name(reader)
 412                        : "invalid reader", error);
 413             } else {
 414                 printf("no reader by id %u found\n", reader_id);
 415             }
 416         } else if (strncmp(string, "remove", 6) == 0) {
 417             if (string[6] == ' ') {
 418                 reader_id = get_id_from_string(&string[7], reader_id);
 419             }
 420             reader = vreader_get_reader_by_id(reader_id);
 421             if (reader != NULL) {
 422                 error = vcard_emul_force_card_remove(reader);
 423                 printf("remove %s, returned %d\n",
 424                         reader ? vreader_get_name(reader)
 425                         : "invalid reader", error);
 426             } else {
 427                 printf("no reader by id %u found\n", reader_id);
 428             }
 429         } else if (strncmp(string, "select", 6) == 0) {
 430             if (string[6] == ' ') {
 431                 reader_id = get_id_from_string(&string[7],
 432                                                VSCARD_UNDEFINED_READER_ID);
 433             }
 434             if (reader_id != VSCARD_UNDEFINED_READER_ID) {
 435                 reader = vreader_get_reader_by_id(reader_id);
 436             }
 437             if (reader) {
 438                 printf("Selecting reader %u, %s\n", reader_id,
 439                         vreader_get_name(reader));
 440                 default_reader_id = reader_id;
 441             } else {
 442                 printf("Reader with id %u not found\n", reader_id);
 443             }
 444         } else if (strncmp(string, "debug", 5) == 0) {
 445             if (string[5] == ' ') {
 446                 verbose = get_id_from_string(&string[6], 0);
 447             }
 448             printf("debug level = %d\n", verbose);
 449         } else if (strncmp(string, "list", 4) == 0) {
 450             VReaderList *list = vreader_get_reader_list();
 451             VReaderListEntry *reader_entry;
 452             printf("Active Readers:\n");
 453             for (reader_entry = vreader_list_get_first(list); reader_entry;
 454                  reader_entry = vreader_list_get_next(reader_entry)) {
 455                 VReader *reader = vreader_list_get_reader(reader_entry);
 456                 vreader_id_t reader_id;
 457                 reader_id = vreader_get_id(reader);
 458                 if (reader_id == -1) {
 459                     continue;
 460                 }
 461                 printf("%3u %s %s\n", reader_id,
 462                        vreader_card_is_present(reader) == VREADER_OK ?
 463                        "CARD_PRESENT" : "            ",
 464                        vreader_get_name(reader));
 465             }
 466             printf("Inactive Readers:\n");
 467             for (reader_entry = vreader_list_get_first(list); reader_entry;
 468                  reader_entry = vreader_list_get_next(reader_entry)) {
 469                 VReader *reader = vreader_list_get_reader(reader_entry);
 470                 vreader_id_t reader_id;
 471                 reader_id = vreader_get_id(reader);
 472                 if (reader_id != -1) {
 473                     continue;
 474                 }
 475
 476                 printf("INA %s %s\n",
 477                        vreader_card_is_present(reader) == VREADER_OK ?
 478                        "CARD_PRESENT" : "            ",
 479                        vreader_get_name(reader));
 480             }
 481         } else if (*string != 0) {
 482             printf("valid commands:\n");
 483             printf("insert [reader_id]\n");
 484             printf("remove [reader_id]\n");
 485             printf("select reader_id\n");
 486             printf("list\n");
 487             printf("debug [level]\n");
 488             printf("exit\n");
 489         }
 490     }
 491     vreader_free(reader);
 492     printf("> ");
 493     fflush(stdout);
 494 }
 495
 496
 497 /* just for ease of parsing command line arguments. */
 498 #define MAX_CERTS 100
 499
 500 static int
 501 connect_to_qemu(
 502     const char *host,
 503     const char *port
 504 ) {
 505     struct addrinfo hints;
 506     struct addrinfo *server;
 507     int ret;
 508
 509     sock = qemu_socket(AF_INET, SOCK_STREAM, 0);
 510     if (sock < 0) {
 511         /* Error */
 512         fprintf(stderr, "Error opening socket!\n");
 513         return -1;
 514     }
 515
 516     memset(&hints, 0, sizeof(struct addrinfo));
 517     hints.ai_family = AF_UNSPEC;
 518     hints.ai_socktype = SOCK_STREAM;
 519     hints.ai_flags = 0;
 520     hints.ai_protocol = 0;          /* Any protocol */
 521
 522     ret = getaddrinfo(host, port, &hints, &server);
 523
 524     if (ret != 0) {
 525         /* Error */
 526         fprintf(stderr, "getaddrinfo failed\n");
 527         return -1;
 528     }
 529
 530     if (connect(sock, server->ai_addr, server->ai_addrlen) < 0) {
 531         /* Error */
 532         fprintf(stderr, "Could not connect\n");
 533         return -1;
 534     }
 535     if (verbose) {
 536         printf("Connected (sizeof Header=%zd)!\n", sizeof(VSCMsgHeader));
 537     }
 538     return sock;
 539 }
 540
 541 int
 542 main(
 543     int argc,
 544     char *argv[]
 545 ) {
 546     char *qemu_host;
 547     char *qemu_port;
 548     VSCMsgHeader mhHeader;
 549
 550     VCardEmulOptions *command_line_options = NULL;
 551
 552     char *cert_names[MAX_CERTS];
 553     char *emul_args = NULL;
 554     int cert_count = 0;
 555     int c, rv;
 556
 557     while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
 558         switch (c) {
 559         case 'c':
 560             if (cert_count >= MAX_CERTS) {
 561                 printf("too many certificates (max = %d)\n", MAX_CERTS);
 562                 exit(5);
 563             }
 564             cert_names[cert_count++] = optarg;
 565             break;
 566         case 'e':
 567             emul_args = optarg;
 568             break;
 569         case 'p':
 570             print_usage();
 571             exit(4);
 572             break;
 573         case 'd':
 574             verbose = get_id_from_string(optarg, 1);
 575             break;
 576         }
 577     }
 578
 579     if (argc - optind != 2) {
 580         print_usage();
 581         exit(4);
 582     }
 583
 584     if (cert_count > 0) {
 585         char *new_args;
 586         int len, i;
 587         /* if we've given some -c options, we clearly we want do so some
 588          * software emulation.  add that emulation now. this is NSS Emulator
 589          * specific */
 590         if (emul_args == NULL) {
 591             emul_args = (char *)"db=\"/etc/pki/nssdb\"";
 592         }
 593 #define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
 594              /* 2 == close paren & null */
 595         len = strlen(emul_args) + strlen(SOFT_STRING) + 2;
 596         for (i = 0; i < cert_count; i++) {
 597             len += strlen(cert_names[i])+1; /* 1 == comma */
 598         }
 599         new_args = g_malloc(len);
 600         strcpy(new_args, emul_args);
 601         strcat(new_args, SOFT_STRING);
 602         for (i = 0; i < cert_count; i++) {
 603             strcat(new_args, cert_names[i]);
 604             strcat(new_args, ",");
 605         }
 606         strcat(new_args, ")");
 607         emul_args = new_args;
 608     }
 609     if (emul_args) {
 610         command_line_options = vcard_emul_options(emul_args);
 611     }
 612
 613     qemu_host = g_strdup(argv[argc - 2]);
 614     qemu_port = g_strdup(argv[argc - 1]);
 615     sock = connect_to_qemu(qemu_host, qemu_port);
 616     if (sock == -1) {
 617         fprintf(stderr, "error opening socket, exiting.\n");
 618         exit(5);
 619     }
 620
 621     qemu_mutex_init(&write_lock);
 622     qemu_mutex_init(&pending_reader_lock);
 623     qemu_cond_init(&pending_reader_condition);
 624
 625     vcard_emul_init(command_line_options);
 626
 627     printf("> ");
 628     fflush(stdout);
 629
 630     /* Send init message, Host responds (and then we send reader attachments) */
 631     VSCMsgInit init = {
 632         .version = htonl(VSCARD_VERSION),
 633         .magic = VSCARD_MAGIC,
 634         .capabilities = {0}
 635     };
 636     send_msg(VSC_Init, mhHeader.reader_id, &init, sizeof(init));
 637
 638     do {
 639         fd_set fds;
 640
 641         FD_ZERO(&fds);
 642         FD_SET(1, &fds);
 643         FD_SET(sock, &fds);
 644
 645         /* waiting on input from the socket */
 646         rv = select(sock+1, &fds, NULL, NULL, NULL);
 647         if (rv < 0) {
 648             /* handle error */
 649             perror("select");
 650             return 7;
 651         }
 652         if (FD_ISSET(1, &fds)) {
 653             do_command();
 654         }
 655         if (!FD_ISSET(sock, &fds)) {
 656             continue;
 657         }
 658         rv = do_socket_read();
 659     } while (rv >= 0);
 660
 661     return 0;
 662 }