VivoKey/vsmartcard
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

VPCD: partial rewrite of socket communication

Browse Source 
- 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
This commit is contained in:
Frank Morgner
2012-08-13 00:19:58 +02:00
parent 3adf5b1e60
commit 01c9f00a33
4 changed files with 178 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
pcsc-relay/src/vpcd-driver.c
View File

@@ -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;
}

48
virtualsmartcard/src/vpcd/ifd-vpcd.c
View File

@@ -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

205
virtualsmartcard/src/vpcd/vpcd.c
View File

@@ -16,19 +16,17 @@
* You should have received a copy of the GNU General Public License along with
* virtualsmartcard. If not, see <http://www.gnu.org/licenses/>.
*/
#include "vpcd.h"
#include <arpa/inet.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#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;
int i = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0)
if (sock < 0)
return -1;
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);
}

34
virtualsmartcard/src/vpcd/vpcd.h
View File

@@ -19,25 +19,51 @@
#ifndef _VPCD_H_
#define _VPCD_H_
#include <stdint.h>
#include <unistd.h>
#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