2 * CCID Passthru Card Device emulation
4 * Copyright (c) 2011 Red Hat.
5 * Written by Alon Levy.
7 * This work is licensed under the terms of the GNU GPL, version 2.1 or later.
8 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
12 #include "sysemu/char.h"
13 #include "qemu/error-report.h"
14 #include "qemu/sockets.h"
16 #include "cacard/vscard_common.h"
18 #define DPRINTF(card, lvl, fmt, ...) \
20 if (lvl <= card->debug) { \
21 printf("ccid-card-passthru: " fmt , ## __VA_ARGS__); \
30 /* TODO: do we still need this? */
31 static const uint8_t DEFAULT_ATR
[] = {
33 * From some example somewhere
34 * 0x3B, 0xB0, 0x18, 0x00, 0xD1, 0x81, 0x05, 0xB1, 0x40, 0x38, 0x1F, 0x03, 0x28
37 /* From an Athena smart card */
38 0x3B, 0xD5, 0x18, 0xFF, 0x80, 0x91, 0xFE, 0x1F, 0xC3, 0x80, 0x73, 0xC8, 0x21,
43 #define PASSTHRU_DEV_NAME "ccid-card-passthru"
44 #define VSCARD_IN_SIZE 65536
46 /* maximum size of ATR - from 7816-3 */
47 #define MAX_ATR_SIZE 40
49 typedef struct PassthruState PassthruState
;
51 struct PassthruState
{
54 uint8_t vscard_in_data
[VSCARD_IN_SIZE
];
55 uint32_t vscard_in_pos
;
56 uint32_t vscard_in_hdr
;
57 uint8_t atr
[MAX_ATR_SIZE
];
63 * VSCard protocol over chardev
64 * This code should not depend on the card type.
67 static void ccid_card_vscard_send_msg(PassthruState
*s
,
68 VSCMsgType type
, uint32_t reader_id
,
69 const uint8_t *payload
, uint32_t length
)
71 VSCMsgHeader scr_msg_header
;
73 scr_msg_header
.type
= htonl(type
);
74 scr_msg_header
.reader_id
= htonl(reader_id
);
75 scr_msg_header
.length
= htonl(length
);
76 qemu_chr_fe_write(s
->cs
, (uint8_t *)&scr_msg_header
, sizeof(VSCMsgHeader
));
77 qemu_chr_fe_write(s
->cs
, payload
, length
);
80 static void ccid_card_vscard_send_apdu(PassthruState
*s
,
81 const uint8_t *apdu
, uint32_t length
)
83 ccid_card_vscard_send_msg(
84 s
, VSC_APDU
, VSCARD_MINIMAL_READER_ID
, apdu
, length
);
87 static void ccid_card_vscard_send_error(PassthruState
*s
,
88 uint32_t reader_id
, VSCErrorCode code
)
90 VSCMsgError msg
= {.code
= htonl(code
)};
92 ccid_card_vscard_send_msg(
93 s
, VSC_Error
, reader_id
, (uint8_t *)&msg
, sizeof(msg
));
96 static void ccid_card_vscard_send_init(PassthruState
*s
)
99 .version
= htonl(VSCARD_VERSION
),
100 .magic
= VSCARD_MAGIC
,
104 ccid_card_vscard_send_msg(s
, VSC_Init
, VSCARD_UNDEFINED_READER_ID
,
105 (uint8_t *)&msg
, sizeof(msg
));
108 static int ccid_card_vscard_can_read(void *opaque
)
110 PassthruState
*card
= opaque
;
112 return VSCARD_IN_SIZE
>= card
->vscard_in_pos
?
113 VSCARD_IN_SIZE
- card
->vscard_in_pos
: 0;
116 static void ccid_card_vscard_handle_init(
117 PassthruState
*card
, VSCMsgHeader
*hdr
, VSCMsgInit
*init
)
119 uint32_t *capabilities
;
120 int num_capabilities
;
123 capabilities
= init
->capabilities
;
125 1 + ((hdr
->length
- sizeof(VSCMsgInit
)) / sizeof(uint32_t));
126 init
->version
= ntohl(init
->version
);
127 for (i
= 0 ; i
< num_capabilities
; ++i
) {
128 capabilities
[i
] = ntohl(capabilities
[i
]);
130 if (init
->magic
!= VSCARD_MAGIC
) {
131 error_report("wrong magic");
132 /* we can't disconnect the chardev */
134 if (init
->version
!= VSCARD_VERSION
) {
135 DPRINTF(card
, D_WARN
,
136 "got version %d, have %d", init
->version
, VSCARD_VERSION
);
138 /* future handling of capabilities, none exist atm */
139 ccid_card_vscard_send_init(card
);
142 static int check_atr(PassthruState
*card
, uint8_t *data
, int len
)
144 int historical_length
, opt_bytes
;
151 historical_length
= data
[1] & 0xf;
153 if (data
[0] != 0x3b && data
[0] != 0x3f) {
154 DPRINTF(card
, D_WARN
, "atr's T0 is 0x%X, not in {0x3b, 0x3f}\n",
160 while (td
&& td_count
< 2 && opt_bytes
+ historical_length
+ 2 < len
) {
173 td
= data
[opt_bytes
+ 2] >> 4;
176 if (len
< 2 + historical_length
+ opt_bytes
) {
177 DPRINTF(card
, D_WARN
,
178 "atr too short: len %d, but historical_len %d, T1 0x%X\n",
179 len
, historical_length
, data
[1]);
182 if (len
> 2 + historical_length
+ opt_bytes
) {
183 DPRINTF(card
, D_WARN
,
184 "atr too long: len %d, but hist/opt %d/%d, T1 0x%X\n",
185 len
, historical_length
, opt_bytes
, data
[1]);
188 DPRINTF(card
, D_VERBOSE
,
189 "atr passes check: %d total length, %d historical, %d optional\n",
190 len
, historical_length
, opt_bytes
);
195 static void ccid_card_vscard_handle_message(PassthruState
*card
,
196 VSCMsgHeader
*scr_msg_header
)
198 uint8_t *data
= (uint8_t *)&scr_msg_header
[1];
200 switch (scr_msg_header
->type
) {
202 DPRINTF(card
, D_INFO
, "VSC_ATR %d\n", scr_msg_header
->length
);
203 if (scr_msg_header
->length
> MAX_ATR_SIZE
) {
204 error_report("ATR size exceeds spec, ignoring");
205 ccid_card_vscard_send_error(card
, scr_msg_header
->reader_id
,
209 if (!check_atr(card
, data
, scr_msg_header
->length
)) {
210 error_report("ATR is inconsistent, ignoring");
211 ccid_card_vscard_send_error(card
, scr_msg_header
->reader_id
,
215 memcpy(card
->atr
, data
, scr_msg_header
->length
);
216 card
->atr_length
= scr_msg_header
->length
;
217 ccid_card_card_inserted(&card
->base
);
218 ccid_card_vscard_send_error(card
, scr_msg_header
->reader_id
,
222 ccid_card_send_apdu_to_guest(
223 &card
->base
, data
, scr_msg_header
->length
);
226 DPRINTF(card
, D_INFO
, "VSC_CardRemove\n");
227 ccid_card_card_removed(&card
->base
);
228 ccid_card_vscard_send_error(card
,
229 scr_msg_header
->reader_id
, VSC_SUCCESS
);
232 ccid_card_vscard_handle_init(
233 card
, scr_msg_header
, (VSCMsgInit
*)data
);
236 ccid_card_card_error(&card
->base
, *(uint32_t *)data
);
239 if (ccid_card_ccid_attach(&card
->base
) < 0) {
240 ccid_card_vscard_send_error(card
, VSCARD_UNDEFINED_READER_ID
,
241 VSC_CANNOT_ADD_MORE_READERS
);
243 ccid_card_vscard_send_error(card
, VSCARD_MINIMAL_READER_ID
,
247 case VSC_ReaderRemove
:
248 ccid_card_ccid_detach(&card
->base
);
249 ccid_card_vscard_send_error(card
,
250 scr_msg_header
->reader_id
, VSC_SUCCESS
);
253 printf("usb-ccid: chardev: unexpected message of type %X\n",
254 scr_msg_header
->type
);
255 ccid_card_vscard_send_error(card
, scr_msg_header
->reader_id
,
260 static void ccid_card_vscard_drop_connection(PassthruState
*card
)
262 qemu_chr_delete(card
->cs
);
263 card
->vscard_in_pos
= card
->vscard_in_hdr
= 0;
266 static void ccid_card_vscard_read(void *opaque
, const uint8_t *buf
, int size
)
268 PassthruState
*card
= opaque
;
271 if (card
->vscard_in_pos
+ size
> VSCARD_IN_SIZE
) {
273 "no room for data: pos %d + size %d > %d. dropping connection.",
274 card
->vscard_in_pos
, size
, VSCARD_IN_SIZE
);
275 ccid_card_vscard_drop_connection(card
);
278 assert(card
->vscard_in_pos
< VSCARD_IN_SIZE
);
279 assert(card
->vscard_in_hdr
< VSCARD_IN_SIZE
);
280 memcpy(card
->vscard_in_data
+ card
->vscard_in_pos
, buf
, size
);
281 card
->vscard_in_pos
+= size
;
282 hdr
= (VSCMsgHeader
*)(card
->vscard_in_data
+ card
->vscard_in_hdr
);
284 while ((card
->vscard_in_pos
- card
->vscard_in_hdr
>= sizeof(VSCMsgHeader
))
285 &&(card
->vscard_in_pos
- card
->vscard_in_hdr
>=
286 sizeof(VSCMsgHeader
) + ntohl(hdr
->length
))) {
287 hdr
->reader_id
= ntohl(hdr
->reader_id
);
288 hdr
->length
= ntohl(hdr
->length
);
289 hdr
->type
= ntohl(hdr
->type
);
290 ccid_card_vscard_handle_message(card
, hdr
);
291 card
->vscard_in_hdr
+= hdr
->length
+ sizeof(VSCMsgHeader
);
292 hdr
= (VSCMsgHeader
*)(card
->vscard_in_data
+ card
->vscard_in_hdr
);
294 if (card
->vscard_in_hdr
== card
->vscard_in_pos
) {
295 card
->vscard_in_pos
= card
->vscard_in_hdr
= 0;
299 static void ccid_card_vscard_event(void *opaque
, int event
)
301 PassthruState
*card
= opaque
;
304 case CHR_EVENT_BREAK
:
305 card
->vscard_in_pos
= card
->vscard_in_hdr
= 0;
307 case CHR_EVENT_FOCUS
:
309 case CHR_EVENT_OPENED
:
310 DPRINTF(card
, D_INFO
, "%s: CHR_EVENT_OPENED\n", __func__
);
315 /* End VSCard handling */
317 static void passthru_apdu_from_guest(
318 CCIDCardState
*base
, const uint8_t *apdu
, uint32_t len
)
320 PassthruState
*card
= DO_UPCAST(PassthruState
, base
, base
);
323 printf("ccid-passthru: no chardev, discarding apdu length %d\n", len
);
326 ccid_card_vscard_send_apdu(card
, apdu
, len
);
329 static const uint8_t *passthru_get_atr(CCIDCardState
*base
, uint32_t *len
)
331 PassthruState
*card
= DO_UPCAST(PassthruState
, base
, base
);
333 *len
= card
->atr_length
;
337 static int passthru_initfn(CCIDCardState
*base
)
339 PassthruState
*card
= DO_UPCAST(PassthruState
, base
, base
);
341 card
->vscard_in_pos
= 0;
342 card
->vscard_in_hdr
= 0;
344 DPRINTF(card
, D_INFO
, "initing chardev\n");
345 qemu_chr_add_handlers(card
->cs
,
346 ccid_card_vscard_can_read
,
347 ccid_card_vscard_read
,
348 ccid_card_vscard_event
, card
);
349 ccid_card_vscard_send_init(card
);
351 error_report("missing chardev");
354 card
->debug
= parse_debug_env("QEMU_CCID_PASSTHRU_DEBUG", D_VERBOSE
,
356 assert(sizeof(DEFAULT_ATR
) <= MAX_ATR_SIZE
);
357 memcpy(card
->atr
, DEFAULT_ATR
, sizeof(DEFAULT_ATR
));
358 card
->atr_length
= sizeof(DEFAULT_ATR
);
362 static int passthru_exitfn(CCIDCardState
*base
)
367 static VMStateDescription passthru_vmstate
= {
368 .name
= "ccid-card-passthru",
370 .minimum_version_id
= 1,
371 .fields
= (VMStateField
[]) {
372 VMSTATE_BUFFER(vscard_in_data
, PassthruState
),
373 VMSTATE_UINT32(vscard_in_pos
, PassthruState
),
374 VMSTATE_UINT32(vscard_in_hdr
, PassthruState
),
375 VMSTATE_BUFFER(atr
, PassthruState
),
376 VMSTATE_UINT8(atr_length
, PassthruState
),
377 VMSTATE_END_OF_LIST()
381 static Property passthru_card_properties
[] = {
382 DEFINE_PROP_CHR("chardev", PassthruState
, cs
),
383 DEFINE_PROP_UINT8("debug", PassthruState
, debug
, 0),
384 DEFINE_PROP_END_OF_LIST(),
387 static void passthru_class_initfn(ObjectClass
*klass
, void *data
)
389 DeviceClass
*dc
= DEVICE_CLASS(klass
);
390 CCIDCardClass
*cc
= CCID_CARD_CLASS(klass
);
392 cc
->initfn
= passthru_initfn
;
393 cc
->exitfn
= passthru_exitfn
;
394 cc
->get_atr
= passthru_get_atr
;
395 cc
->apdu_from_guest
= passthru_apdu_from_guest
;
396 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
397 dc
->desc
= "passthrough smartcard";
398 dc
->vmsd
= &passthru_vmstate
;
399 dc
->props
= passthru_card_properties
;
402 static const TypeInfo passthru_card_info
= {
403 .name
= PASSTHRU_DEV_NAME
,
404 .parent
= TYPE_CCID_CARD
,
405 .instance_size
= sizeof(PassthruState
),
406 .class_init
= passthru_class_initfn
,
409 static void ccid_card_passthru_register_types(void)
411 type_register_static(&passthru_card_info
);
414 type_init(ccid_card_passthru_register_types
)