From 01c9f00a33750469c83d4819f748e97db52c132d Mon Sep 17 00:00:00 2001 From: Frank Morgner Date: Mon, 13 Aug 2012 00:19:58 +0200 Subject: [PATCH] VPCD: partial rewrite of socket communication - memory for buffer of received data is now reused with realloc - internal functions now use a similar interface like recv/send/... - added documentation about memory handling of vicc_getatr/vicc_transmit - fixed transmit when using send in multiple passes --- pcsc-relay/src/vpcd-driver.c | 23 +-- virtualsmartcard/src/vpcd/ifd-vpcd.c | 48 ++++--- virtualsmartcard/src/vpcd/vpcd.c | 203 ++++++++++++++------------- virtualsmartcard/src/vpcd/vpcd.h | 34 ++++- 4 files changed, 178 insertions(+), 130 deletions(-) diff --git a/pcsc-relay/src/vpcd-driver.c b/pcsc-relay/src/vpcd-driver.c index 360ba51..9c374a5 100644 --- a/pcsc-relay/src/vpcd-driver.c +++ b/pcsc-relay/src/vpcd-driver.c @@ -88,27 +88,32 @@ static int vpcd_transmit(driver_data_t *driver_data, const unsigned char *send, size_t send_len, unsigned char *recv, size_t *recv_len) { - char *rapdu; - int size = vicc_transmit(send_len, (char *) send, &rapdu); + unsigned char *rapdu = NULL; + int r = 0; + ssize_t size = vicc_transmit(send_len, send, &rapdu); if (size < 0) { RELAY_ERROR("could not send apdu or receive rapdu\n"); - *recv_len = 0; - return 0; + goto err; } if (*recv_len < size) { RELAY_ERROR("Not enough memory for rapdu\n"); - *recv_len = 0; - free(rapdu); - return 0; + goto err; } - *recv_len = size; memcpy(recv, rapdu, size); + *recv_len = size; + + r = 1; + +err: + if (!r) + *recv_len = 0; + free(rapdu); - return 1; + return r; } diff --git a/virtualsmartcard/src/vpcd/ifd-vpcd.c b/virtualsmartcard/src/vpcd/ifd-vpcd.c index 1673632..7589169 100644 --- a/virtualsmartcard/src/vpcd/ifd-vpcd.c +++ b/virtualsmartcard/src/vpcd/ifd-vpcd.c @@ -78,8 +78,12 @@ IFDHCloseChannel (DWORD Lun) RESPONSECODE IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value) { - char *atr; - int size; + unsigned char *atr = NULL; + ssize_t size; + + if (!Length || !Value) + return IFD_COMMUNICATION_ERROR; + switch (Tag) { case TAG_IFD_ATR: @@ -88,19 +92,23 @@ IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value) Log1(PCSC_LOG_ERROR, "could not get ATR"); return IFD_COMMUNICATION_ERROR; } + if (size == 0) { + Log1(PCSC_LOG_ERROR, "Virtual ICC removed"); + return IFD_ICC_NOT_PRESENT; + } Log2(PCSC_LOG_DEBUG, "Got ATR (%d bytes)", size); if (*Length < size) { + free(atr); Log1(PCSC_LOG_ERROR, "Not enough memory for ATR"); return IFD_COMMUNICATION_ERROR; } - /* Flawfinder: ignore */ memcpy(Value, atr, size); *Length = size; free(atr); - break; + case TAG_IFD_SLOTS_NUMBER: if (*Length < 1) { Log1(PCSC_LOG_ERROR, "Invalid input data"); @@ -109,8 +117,8 @@ IFDHGetCapabilities (DWORD Lun, DWORD Tag, PDWORD Length, PUCHAR Value) *Value = 1; *Length = 1; - break; + default: Log2(PCSC_LOG_DEBUG, "unknown tag %d", (int)Tag); return IFD_ERROR_TAG; @@ -179,34 +187,40 @@ IFDHTransmitToICC (DWORD Lun, SCARD_IO_HEADER SendPci, PUCHAR TxBuffer, DWORD TxLength, PUCHAR RxBuffer, PDWORD RxLength, PSCARD_IO_HEADER RecvPci) { + unsigned char *rapdu = NULL; + ssize_t size; + RESPONSECODE r = IFD_COMMUNICATION_ERROR; + if (!RxLength || !RecvPci) { Log1(PCSC_LOG_ERROR, "Invalid input data"); - return IFD_COMMUNICATION_ERROR; + goto err; } - char *rapdu; - int size = vicc_transmit(TxLength, (char *) TxBuffer, &rapdu); + size = vicc_transmit(TxLength, TxBuffer, &rapdu); if (size < 0) { Log1(PCSC_LOG_ERROR, "could not send apdu or receive rapdu"); - *RxLength = 0; - return IFD_COMMUNICATION_ERROR; + goto err; } if (*RxLength < size) { Log1(PCSC_LOG_ERROR, "Not enough memory for rapdu"); - *RxLength = 0; - free(rapdu); - return IFD_COMMUNICATION_ERROR; + goto err; } - (*RxLength) = size; - /* Flawfinder: ignore */ + *RxLength = size; memcpy(RxBuffer, rapdu, size); - free(rapdu); RecvPci->Protocol = 1; - return IFD_SUCCESS; + r = IFD_SUCCESS; + +err: + if (r != IFD_SUCCESS) + *RxLength = 0; + + free(rapdu); + + return r; } RESPONSECODE diff --git a/virtualsmartcard/src/vpcd/vpcd.c b/virtualsmartcard/src/vpcd/vpcd.c index 167b195..02c82cd 100644 --- a/virtualsmartcard/src/vpcd/vpcd.c +++ b/virtualsmartcard/src/vpcd/vpcd.c @@ -16,19 +16,17 @@ * You should have received a copy of the GNU General Public License along with * virtualsmartcard. If not, see . */ +#include "vpcd.h" #include +#include #include +#include #include #include #include #include #include - -#include - -#include "vpcd.h" - #define VPCD_CTRL_LEN 1 #define VPCD_CTRL_OFF 0 @@ -36,144 +34,135 @@ #define VPCD_CTRL_RESET 2 #define VPCD_CTRL_ATR 4 -/* - * First send length (unsigned integer in network byte order), then send the - * message itself to the socket. - */ -int sendToVICC(uint16_t size, const char* buffer); -/* - * Receive a message from icc - */ -int recvFromVICC(char** buffer); - static int server_sock = -1; static int client_sock = -1; -/* - * Send all size bytes from buffer to sock - */ -static int sendall(int sock, size_t size, const char* buffer); -/* - * Receive size bytes from sock - */ -static char* recvall(int sock, size_t size); -/* - * Open a TCP socket and listen. - */ +ssize_t sendToVICC(size_t size, const unsigned char *buffer); +ssize_t recvFromVICC(unsigned char **buffer); + +static int sendall(int sock, const void *buffer, size_t size); +static ssize_t recvall(int sock, void *buffer, size_t size); + static int opensock(unsigned short port); -int sendall(int sock, size_t size, const char* buffer) { +ssize_t sendall(int sock, const void *buffer, size_t size) +{ size_t sent = 0; - int i; + ssize_t r; + while (sent < size) { - i = send(sock, buffer, size-sent, 0); - if (i < 0) return i; - sent += i; + r = send(sock, buffer, size-sent, 0); + if (r < 0) + return r; + + sent += r; + buffer += r; } - return 0; + + return sent; } -char* recvall(int sock, size_t size) { - char* buffer = (char*) malloc(size); - if (buffer == NULL) return NULL; - - if (recv(sock, buffer, size, MSG_WAITALL) < size) { - free(buffer); - return NULL; - } - return buffer; +ssize_t recvall(int sock, void *buffer, size_t size) { + return recv(sock, buffer, size, MSG_WAITALL); } int opensock(unsigned short port) { int sock; + socklen_t yes = 1; + struct sockaddr_in server_sockaddr; sock = socket(AF_INET, SOCK_STREAM, 0); - if (sock < 0) return -1; + if (sock < 0) + return -1; - int i = 1; - if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0) + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) != 0) return -1; - struct sockaddr_in server_sockaddr; memset(&server_sockaddr, 0, sizeof server_sockaddr); server_sockaddr.sin_family = PF_INET; server_sockaddr.sin_port = htons(port); server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY); - if (bind(sock, (struct sockaddr*)&server_sockaddr, - sizeof server_sockaddr) < 0) return -1; + if (bind(sock, (struct sockaddr *) &server_sockaddr, + sizeof server_sockaddr) != 0) + return -1; - if (listen(sock, 0) < 0) return -1; + if (listen(sock, 0) != 0) + return -1; return sock; } -int waitforclient(int server, long int secs, long int usecs) { - int sock = 0; - +int waitforclient(int server, long secs, long usecs) +{ fd_set rfds; + struct sockaddr_in client_sockaddr; + socklen_t client_socklen = sizeof client_sockaddr; + struct timeval tv; + FD_ZERO(&rfds); FD_SET(server, &rfds); - /* Wait up to one microsecond. */ - struct timeval tv; tv.tv_sec = secs; tv.tv_usec = usecs; - if (select(server+1, &rfds, NULL, NULL, &tv) < 0) return -1; + if (select(server+1, &rfds, NULL, NULL, &tv) == -1) + return -1; - if (FD_ISSET(server, &rfds)) { - struct sockaddr_in client_sockaddr; - socklen_t client_socklen = sizeof client_sockaddr; - sock = accept(server, - (struct sockaddr*)&client_sockaddr, + if (FD_ISSET(server, &rfds)) + return accept(server, (struct sockaddr *) &client_sockaddr, &client_socklen); - } - - return sock; -} - -int sendToVICC(uint16_t size, const char* buffer) { - /* send size of message */ - uint16_t i = htons(size); - i = sendall(client_sock, sizeof i, (char *) &i); - if (i<0) { - vicc_eject(); - return i; - } - /* send message */ - i = sendall(client_sock, size, buffer); - if (i<0) { - vicc_eject(); - return i; - } return 0; } -/* - * Receive a message from icc - */ -int recvFromVICC(char** buffer) { - /* receive size of message on LENLEN bytes */ - uint16_t *p = (uint16_t *) recvall(client_sock, sizeof *p); - if (p == NULL) { +ssize_t sendToVICC(size_t length, const unsigned char* buffer) +{ + ssize_t r; + uint16_t size; + + /* send size of message on 2 bytes */ + size = htons(length); + r = sendall(client_sock, (void *) &size, sizeof size); + if (r == sizeof size) + /* send message */ + r = sendall(client_sock, buffer, length); + + if (r < 0) vicc_eject(); + + return r; +} + +ssize_t recvFromVICC(unsigned char **buffer) +{ + ssize_t r; + uint16_t size; + unsigned char *p = NULL; + + if (!buffer) { + errno = EINVAL; return -1; } - uint16_t size = ntohs(*p); - free(p); + + /* receive size of message on 2 bytes */ + r = recvall(client_sock, &size, sizeof size); + if (r < sizeof size) + return r; + + size = ntohs(size); + + p = realloc(*buffer, size); + if (p == NULL) { + errno = ENOMEM; + return -1; + } + *buffer = p; /* receive message */ - *buffer = recvall(client_sock, size); - if (*buffer == NULL) { - vicc_eject(); - return -1; - } - - return size; + return recvall(client_sock, *buffer, size); } int vicc_eject(void) { @@ -203,22 +192,36 @@ int vicc_exit(void) { return 0; } -int vicc_transmit(int apdu_len, const char *apdu, char **rapdu) { - if (sendToVICC(apdu_len, apdu) < 0) return -1; +ssize_t vicc_transmit(size_t apdu_len, + const unsigned char *apdu, unsigned char **rapdu) +{ + ssize_t r; - return recvFromVICC(rapdu); + r = sendToVICC(apdu_len, apdu); + + if (r > 0) + r = recvFromVICC(rapdu); + + if (r <= 0) + vicc_eject(); + + return r; } int vicc_present(void) { + unsigned char *atr = NULL; + if (client_sock > 0) { - char *atr = NULL; - if (vicc_getatr(&atr) < 0) + if (vicc_getatr(&atr) <= 0) return 0; + free(atr); + return 1; } else { /* Wait up to one microsecond. */ client_sock = waitforclient(server_sock, 0, 1); + if (client_sock < 0) return -1; } @@ -226,7 +229,7 @@ int vicc_present(void) { return 0; } -int vicc_getatr(char** atr) { +ssize_t vicc_getatr(unsigned char **atr) { char i = VPCD_CTRL_ATR; return vicc_transmit(VPCD_CTRL_LEN, &i, atr); } diff --git a/virtualsmartcard/src/vpcd/vpcd.h b/virtualsmartcard/src/vpcd/vpcd.h index 3141022..690a9b2 100644 --- a/virtualsmartcard/src/vpcd/vpcd.h +++ b/virtualsmartcard/src/vpcd/vpcd.h @@ -19,25 +19,51 @@ #ifndef _VPCD_H_ #define _VPCD_H_ -#include +#include #ifdef __cplusplus extern "C" { #endif +/** Standard port of the virtual smart card reader */ #define VPCDPORT 35963 -int vicc_eject(void); int vicc_init(unsigned short port); int vicc_exit(void); -int vicc_transmit(int apdu_len, const char *apdu, char **rapdu); -int vicc_getatr(char** atr); +int vicc_eject(void); + int vicc_present(void); int vicc_poweron(void); int vicc_poweroff(void); int vicc_reset(void); +/** + * @brief Receive ATR from the virtual smart card. + * + * @param[in,out] atr ATR received. Memory will be reused (via \a realloc) and + * should be freed by the caller if no longer needed. + * + * @return On success, the call returns the number of bytes received. + * On error, -1 is returned, and errno is set appropriately. + */ +ssize_t vicc_getatr(unsigned char** atr); + +/** + * @brief Send an APDU to the virtual smart card. + * + * @param[in] apdu_len Number of bytes to send + * @param[in] apdu Data to be sent + * @param[in,out] rapdu Data received. Memory will be reused (via \a + * realloc) and should be freed by the caller if no + * longer needed. + * + * @return On success, the call returns the number of bytes received. + * On error, -1 is returned, and errno is set appropriately. + */ +ssize_t vicc_transmit(size_t apdu_len, const unsigned char *apdu, + unsigned char **rapdu); + #ifdef __cplusplus } #endif