mirror of
https://github.com/izzy2lost/xemu.git
synced 2026-07-06 00:20:22 -07:00
Merge remote-tracking branch 'remotes/elmarco/tags/rm-libcacard' into staging
Remove libcacard # gpg: Signature made Wed 23 Sep 2015 22:37:11 BST using RSA key ID 75969CE5 # gpg: Good signature from "Marc-André Lureau <marcandre.lureau@redhat.com>" # gpg: aka "Marc-André Lureau <marcandre.lureau@gmail.com>" # gpg: WARNING: This key is not certified with sufficiently trusted signatures! # gpg: It is not certain that the signature belongs to the owner. # Primary key fingerprint: 87A9 BD93 3F87 C606 D276 F62D DAE8 E109 7596 9CE5 * remotes/elmarco/tags/rm-libcacard: libcacard: use the standalone project Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
@@ -19,7 +19,6 @@
|
||||
/trace/generated-ust.c
|
||||
/ui/shader/texture-blit-frag.h
|
||||
/ui/shader/texture-blit-vert.h
|
||||
/libcacard/trace/generated-tracers.c
|
||||
*-timestamp
|
||||
/*-softmmu
|
||||
/*-darwin-user
|
||||
|
||||
@@ -163,9 +163,6 @@ dummy := $(call unnest-vars,, \
|
||||
ifneq ($(wildcard config-host.mak),)
|
||||
include $(SRC_PATH)/tests/Makefile
|
||||
endif
|
||||
ifeq ($(CONFIG_SMARTCARD_NSS),y)
|
||||
include $(SRC_PATH)/libcacard/Makefile
|
||||
endif
|
||||
|
||||
all: $(DOCS) $(TOOLS) $(HELPERS-y) recurse-all modules
|
||||
|
||||
|
||||
@@ -32,18 +32,6 @@ crypto-aes-obj-y = crypto/
|
||||
|
||||
qom-obj-y = qom/
|
||||
|
||||
######################################################################
|
||||
# smartcard
|
||||
|
||||
libcacard-y += libcacard/cac.o libcacard/event.o
|
||||
libcacard-y += libcacard/vcard.o libcacard/vreader.o
|
||||
libcacard-y += libcacard/vcard_emul_nss.o
|
||||
libcacard-y += libcacard/vcard_emul_type.o
|
||||
libcacard-y += libcacard/card_7816.o
|
||||
libcacard-y += libcacard/vcardt.o
|
||||
libcacard/vcard_emul_nss.o-cflags := $(NSS_CFLAGS)
|
||||
libcacard/vcard_emul_nss.o-libs := $(NSS_LIBS)
|
||||
|
||||
######################################################################
|
||||
# Target independent part of system emulation. The long term path is to
|
||||
# suppress *all* target specific code in case of system emulation, i.e. a
|
||||
@@ -85,8 +73,6 @@ common-obj-y += backends/
|
||||
|
||||
common-obj-$(CONFIG_SECCOMP) += qemu-seccomp.o
|
||||
|
||||
common-obj-$(CONFIG_SMARTCARD_NSS) += $(libcacard-y)
|
||||
|
||||
common-obj-$(CONFIG_FDT) += device_tree.o
|
||||
|
||||
######################################################################
|
||||
|
||||
@@ -302,7 +302,7 @@ trace_backends="nop"
|
||||
trace_file="trace"
|
||||
spice=""
|
||||
rbd=""
|
||||
smartcard_nss=""
|
||||
smartcard=""
|
||||
libusb=""
|
||||
usb_redir=""
|
||||
opengl=""
|
||||
@@ -1039,9 +1039,9 @@ for opt do
|
||||
;;
|
||||
--enable-xfsctl) xfs="yes"
|
||||
;;
|
||||
--disable-smartcard-nss) smartcard_nss="no"
|
||||
--disable-smartcard) smartcard="no"
|
||||
;;
|
||||
--enable-smartcard-nss) smartcard_nss="yes"
|
||||
--enable-smartcard) smartcard="yes"
|
||||
;;
|
||||
--disable-libusb) libusb="no"
|
||||
;;
|
||||
@@ -1354,7 +1354,7 @@ disabled with --disable-FEATURE, default is enabled if available:
|
||||
rbd rados block device (rbd)
|
||||
libiscsi iscsi support
|
||||
libnfs nfs support
|
||||
smartcard-nss smartcard nss support
|
||||
smartcard smartcard support (libcacard)
|
||||
libusb libusb (for usb passthrough)
|
||||
usb-redir usb network redirection support
|
||||
lzo support of lzo compression library
|
||||
@@ -3810,34 +3810,20 @@ EOF
|
||||
fi
|
||||
fi
|
||||
|
||||
# check for libcacard for smartcard support
|
||||
# check for smartcard support
|
||||
smartcard_cflags=""
|
||||
# TODO - what's the minimal nss version we support?
|
||||
if test "$smartcard_nss" != "no"; then
|
||||
cat > $TMPC << EOF
|
||||
#include <pk11pub.h>
|
||||
int main(void) { PK11_FreeSlot(0); return 0; }
|
||||
EOF
|
||||
# FIXME: do not include $glib_* in here
|
||||
nss_libs="$($pkg_config --libs nss 2>/dev/null) $glib_libs"
|
||||
nss_cflags="$($pkg_config --cflags nss 2>/dev/null) $glib_cflags"
|
||||
test_cflags="$nss_cflags"
|
||||
# The header files in nss < 3.13.3 have a bug which causes them to
|
||||
# emit a warning. If we're going to compile QEMU with -Werror, then
|
||||
# test that the headers don't have this bug. Otherwise we would pass
|
||||
# the configure test but fail to compile QEMU later.
|
||||
if test "$werror" = "yes"; then
|
||||
test_cflags="-Werror $test_cflags"
|
||||
fi
|
||||
if test -n "$libtool" &&
|
||||
$pkg_config --atleast-version=3.12.8 nss && \
|
||||
compile_prog "$test_cflags" "$nss_libs"; then
|
||||
smartcard_nss="yes"
|
||||
if test "$smartcard" != "no"; then
|
||||
if $pkg_config libcacard; then
|
||||
libcacard_cflags=$($pkg_config --cflags libcacard)
|
||||
libcacard_libs=$($pkg_config --libs libcacard)
|
||||
QEMU_CFLAGS="$QEMU_CFLAGS $libcacard_cflags"
|
||||
libs_softmmu="$libs_softmmu $libcacard_libs"
|
||||
smartcard="yes"
|
||||
else
|
||||
if test "$smartcard_nss" = "yes"; then
|
||||
feature_not_found "nss" "Install nss devel >= 3.12.8"
|
||||
if test "$smartcard" = "yes"; then
|
||||
feature_not_found "smartcard" "Install libcacard devel"
|
||||
fi
|
||||
smartcard_nss="no"
|
||||
smartcard="no"
|
||||
fi
|
||||
fi
|
||||
|
||||
@@ -4618,7 +4604,7 @@ echo "spice support $spice"
|
||||
fi
|
||||
echo "rbd support $rbd"
|
||||
echo "xfsctl support $xfs"
|
||||
echo "nss used $smartcard_nss"
|
||||
echo "smartcard support $smartcard"
|
||||
echo "libusb $libusb"
|
||||
echo "usb net redir $usb_redir"
|
||||
echo "OpenGL support $opengl"
|
||||
@@ -4995,10 +4981,8 @@ if test "$spice" = "yes" ; then
|
||||
echo "CONFIG_SPICE=y" >> $config_host_mak
|
||||
fi
|
||||
|
||||
if test "$smartcard_nss" = "yes" ; then
|
||||
echo "CONFIG_SMARTCARD_NSS=y" >> $config_host_mak
|
||||
echo "NSS_LIBS=$nss_libs" >> $config_host_mak
|
||||
echo "NSS_CFLAGS=$nss_cflags" >> $config_host_mak
|
||||
if test "$smartcard" = "yes" ; then
|
||||
echo "CONFIG_SMARTCARD=y" >> $config_host_mak
|
||||
fi
|
||||
|
||||
if test "$libusb" = "yes" ; then
|
||||
|
||||
@@ -1,483 +0,0 @@
|
||||
This file documents the CAC (Common Access Card) library in the libcacard
|
||||
subdirectory.
|
||||
|
||||
Virtual Smart Card Emulator
|
||||
|
||||
This emulator is designed to provide emulation of actual smart cards to a
|
||||
virtual card reader running in a guest virtual machine. The emulated smart
|
||||
cards can be representations of real smart cards, where the necessary functions
|
||||
such as signing, card removal/insertion, etc. are mapped to real, physical
|
||||
cards which are shared with the client machine the emulator is running on, or
|
||||
the cards could be pure software constructs.
|
||||
|
||||
The emulator is structured to allow multiple replaceable or additional pieces,
|
||||
so it can be easily modified for future requirements. The primary envisioned
|
||||
modifications are:
|
||||
|
||||
1) The socket connection to the virtual card reader (presumably a CCID reader,
|
||||
but other ISO-7816 compatible readers could be used). The code that handles
|
||||
this is in vscclient.c.
|
||||
|
||||
2) The virtual card low level emulation. This is currently supplied by using
|
||||
NSS. This emulation could be replaced by implementations based on other
|
||||
security libraries, including but not limitted to openssl+pkcs#11 library,
|
||||
raw pkcs#11, Microsoft CAPI, direct opensc calls, etc. The code that handles
|
||||
this is in vcard_emul_nss.c.
|
||||
|
||||
3) Emulation for new types of cards. The current implementation emulates the
|
||||
original DoD CAC standard with separate pki containers. This emulator lives in
|
||||
cac.c. More than one card type emulator could be included. Other cards could
|
||||
be emulated as well, including PIV, newer versions of CAC, PKCS #15, etc.
|
||||
|
||||
--------------------
|
||||
Replacing the Socket Based Virtual Reader Interface.
|
||||
|
||||
The current implementation contains a replaceable module vscclient.c. The
|
||||
current vscclient.c implements a sockets interface to the virtual ccid reader
|
||||
on the guest. CCID commands that are pertinent to emulation are passed
|
||||
across the socket, and their responses are passed back along that same socket.
|
||||
The protocol that vscclient uses is defined in vscard_common.h and connects
|
||||
to a qemu ccid usb device. Since this socket runs as a client, vscclient.c
|
||||
implements a program with a main entry. It also handles argument parsing for
|
||||
the emulator.
|
||||
|
||||
An application that wants to use the virtual reader can replace vscclient.c
|
||||
with its own implementation that connects to its own CCID reader. The calls
|
||||
that the CCID reader can call are:
|
||||
|
||||
VReaderList * vreader_get_reader_list();
|
||||
|
||||
This function returns a list of virtual readers. These readers may map to
|
||||
physical devices, or simulated devices depending on vcard the back end. Each
|
||||
reader in the list should represent a reader to the virtual machine. Virtual
|
||||
USB address mapping is left to the CCID reader front end. This call can be
|
||||
made any time to get an updated list. The returned list is a copy of the
|
||||
internal list that can be referenced by the caller without locking. This copy
|
||||
must be freed by the caller with vreader_list_delete when it is no longer
|
||||
needed.
|
||||
|
||||
VReaderListEntry *vreader_list_get_first(VReaderList *);
|
||||
|
||||
This function gets the first entry on the reader list. Along with
|
||||
vreader_list_get_next(), vreader_list_get_first() can be used to walk the
|
||||
reader list returned from vreader_get_reader_list(). VReaderListEntries are
|
||||
part of the list themselves and do not need to be freed separately from the
|
||||
list. If there are no entries on the list, it will return NULL.
|
||||
|
||||
VReaderListEntry *vreader_list_get_next(VReaderListEntry *);
|
||||
|
||||
This function gets the next entry in the list. If there are no more entries
|
||||
it will return NULL.
|
||||
|
||||
VReader * vreader_list_get_reader(VReaderListEntry *)
|
||||
|
||||
This function returns the reader stored in the reader List entry. Caller gets
|
||||
a new reference to a reader. The caller must free its reference when it is
|
||||
finished with vreader_free().
|
||||
|
||||
void vreader_free(VReader *reader);
|
||||
|
||||
This function frees a reference to a reader. Readers are reference counted
|
||||
and are automatically deleted when the last reference is freed.
|
||||
|
||||
void vreader_list_delete(VReaderList *list);
|
||||
|
||||
This function frees the list, all the elements on the list, and all the
|
||||
reader references held by the list.
|
||||
|
||||
VReaderStatus vreader_power_on(VReader *reader, char *atr, int *len);
|
||||
|
||||
This function simulates a card power on. A virtual card does not care about
|
||||
the actual voltage and other physical parameters, but it does care that the
|
||||
card is actually on or off. Cycling the card causes the card to reset. If
|
||||
the caller provides enough space, vreader_power_on will return the ATR of
|
||||
the virtual card. The amount of space provided in atr should be indicated
|
||||
in *len. The function modifies *len to be the actual length of of the
|
||||
returned ATR.
|
||||
|
||||
VReaderStatus vreader_power_off(VReader *reader);
|
||||
|
||||
This function simulates a power off of a virtual card.
|
||||
|
||||
VReaderStatus vreader_xfer_bytes(VReader *reader, unsigne char *send_buf,
|
||||
int send_buf_len,
|
||||
unsigned char *receive_buf,
|
||||
int receive_buf_len);
|
||||
|
||||
This function sends a raw apdu to a card and returns the card's response.
|
||||
The CCID front end should return the response back. Most of the emulation
|
||||
is driven from these APDUs.
|
||||
|
||||
VReaderStatus vreader_card_is_present(VReader *reader);
|
||||
|
||||
This function returns whether or not the reader has a card inserted. The
|
||||
vreader_power_on, vreader_power_off, and vreader_xfer_bytes will return
|
||||
VREADER_NO_CARD.
|
||||
|
||||
const char *vreader_get_name(VReader *reader);
|
||||
|
||||
This function returns the name of the reader. The name comes from the card
|
||||
emulator level and is usually related to the name of the physical reader.
|
||||
|
||||
VReaderID vreader_get_id(VReader *reader);
|
||||
|
||||
This function returns the id of a reader. All readers start out with an id
|
||||
of -1. The application can set the id with vreader_set_id.
|
||||
|
||||
VReaderStatus vreader_get_id(VReader *reader, VReaderID id);
|
||||
|
||||
This function sets the reader id. The application is responsible for making
|
||||
sure that the id is unique for all readers it is actively using.
|
||||
|
||||
VReader *vreader_find_reader_by_id(VReaderID id);
|
||||
|
||||
This function returns the reader which matches the id. If two readers match,
|
||||
only one is returned. The function returns NULL if the id is -1.
|
||||
|
||||
Event *vevent_wait_next_vevent();
|
||||
|
||||
This function blocks waiting for reader and card insertion events. There
|
||||
will be one event for each card insertion, each card removal, each reader
|
||||
insertion and each reader removal. At start up, events are created for all
|
||||
the initial readers found, as well as all the cards that are inserted.
|
||||
|
||||
Event *vevent_get_next_vevent();
|
||||
|
||||
This function returns a pending event if it exists, otherwise it returns
|
||||
NULL. It does not block.
|
||||
|
||||
----------------
|
||||
Card Type Emulator: Adding a New Virtual Card Type
|
||||
|
||||
The ISO 7816 card spec describes 2 types of cards:
|
||||
1) File system cards, where the smartcard is managed by reading and writing
|
||||
data to files in a file system. There is currently only boiler plate
|
||||
implemented for file system cards.
|
||||
2) VM cards, where the card has loadable applets which perform the card
|
||||
functions. The current implementation supports VM cards.
|
||||
|
||||
In the case of VM cards, the difference between various types of cards is
|
||||
really what applets have been installed in that card. This structure is
|
||||
mirrored in card type emulators. The 7816 emulator already handles the basic
|
||||
ISO 7186 commands. Card type emulators simply need to add the virtual applets
|
||||
which emulate the real card applets. Card type emulators have exactly one
|
||||
public entry point:
|
||||
|
||||
VCARDStatus xxx_card_init(VCard *card, const char *flags,
|
||||
const unsigned char *cert[],
|
||||
int cert_len[],
|
||||
VCardKey *key[],
|
||||
int cert_count);
|
||||
|
||||
The parameters for this are:
|
||||
card - the virtual card structure which will represent this card.
|
||||
flags - option flags that may be specific to this card type.
|
||||
cert - array of binary certificates.
|
||||
cert_len - array of lengths of each of the certificates specified in cert.
|
||||
key - array of opaque key structures representing the private keys on
|
||||
the card.
|
||||
cert_count - number of entries in cert, cert_len, and key arrays.
|
||||
|
||||
Any cert, cert_len, or key with the same index are matching sets. That is
|
||||
cert[0] is cert_len[0] long and has the corresponding private key of key[0].
|
||||
|
||||
The card type emulator is expected to own the VCardKeys, but it should copy
|
||||
any raw cert data it wants to save. It can create new applets and add them to
|
||||
the card using the following functions:
|
||||
|
||||
VCardApplet *vcard_new_applet(VCardProcessAPDU apdu_func,
|
||||
VCardResetApplet reset_func,
|
||||
const unsigned char *aid,
|
||||
int aid_len);
|
||||
|
||||
This function creates a new applet. Applet structures store the following
|
||||
information:
|
||||
1) the AID of the applet (set by aid and aid_len).
|
||||
2) a function to handle APDUs for this applet. (set by apdu_func, more on
|
||||
this below).
|
||||
3) a function to reset the applet state when the applet is selected.
|
||||
(set by reset_func, more on this below).
|
||||
3) applet private data, a data pointer used by the card type emulator to
|
||||
store any data or state it needs to complete requests. (set by a
|
||||
separate call).
|
||||
4) applet private data free, a function used to free the applet private
|
||||
data when the applet itself is destroyed.
|
||||
The created applet can be added to the card with vcard_add_applet below.
|
||||
|
||||
void vcard_set_applet_private(VCardApplet *applet,
|
||||
VCardAppletPrivate *private,
|
||||
VCardAppletPrivateFree private_free);
|
||||
This function sets the private data and the corresponding free function.
|
||||
VCardAppletPrivate is an opaque data structure to the rest of the emulator.
|
||||
The card type emulator can define it any way it wants by defining
|
||||
struct VCardAppletPrivateStruct {};. If there is already a private data
|
||||
structure on the applet, the old one is freed before the new one is set up.
|
||||
passing two NULL clear any existing private data.
|
||||
|
||||
VCardStatus vcard_add_applet(VCard *card, VCardApplet *applet);
|
||||
|
||||
Add an applet onto the list of applets attached to the card. Once an applet
|
||||
has been added, it can be selected by its AID, and then commands will be
|
||||
routed to it VCardProcessAPDU function. This function adopts the applet that
|
||||
is passed into it. Note: 2 applets with the same AID should not be added to
|
||||
the same card. It is permissible to add more than one applet. Multiple applets
|
||||
may have the same VCardPRocessAPDU entry point.
|
||||
|
||||
The certs and keys should be attached to private data associated with one or
|
||||
more appropriate applets for that card. Control will come to the card type
|
||||
emulators once one of its applets are selected through the VCardProcessAPDU
|
||||
function it specified when it created the applet.
|
||||
|
||||
The signature of VCardResetApplet is:
|
||||
VCardStatus (*VCardResetApplet) (VCard *card, int channel);
|
||||
This function will reset the any internal applet state that needs to be
|
||||
cleared after a select applet call. It should return VCARD_DONE;
|
||||
|
||||
The signature of VCardProcessAPDU is:
|
||||
VCardStatus (*VCardProcessAPDU)(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response);
|
||||
This function examines the APDU and determines whether it should process
|
||||
the apdu directly, reject the apdu as invalid, or pass the apdu on to
|
||||
the basic 7816 emulator for processing.
|
||||
If the 7816 emulator should process the apdu, then the VCardProcessAPDU
|
||||
should return VCARD_NEXT.
|
||||
If there is an error, then VCardProcessAPDU should return an error
|
||||
response using vcard_make_response and the appropriate 7816 error code
|
||||
(see card_7816t.h) or vcard_make_response with a card type specific error
|
||||
code. It should then return VCARD_DONE.
|
||||
If the apdu can be processed correctly, VCardProcessAPDU should do so,
|
||||
set the response value appropriately for that APDU, and return VCARD_DONE.
|
||||
VCardProcessAPDU should always set the response if it returns VCARD_DONE.
|
||||
It should always either return VCARD_DONE or VCARD_NEXT.
|
||||
|
||||
Parsing the APDU --
|
||||
|
||||
Prior to processing calling the card type emulator's VCardProcessAPDU function, the emulator has already decoded the APDU header and set several fields:
|
||||
|
||||
apdu->a_data - The raw apdu data bytes.
|
||||
apdu->a_len - The len of the raw apdu data.
|
||||
apdu->a_body - The start of any post header parameter data.
|
||||
apdu->a_Lc - The parameter length value.
|
||||
apdu->a_Le - The expected length of any returned data.
|
||||
apdu->a_cla - The raw apdu class.
|
||||
apdu->a_channel - The channel (decoded from the class).
|
||||
apdu->a_secure_messaging_type - The decoded secure messaging type
|
||||
(from class).
|
||||
apdu->a_type - The decode class type.
|
||||
apdu->a_gen_type - the generic class type (7816, PROPRIETARY, RFU, PTS).
|
||||
apdu->a_ins - The instruction byte.
|
||||
apdu->a_p1 - Parameter 1.
|
||||
apdu->a_p2 - Parameter 2.
|
||||
|
||||
Creating a Response --
|
||||
|
||||
The expected result of any APDU call is a response. The card type emulator must
|
||||
set *response with an appropriate VCardResponse value if it returns VCARD_DONE.
|
||||
Responses could be as simple as returning a 2 byte status word response, to as
|
||||
complex as returning a block of data along with a 2 byte response. Which is
|
||||
returned will depend on the semantics of the APDU. The following functions will
|
||||
create card responses.
|
||||
|
||||
VCardResponse *vcard_make_response(VCard7816Status status);
|
||||
|
||||
This is the most basic function to get a response. This function will
|
||||
return a response the consists solely one 2 byte status code. If that status
|
||||
code is defined in card_7816t.h, then this function is guaranteed to
|
||||
return a response with that status. If a cart type specific status code
|
||||
is passed and vcard_make_response fails to allocate the appropriate memory
|
||||
for that response, then vcard_make_response will return a VCardResponse
|
||||
of VCARD7816_STATUS_EXC_ERROR_MEMORY. In any case, this function is
|
||||
guaranteed to return a valid VCardResponse.
|
||||
|
||||
VCardResponse *vcard_response_new(unsigned char *buf, int len,
|
||||
VCard7816Status status);
|
||||
|
||||
This function is similar to vcard_make_response except it includes some
|
||||
returned data with the response. It could also fail to allocate enough
|
||||
memory, in which case it will return NULL.
|
||||
|
||||
VCardResponse *vcard_response_new_status_bytes(unsigned char sw1,
|
||||
unsigned char sw2);
|
||||
|
||||
Sometimes in 7816 the response bytes are treated as two separate bytes with
|
||||
split meanings. This function allows you to create a response based on
|
||||
two separate bytes. This function could fail, in which case it will return
|
||||
NULL.
|
||||
|
||||
VCardResponse *vcard_response_new_bytes(unsigned char *buf, int len,
|
||||
unsigned char sw1,
|
||||
unsigned char sw2);
|
||||
|
||||
This function is the same as vcard_response_new except you may specify
|
||||
the status as two separate bytes like vcard_response_new_status_bytes.
|
||||
|
||||
|
||||
Implementing functionality ---
|
||||
|
||||
The following helper functions access information about the current card
|
||||
and applet.
|
||||
|
||||
VCARDAppletPrivate *vcard_get_current_applet_private(VCard *card,
|
||||
int channel);
|
||||
|
||||
This function returns any private data set by the card type emulator on
|
||||
the currently selected applet. The card type emulator keeps track of the
|
||||
current applet state in this data structure. Any certs and keys associated
|
||||
with a particular applet is also stored here.
|
||||
|
||||
int vcard_emul_get_login_count(VCard *card);
|
||||
|
||||
This function returns the number of remaining login attempts for this
|
||||
card. If the card emulator does not know, or the card does not have a
|
||||
way of giving this information, this function returns -1.
|
||||
|
||||
|
||||
VCard7816Status vcard_emul_login(VCard *card, unsigned char *pin,
|
||||
int pin_len);
|
||||
|
||||
This function logs into the card and returns the standard 7816 status
|
||||
word depending on the success or failure of the call.
|
||||
|
||||
void vcard_emul_delete_key(VCardKey *key);
|
||||
|
||||
This function frees the VCardKey passed in to xxxx_card_init. The card
|
||||
type emulator is responsible for freeing this key when it no longer needs
|
||||
it.
|
||||
|
||||
VCard7816Status vcard_emul_rsa_op(VCard *card, VCardKey *key,
|
||||
unsigned char *buffer,
|
||||
int buffer_size);
|
||||
|
||||
This function does a raw rsa op on the buffer with the given key.
|
||||
|
||||
The sample card type emulator is found in cac.c. It implements the cac specific
|
||||
applets. Only those applets needed by the coolkey pkcs#11 driver on the guest
|
||||
have been implemented. To support the full range CAC middleware, a complete CAC
|
||||
card according to the CAC specs should be implemented here.
|
||||
|
||||
------------------------------
|
||||
Virtual Card Emulator
|
||||
|
||||
This code accesses both real smart cards and simulated smart cards through
|
||||
services provided on the client. The current implementation uses NSS, which
|
||||
already knows how to talk to various PKCS #11 modules on the client, and is
|
||||
portable to most operating systems. A particular emulator can have only one
|
||||
virtual card implementation at a time.
|
||||
|
||||
The virtual card emulator consists of a series of virtual card services. In
|
||||
addition to the services describe above (services starting with
|
||||
vcard_emul_xxxx), the virtual card emulator also provides the following
|
||||
functions:
|
||||
|
||||
VCardEmulError vcard_emul_init(cont VCardEmulOptions *options);
|
||||
|
||||
The options structure is built by another function in the virtual card
|
||||
interface where a string of virtual card emulator specific strings are
|
||||
mapped to the options. The actual structure is defined by the virtual card
|
||||
emulator and is used to determine the configuration of soft cards, or to
|
||||
determine which physical cards to present to the guest.
|
||||
|
||||
The vcard_emul_init function will build up sets of readers, create any
|
||||
threads that are needed to watch for changes in the reader state. If readers
|
||||
have cards present in them, they are also initialized.
|
||||
|
||||
Readers are created with the function.
|
||||
|
||||
VReader *vreader_new(VReaderEmul *reader_emul,
|
||||
VReaderEmulFree reader_emul_free);
|
||||
|
||||
The freeFunc is used to free the VReaderEmul * when the reader is
|
||||
destroyed. The VReaderEmul structure is an opaque structure to the
|
||||
rest of the code, but defined by the virtual card emulator, which can
|
||||
use it to store any reader specific state.
|
||||
|
||||
Once the reader has been created, it can be added to the front end with the
|
||||
call:
|
||||
|
||||
VReaderStatus vreader_add_reader(VReader *reader);
|
||||
|
||||
This function will automatically generate the appropriate new reader
|
||||
events and add the reader to the list.
|
||||
|
||||
To create a new card, the virtual card emulator will call a similar
|
||||
function.
|
||||
|
||||
VCard *vcard_new(VCardEmul *card_emul,
|
||||
VCardEmulFree card_emul_free);
|
||||
|
||||
Like vreader_new, this function takes a virtual card emulator specific
|
||||
structure which it uses to keep track of the card state.
|
||||
|
||||
Once the card is created, it is attached to a card type emulator with the
|
||||
following function:
|
||||
|
||||
VCardStatus vcard_init(VCard *vcard, VCardEmulType type,
|
||||
const char *flags,
|
||||
unsigned char *const *certs,
|
||||
int *cert_len,
|
||||
VCardKey *key[],
|
||||
int cert_count);
|
||||
|
||||
The vcard is the value returned from vcard_new. The type is the
|
||||
card type emulator that this card should presented to the guest as.
|
||||
The flags are card type emulator specific options. The certs,
|
||||
cert_len, and keys are all arrays of length cert_count. These are
|
||||
the same of the parameters xxxx_card_init() accepts.
|
||||
|
||||
Finally the card is associated with its reader by the call:
|
||||
|
||||
VReaderStatus vreader_insert_card(VReader *vreader, VCard *vcard);
|
||||
|
||||
This function, like vreader_add_reader, will take care of any event
|
||||
notification for the card insert.
|
||||
|
||||
|
||||
VCardEmulError vcard_emul_force_card_remove(VReader *vreader);
|
||||
|
||||
Force a card that is present to appear to be removed to the guest, even if
|
||||
that card is a physical card and is present.
|
||||
|
||||
|
||||
VCardEmulError vcard_emul_force_card_insert(VReader *reader);
|
||||
|
||||
Force a card that has been removed by vcard_emul_force_card_remove to be
|
||||
reinserted from the point of view of the guest. This will only work if the
|
||||
card is physically present (which is always true fro a soft card).
|
||||
|
||||
void vcard_emul_get_atr(Vcard *card, unsigned char *atr, int *atr_len);
|
||||
|
||||
Return the virtual ATR for the card. By convention this should be the value
|
||||
VCARD_ATR_PREFIX(size) followed by several ascii bytes related to this
|
||||
particular emulator. For instance the NSS emulator returns
|
||||
{VCARD_ATR_PREFIX(3), 'N', 'S', 'S' }. Do ot return more data then *atr_len;
|
||||
|
||||
void vcard_emul_reset(VCard *card, VCardPower power)
|
||||
|
||||
Set the state of 'card' to the current power level and reset its internal
|
||||
state (logout, etc).
|
||||
|
||||
-------------------------------------------------------
|
||||
List of files and their function:
|
||||
README - This file
|
||||
card_7816.c - emulate basic 7816 functionality. Parse APDUs.
|
||||
card_7816.h - apdu and response services definitions.
|
||||
card_7816t.h - 7816 specific structures, types and definitions.
|
||||
event.c - event handling code.
|
||||
event.h - event handling services definitions.
|
||||
eventt.h - event handling structures and types
|
||||
vcard.c - handle common virtual card services like creation, destruction, and
|
||||
applet management.
|
||||
vcard.h - common virtual card services function definitions.
|
||||
vcardt.h - comon virtual card types
|
||||
vreader.c - common virtual reader services.
|
||||
vreader.h - common virtual reader services definitions.
|
||||
vreadert.h - comon virtual reader types.
|
||||
vcard_emul_type.c - manage the card type emulators.
|
||||
vcard_emul_type.h - definitions for card type emulators.
|
||||
cac.c - card type emulator for CAC cards
|
||||
vcard_emul.h - virtual card emulator service definitions.
|
||||
vcard_emul_nss.c - virtual card emulator implementation for nss.
|
||||
vscclient.c - socket connection to guest qemu usb driver.
|
||||
vscard_common.h - common header with the guest qemu usb driver.
|
||||
mutex.h - header file for machine independent mutexes.
|
||||
link_test.c - static test to make sure all the symbols are properly defined.
|
||||
@@ -23,9 +23,8 @@ common-obj-$(CONFIG_USB_BLUETOOTH) += dev-bluetooth.o
|
||||
|
||||
ifeq ($(CONFIG_USB_SMARTCARD),y)
|
||||
common-obj-y += dev-smartcard-reader.o
|
||||
common-obj-y += ccid-card-passthru.o
|
||||
common-obj-$(CONFIG_SMARTCARD_NSS) += ccid-card-emulated.o
|
||||
ccid-card-emulated.o-cflags := -I$(SRC_PATH)/libcacard
|
||||
common-obj-$(CONFIG_SMARTCARD) += ccid-card-passthru.o
|
||||
common-obj-$(CONFIG_SMARTCARD) += ccid-card-emulated.o
|
||||
endif
|
||||
|
||||
ifeq ($(CONFIG_POSIX),y)
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
#include "qemu/error-report.h"
|
||||
#include "qemu/sockets.h"
|
||||
#include "ccid.h"
|
||||
#include "libcacard/vscard_common.h"
|
||||
#include "cacard/vscard_common.h"
|
||||
|
||||
#define DPRINTF(card, lvl, fmt, ...) \
|
||||
do { \
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
libcacard_includedir=$(includedir)/cacard
|
||||
|
||||
TOOLS += vscclient$(EXESUF)
|
||||
|
||||
# objects linked into a shared library, built with libtool with -fPIC if required
|
||||
libcacard-obj-y = $(libcacard-y)
|
||||
libcacard-lobj-y=$(patsubst %.o,%.lo,$(libcacard-obj-y))
|
||||
|
||||
# libtool will build the .o files, too
|
||||
$(libcacard-obj-y): | $(libcacard-lobj-y)
|
||||
|
||||
all: libcacard.la libcacard.pc
|
||||
|
||||
vscclient$(EXESUF): libcacard/vscclient.o libcacard.la
|
||||
$(call LINK,$^)
|
||||
|
||||
#########################################################################
|
||||
# Rules for building libcacard standalone library
|
||||
|
||||
libcacard.la: LDFLAGS += -rpath $(libdir) -no-undefined \
|
||||
-export-symbols $(SRC_PATH)/libcacard/libcacard.syms
|
||||
# Prevent libcacard.so linking against the entire world of 3rd party libs
|
||||
libcacard.la: LIBS =
|
||||
libcacard.la: $(libcacard-lobj-y)
|
||||
$(call LINK,$^)
|
||||
|
||||
libcacard.pc: $(SRC_PATH)/libcacard/libcacard.pc.in
|
||||
$(call quiet-command,sed -e 's|@LIBDIR@|$(libdir)|' \
|
||||
-e 's|@INCLUDEDIR@|$(libcacard_includedir)|' \
|
||||
-e 's|@VERSION@|$(shell cat $(SRC_PATH)/VERSION)|' \
|
||||
-e 's|@PREFIX@|$(prefix)|' $< > libcacard.pc,\
|
||||
" GEN $@")
|
||||
|
||||
.PHONY: install-libcacard
|
||||
|
||||
install: install-libcacard
|
||||
install-libcacard: libcacard.pc libcacard.la
|
||||
$(INSTALL_DIR) "$(DESTDIR)$(libdir)"
|
||||
$(INSTALL_DIR) "$(DESTDIR)$(libdir)/pkgconfig"
|
||||
$(INSTALL_DIR) "$(DESTDIR)$(libcacard_includedir)"
|
||||
$(INSTALL_LIB) libcacard.la "$(DESTDIR)$(libdir)"
|
||||
$(INSTALL_DATA) libcacard.pc "$(DESTDIR)$(libdir)/pkgconfig"
|
||||
for inc in $(SRC_PATH)/libcacard/*.h; do \
|
||||
$(INSTALL_DATA) $$inc "$(DESTDIR)$(libcacard_includedir)"; \
|
||||
done
|
||||
-414
@@ -1,414 +0,0 @@
|
||||
/*
|
||||
* implement the applets for the CAC card.
|
||||
*
|
||||
* This code is licensed under the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "glib-compat.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "cac.h"
|
||||
#include "vcard.h"
|
||||
#include "vcard_emul.h"
|
||||
#include "card_7816.h"
|
||||
|
||||
/* private data for PKI applets */
|
||||
typedef struct CACPKIAppletDataStruct {
|
||||
unsigned char *cert;
|
||||
int cert_len;
|
||||
unsigned char *cert_buffer;
|
||||
int cert_buffer_len;
|
||||
unsigned char *sign_buffer;
|
||||
int sign_buffer_len;
|
||||
VCardKey *key;
|
||||
} CACPKIAppletData;
|
||||
|
||||
/*
|
||||
* CAC applet private data
|
||||
*/
|
||||
struct VCardAppletPrivateStruct {
|
||||
union {
|
||||
CACPKIAppletData pki_data;
|
||||
void *reserved;
|
||||
} u;
|
||||
};
|
||||
|
||||
/*
|
||||
* handle all the APDU's that are common to all CAC applets
|
||||
*/
|
||||
static VCardStatus
|
||||
cac_common_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
|
||||
{
|
||||
int ef;
|
||||
VCardStatus ret = VCARD_FAIL;
|
||||
|
||||
switch (apdu->a_ins) {
|
||||
case VCARD7816_INS_SELECT_FILE:
|
||||
if (apdu->a_p1 != 0x02) {
|
||||
/* let the 7816 code handle applet switches */
|
||||
ret = VCARD_NEXT;
|
||||
break;
|
||||
}
|
||||
/* handle file id setting */
|
||||
if (apdu->a_Lc != 2) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_DATA_INVALID);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
}
|
||||
/* CAC 1.0 only supports ef = 0 */
|
||||
ef = apdu->a_body[0] | (apdu->a_body[1] << 8);
|
||||
if (ef != 0) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
}
|
||||
*response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
case VCARD7816_INS_GET_RESPONSE:
|
||||
case VCARD7816_INS_VERIFY:
|
||||
/* let the 7816 code handle these */
|
||||
ret = VCARD_NEXT;
|
||||
break;
|
||||
case CAC_GET_PROPERTIES:
|
||||
case CAC_GET_ACR:
|
||||
/* skip these for now, this will probably be needed */
|
||||
*response = vcard_make_response(VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
default:
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* reset the inter call state between applet selects
|
||||
*/
|
||||
static VCardStatus
|
||||
cac_applet_pki_reset(VCard *card, int channel)
|
||||
{
|
||||
VCardAppletPrivate *applet_private;
|
||||
CACPKIAppletData *pki_applet;
|
||||
applet_private = vcard_get_current_applet_private(card, channel);
|
||||
assert(applet_private);
|
||||
pki_applet = &(applet_private->u.pki_data);
|
||||
|
||||
pki_applet->cert_buffer = NULL;
|
||||
g_free(pki_applet->sign_buffer);
|
||||
pki_applet->sign_buffer = NULL;
|
||||
pki_applet->cert_buffer_len = 0;
|
||||
pki_applet->sign_buffer_len = 0;
|
||||
return VCARD_DONE;
|
||||
}
|
||||
|
||||
static VCardStatus
|
||||
cac_applet_pki_process_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response)
|
||||
{
|
||||
CACPKIAppletData *pki_applet;
|
||||
VCardAppletPrivate *applet_private;
|
||||
int size, next;
|
||||
unsigned char *sign_buffer;
|
||||
bool retain_sign_buffer = FALSE;
|
||||
vcard_7816_status_t status;
|
||||
VCardStatus ret = VCARD_FAIL;
|
||||
|
||||
applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
|
||||
assert(applet_private);
|
||||
pki_applet = &(applet_private->u.pki_data);
|
||||
|
||||
switch (apdu->a_ins) {
|
||||
case CAC_UPDATE_BUFFER:
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
case CAC_GET_CERTIFICATE:
|
||||
if ((apdu->a_p2 != 0) || (apdu->a_p1 != 0)) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
||||
break;
|
||||
}
|
||||
assert(pki_applet->cert != NULL);
|
||||
size = apdu->a_Le;
|
||||
if (pki_applet->cert_buffer == NULL) {
|
||||
pki_applet->cert_buffer = pki_applet->cert;
|
||||
pki_applet->cert_buffer_len = pki_applet->cert_len;
|
||||
}
|
||||
size = MIN(size, pki_applet->cert_buffer_len);
|
||||
next = MIN(255, pki_applet->cert_buffer_len - size);
|
||||
*response = vcard_response_new_bytes(
|
||||
card, pki_applet->cert_buffer, size,
|
||||
apdu->a_Le, next ?
|
||||
VCARD7816_SW1_WARNING_CHANGE :
|
||||
VCARD7816_SW1_SUCCESS,
|
||||
next);
|
||||
pki_applet->cert_buffer += size;
|
||||
pki_applet->cert_buffer_len -= size;
|
||||
if ((*response == NULL) || (next == 0)) {
|
||||
pki_applet->cert_buffer = NULL;
|
||||
}
|
||||
if (*response == NULL) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
|
||||
}
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
case CAC_SIGN_DECRYPT:
|
||||
if (apdu->a_p2 != 0) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
||||
break;
|
||||
}
|
||||
size = apdu->a_Lc;
|
||||
|
||||
sign_buffer = g_realloc(pki_applet->sign_buffer,
|
||||
pki_applet->sign_buffer_len + size);
|
||||
memcpy(sign_buffer+pki_applet->sign_buffer_len, apdu->a_body, size);
|
||||
size += pki_applet->sign_buffer_len;
|
||||
switch (apdu->a_p1) {
|
||||
case 0x80:
|
||||
/* p1 == 0x80 means we haven't yet sent the whole buffer, wait for
|
||||
* the rest */
|
||||
pki_applet->sign_buffer = sign_buffer;
|
||||
pki_applet->sign_buffer_len = size;
|
||||
*response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
|
||||
retain_sign_buffer = TRUE;
|
||||
break;
|
||||
case 0x00:
|
||||
/* we now have the whole buffer, do the operation, result will be
|
||||
* in the sign_buffer */
|
||||
status = vcard_emul_rsa_op(card, pki_applet->key,
|
||||
sign_buffer, size);
|
||||
if (status != VCARD7816_STATUS_SUCCESS) {
|
||||
*response = vcard_make_response(status);
|
||||
break;
|
||||
}
|
||||
*response = vcard_response_new(card, sign_buffer, size, apdu->a_Le,
|
||||
VCARD7816_STATUS_SUCCESS);
|
||||
if (*response == NULL) {
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
||||
break;
|
||||
}
|
||||
if (!retain_sign_buffer) {
|
||||
g_free(sign_buffer);
|
||||
pki_applet->sign_buffer = NULL;
|
||||
pki_applet->sign_buffer_len = 0;
|
||||
}
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
case CAC_READ_BUFFER:
|
||||
/* new CAC call, go ahead and use the old version for now */
|
||||
/* TODO: implement */
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
default:
|
||||
ret = cac_common_process_apdu(card, apdu, response);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static VCardStatus
|
||||
cac_applet_id_process_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response)
|
||||
{
|
||||
VCardStatus ret = VCARD_FAIL;
|
||||
|
||||
switch (apdu->a_ins) {
|
||||
case CAC_UPDATE_BUFFER:
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
case CAC_READ_BUFFER:
|
||||
/* new CAC call, go ahead and use the old version for now */
|
||||
/* TODO: implement */
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
default:
|
||||
ret = cac_common_process_apdu(card, apdu, response);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* TODO: if we ever want to support general CAC middleware, we will need to
|
||||
* implement the various containers.
|
||||
*/
|
||||
static VCardStatus
|
||||
cac_applet_container_process_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response)
|
||||
{
|
||||
VCardStatus ret = VCARD_FAIL;
|
||||
|
||||
switch (apdu->a_ins) {
|
||||
case CAC_READ_BUFFER:
|
||||
case CAC_UPDATE_BUFFER:
|
||||
*response = vcard_make_response(
|
||||
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
||||
ret = VCARD_DONE;
|
||||
break;
|
||||
default:
|
||||
ret = cac_common_process_apdu(card, apdu, response);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* utilities for creating and destroying the private applet data
|
||||
*/
|
||||
static void
|
||||
cac_delete_pki_applet_private(VCardAppletPrivate *applet_private)
|
||||
{
|
||||
CACPKIAppletData *pki_applet_data;
|
||||
|
||||
if (applet_private == NULL) {
|
||||
return;
|
||||
}
|
||||
pki_applet_data = &(applet_private->u.pki_data);
|
||||
g_free(pki_applet_data->cert);
|
||||
g_free(pki_applet_data->sign_buffer);
|
||||
if (pki_applet_data->key != NULL) {
|
||||
vcard_emul_delete_key(pki_applet_data->key);
|
||||
}
|
||||
g_free(applet_private);
|
||||
}
|
||||
|
||||
static VCardAppletPrivate *
|
||||
cac_new_pki_applet_private(const unsigned char *cert,
|
||||
int cert_len, VCardKey *key)
|
||||
{
|
||||
CACPKIAppletData *pki_applet_data;
|
||||
VCardAppletPrivate *applet_private;
|
||||
|
||||
applet_private = g_new0(VCardAppletPrivate, 1);
|
||||
pki_applet_data = &(applet_private->u.pki_data);
|
||||
pki_applet_data->cert = (unsigned char *)g_malloc(cert_len+1);
|
||||
/*
|
||||
* if we want to support compression, then we simply change the 0 to a 1
|
||||
* and compress the cert data with libz
|
||||
*/
|
||||
pki_applet_data->cert[0] = 0; /* not compressed */
|
||||
memcpy(&pki_applet_data->cert[1], cert, cert_len);
|
||||
pki_applet_data->cert_len = cert_len+1;
|
||||
|
||||
pki_applet_data->key = key;
|
||||
return applet_private;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* create a new cac applet which links to a given cert
|
||||
*/
|
||||
static VCardApplet *
|
||||
cac_new_pki_applet(int i, const unsigned char *cert,
|
||||
int cert_len, VCardKey *key)
|
||||
{
|
||||
VCardAppletPrivate *applet_private;
|
||||
VCardApplet *applet;
|
||||
unsigned char pki_aid[] = { 0xa0, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00 };
|
||||
int pki_aid_len = sizeof(pki_aid);
|
||||
|
||||
pki_aid[pki_aid_len-1] = i;
|
||||
|
||||
applet_private = cac_new_pki_applet_private(cert, cert_len, key);
|
||||
if (applet_private == NULL) {
|
||||
goto failure;
|
||||
}
|
||||
applet = vcard_new_applet(cac_applet_pki_process_apdu, cac_applet_pki_reset,
|
||||
pki_aid, pki_aid_len);
|
||||
if (applet == NULL) {
|
||||
goto failure;
|
||||
}
|
||||
vcard_set_applet_private(applet, applet_private,
|
||||
cac_delete_pki_applet_private);
|
||||
applet_private = NULL;
|
||||
|
||||
return applet;
|
||||
|
||||
failure:
|
||||
if (applet_private != NULL) {
|
||||
cac_delete_pki_applet_private(applet_private);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static unsigned char cac_default_container_aid[] = {
|
||||
0xa0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00 };
|
||||
static unsigned char cac_id_aid[] = {
|
||||
0xa0, 0x00, 0x00, 0x00, 0x79, 0x03, 0x00 };
|
||||
/*
|
||||
* Initialize the cac card. This is the only public function in this file. All
|
||||
* the rest are connected through function pointers.
|
||||
*/
|
||||
VCardStatus
|
||||
cac_card_init(VReader *reader, VCard *card,
|
||||
const char *params,
|
||||
unsigned char * const *cert,
|
||||
int cert_len[],
|
||||
VCardKey *key[] /* adopt the keys*/,
|
||||
int cert_count)
|
||||
{
|
||||
int i;
|
||||
VCardApplet *applet;
|
||||
|
||||
/* CAC Cards are VM Cards */
|
||||
vcard_set_type(card, VCARD_VM);
|
||||
|
||||
/* create one PKI applet for each cert */
|
||||
for (i = 0; i < cert_count; i++) {
|
||||
applet = cac_new_pki_applet(i, cert[i], cert_len[i], key[i]);
|
||||
if (applet == NULL) {
|
||||
goto failure;
|
||||
}
|
||||
vcard_add_applet(card, applet);
|
||||
}
|
||||
|
||||
/* create a default blank container applet */
|
||||
applet = vcard_new_applet(cac_applet_container_process_apdu,
|
||||
NULL, cac_default_container_aid,
|
||||
sizeof(cac_default_container_aid));
|
||||
if (applet == NULL) {
|
||||
goto failure;
|
||||
}
|
||||
vcard_add_applet(card, applet);
|
||||
|
||||
/* create a default blank container applet */
|
||||
applet = vcard_new_applet(cac_applet_id_process_apdu,
|
||||
NULL, cac_id_aid,
|
||||
sizeof(cac_id_aid));
|
||||
if (applet == NULL) {
|
||||
goto failure;
|
||||
}
|
||||
vcard_add_applet(card, applet);
|
||||
return VCARD_DONE;
|
||||
|
||||
failure:
|
||||
return VCARD_FAIL;
|
||||
}
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* defines the entry point for the cac card. Only used by cac.c anc
|
||||
* vcard_emul_type.c
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
#ifndef CAC_H
|
||||
#define CAC_H 1
|
||||
#include "vcard.h"
|
||||
#include "vreader.h"
|
||||
|
||||
#define CAC_GET_PROPERTIES 0x56
|
||||
#define CAC_GET_ACR 0x4c
|
||||
#define CAC_READ_BUFFER 0x52
|
||||
#define CAC_UPDATE_BUFFER 0x58
|
||||
#define CAC_SIGN_DECRYPT 0x42
|
||||
#define CAC_GET_CERTIFICATE 0x36
|
||||
|
||||
/*
|
||||
* Initialize the cac card. This is the only public function in this file. All
|
||||
* the rest are connected through function pointers.
|
||||
*/
|
||||
VCardStatus cac_card_init(VReader *reader, VCard *card, const char *params,
|
||||
unsigned char * const *cert, int cert_len[],
|
||||
VCardKey *key[] /* adopt the keys*/,
|
||||
int cert_count);
|
||||
|
||||
/* not yet implemented */
|
||||
VCardStatus cac_is_cac_card(VReader *reader);
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,62 +0,0 @@
|
||||
/*
|
||||
* Implement the 7816 portion of the card spec
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
#ifndef CARD_7816_H
|
||||
#define CARD_7816_H 1
|
||||
|
||||
#include "card_7816t.h"
|
||||
#include "vcardt.h"
|
||||
|
||||
/*
|
||||
* constructors for VCardResponse's
|
||||
*/
|
||||
/* response from a return buffer and a status */
|
||||
VCardResponse *vcard_response_new(VCard *card, unsigned char *buf, int len,
|
||||
int Le, vcard_7816_status_t status);
|
||||
/* response from a return buffer and status bytes */
|
||||
VCardResponse *vcard_response_new_bytes(VCard *card, unsigned char *buf,
|
||||
int len, int Le,
|
||||
unsigned char sw1, unsigned char sw2);
|
||||
/* response from just status bytes */
|
||||
VCardResponse *vcard_response_new_status_bytes(unsigned char sw1,
|
||||
unsigned char sw2);
|
||||
/* response from just status: NOTE this cannot fail, it will always return a
|
||||
* valid response, if it can't allocate memory, the response will be
|
||||
* VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE */
|
||||
VCardResponse *vcard_make_response(vcard_7816_status_t status);
|
||||
|
||||
/* create a raw response (status has already been encoded */
|
||||
VCardResponse *vcard_response_new_data(unsigned char *buf, int len);
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* destructor for VCardResponse.
|
||||
* Can be called with a NULL response
|
||||
*/
|
||||
void vcard_response_delete(VCardResponse *response);
|
||||
|
||||
/*
|
||||
* constructor for VCardAPDU
|
||||
*/
|
||||
VCardAPDU *vcard_apdu_new(unsigned char *raw_apdu, int len,
|
||||
unsigned short *status);
|
||||
|
||||
/*
|
||||
* destructor for VCardAPDU
|
||||
* Can be called with a NULL apdu
|
||||
*/
|
||||
void vcard_apdu_delete(VCardAPDU *apdu);
|
||||
|
||||
/*
|
||||
* APDU processing starts here. This routes the card processing stuff to the
|
||||
* right location. Always returns a valid response.
|
||||
*/
|
||||
VCardStatus vcard_process_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response);
|
||||
|
||||
#endif
|
||||
@@ -1,165 +0,0 @@
|
||||
/*
|
||||
* Implement the 7816 portion of the card spec
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
#ifndef CARD_7816T_H
|
||||
#define CARD_7816T_H 1
|
||||
|
||||
typedef unsigned short vcard_7816_status_t;
|
||||
|
||||
struct VCardResponseStruct {
|
||||
unsigned char *b_data;
|
||||
vcard_7816_status_t b_status;
|
||||
unsigned char b_sw1;
|
||||
unsigned char b_sw2;
|
||||
int b_len;
|
||||
int b_total_len;
|
||||
enum VCardResponseBufferType {
|
||||
VCARD_MALLOC,
|
||||
VCARD_MALLOC_DATA,
|
||||
VCARD_MALLOC_STRUCT,
|
||||
VCARD_STATIC
|
||||
} b_type;
|
||||
};
|
||||
|
||||
#define VCARD_RESPONSE_NEW_STATIC_STATUS(stat) \
|
||||
static const VCardResponse VCardResponse##stat = \
|
||||
{(unsigned char *)&VCardResponse##stat.b_sw1, (stat), ((stat) >> 8), \
|
||||
((stat) & 0xff), 0, 2, VCARD_STATIC};
|
||||
|
||||
#define VCARD_RESPONSE_NEW_STATIC_STATUS_BYTES(sw1, sw2) \
|
||||
static const VCardResponse VCARDResponse##sw1 = \
|
||||
{(unsigned char *)&VCardResponse##name.b_sw1, ((sw1) << 8 | (sw2)), \
|
||||
(sw1), (sw2), 0, 2, VCARD_STATIC};
|
||||
|
||||
/* cast away the const, callers need may need to 'free' the
|
||||
* result, and const implies that they don't */
|
||||
#define VCARD_RESPONSE_GET_STATIC(name) \
|
||||
((VCardResponse *)(&VCardResponse##name))
|
||||
|
||||
typedef enum {
|
||||
VCARD_7816_ISO,
|
||||
VCARD_7816_RFU,
|
||||
VCARD_7816_PTS,
|
||||
VCARD_7816_PROPRIETARY
|
||||
} VCardAPDUType;
|
||||
|
||||
|
||||
/*
|
||||
* 7816 header. All APDU's have this header.
|
||||
* They must be laid out in this order.
|
||||
*/
|
||||
struct VCardAPDUHeader {
|
||||
unsigned char ah_cla;
|
||||
unsigned char ah_ins;
|
||||
unsigned char ah_p1;
|
||||
unsigned char ah_p2;
|
||||
unsigned char ah_Le;
|
||||
unsigned char ah_body[1]; /* indefinite length */
|
||||
};
|
||||
|
||||
/*
|
||||
* 7816 APDU structure. The raw bytes are stored in the union and can be
|
||||
* accessed directly through u.data (which is aliased as a_data).
|
||||
*
|
||||
* Names of the fields match the 7816 documentation.
|
||||
*/
|
||||
struct VCardAPDUStruct {
|
||||
int a_len; /* length of the whole buffer, including header */
|
||||
int a_Lc; /* 7816 Lc (parameter length) value */
|
||||
int a_Le; /* 7816 Le (expected result length) value */
|
||||
unsigned char *a_body; /* pointer to the parameter */
|
||||
int a_channel; /* decoded channel */
|
||||
int a_secure_messaging; /* decoded secure messaging type */
|
||||
int a_type; /* decoded type from cla (top nibble of class) */
|
||||
VCardAPDUType a_gen_type; /* generic type (7816, PROPRIETARY, RFU, etc) */
|
||||
union {
|
||||
struct VCardAPDUHeader *header;
|
||||
unsigned char *data;
|
||||
} u;
|
||||
/* give the subfields a unified look */
|
||||
#define a_header u.header
|
||||
#define a_data u.data
|
||||
#define a_cla a_header->ah_cla /* class */
|
||||
#define a_ins a_header->ah_ins /* instruction */
|
||||
#define a_p1 a_header->ah_p1 /* parameter 1 */
|
||||
#define a_p2 a_header->ah_p2 /* parameter 2 */
|
||||
};
|
||||
|
||||
/* 7816 status codes */
|
||||
#define VCARD7816_STATUS_SUCCESS 0x9000
|
||||
#define VCARD7816_STATUS_WARNING 0x6200
|
||||
#define VCARD7816_STATUS_WARNING_RET_CORUPT 0x6281
|
||||
#define VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE 0x6282
|
||||
#define VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED 0x6283
|
||||
#define VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID 0x6284
|
||||
#define VCARD7816_STATUS_WARNING_CHANGE 0x6300
|
||||
#define VCARD7816_STATUS_WARNING_FILE_FILLED 0x6381
|
||||
#define VCARD7816_STATUS_EXC_ERROR 0x6400
|
||||
#define VCARD7816_STATUS_EXC_ERROR_CHANGE 0x6500
|
||||
#define VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE 0x6581
|
||||
#define VCARD7816_STATUS_ERROR_WRONG_LENGTH 0x6700
|
||||
#define VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED 0x6800
|
||||
#define VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED 0x6881
|
||||
#define VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED 0x6882
|
||||
#define VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED 0x6900
|
||||
#define VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE 0x6981
|
||||
#define VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED 0x6982
|
||||
#define VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED 0x6983
|
||||
#define VCARD7816_STATUS_ERROR_DATA_INVALID 0x6984
|
||||
#define VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED 0x6985
|
||||
#define VCARD7816_STATUS_ERROR_DATA_NO_EF 0x6986
|
||||
#define VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING 0x6987
|
||||
#define VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT 0x6988
|
||||
#define VCARD7816_STATUS_ERROR_WRONG_PARAMETERS 0x6a00
|
||||
#define VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA 0x6a80
|
||||
#define VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED 0x6a81
|
||||
#define VCARD7816_STATUS_ERROR_FILE_NOT_FOUND 0x6a82
|
||||
#define VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND 0x6a83
|
||||
#define VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE 0x6a84
|
||||
#define VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT 0x6a85
|
||||
#define VCARD7816_STATUS_ERROR_P1_P2_INCORRECT 0x6a86
|
||||
#define VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT 0x6a87
|
||||
#define VCARD7816_STATUS_ERROR_DATA_NOT_FOUND 0x6a88
|
||||
#define VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2 0x6b00
|
||||
#define VCARD7816_STATUS_ERROR_INS_CODE_INVALID 0x6d00
|
||||
#define VCARD7816_STATUS_ERROR_CLA_INVALID 0x6e00
|
||||
#define VCARD7816_STATUS_ERROR_GENERAL 0x6f00
|
||||
/* 7816 sw1 codes */
|
||||
#define VCARD7816_SW1_SUCCESS 0x90
|
||||
#define VCARD7816_SW1_RESPONSE_BYTES 0x61
|
||||
#define VCARD7816_SW1_WARNING 0x62
|
||||
#define VCARD7816_SW1_WARNING_CHANGE 0x63
|
||||
#define VCARD7816_SW1_EXC_ERROR 0x64
|
||||
#define VCARD7816_SW1_EXC_ERROR_CHANGE 0x65
|
||||
#define VCARD7816_SW1_ERROR_WRONG_LENGTH 0x67
|
||||
#define VCARD7816_SW1_CLA_ERROR 0x68
|
||||
#define VCARD7816_SW1_COMMAND_ERROR 0x69
|
||||
#define VCARD7816_SW1_P1_P2_ERROR 0x6a
|
||||
#define VCARD7816_SW1_LE_ERROR 0x6c
|
||||
#define VCARD7816_SW1_INS_ERROR 0x6d
|
||||
#define VCARD7816_SW1_CLA_NOT_SUPPORTED 0x6e
|
||||
|
||||
/* 7816 Instructions */
|
||||
#define VCARD7816_INS_MANAGE_CHANNEL 0x70
|
||||
#define VCARD7816_INS_EXTERNAL_AUTHENTICATE 0x82
|
||||
#define VCARD7816_INS_GET_CHALLENGE 0x84
|
||||
#define VCARD7816_INS_INTERNAL_AUTHENTICATE 0x88
|
||||
#define VCARD7816_INS_ERASE_BINARY 0x0e
|
||||
#define VCARD7816_INS_READ_BINARY 0xb0
|
||||
#define VCARD7816_INS_WRITE_BINARY 0xd0
|
||||
#define VCARD7816_INS_UPDATE_BINARY 0xd6
|
||||
#define VCARD7816_INS_READ_RECORD 0xb2
|
||||
#define VCARD7816_INS_WRITE_RECORD 0xd2
|
||||
#define VCARD7816_INS_UPDATE_RECORD 0xdc
|
||||
#define VCARD7816_INS_APPEND_RECORD 0xe2
|
||||
#define VCARD7816_INS_ENVELOPE 0xc2
|
||||
#define VCARD7816_INS_PUT_DATA 0xda
|
||||
#define VCARD7816_INS_GET_DATA 0xca
|
||||
#define VCARD7816_INS_SELECT_FILE 0xa4
|
||||
#define VCARD7816_INS_VERIFY 0x20
|
||||
#define VCARD7816_INS_GET_RESPONSE 0xc0
|
||||
|
||||
#endif
|
||||
@@ -1,103 +0,0 @@
|
||||
/*
|
||||
* event queue implementation.
|
||||
*
|
||||
* This code is licensed under the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "glib-compat.h"
|
||||
|
||||
#include "vcard.h"
|
||||
#include "vreader.h"
|
||||
#include "vevent.h"
|
||||
|
||||
VEvent *
|
||||
vevent_new(VEventType type, VReader *reader, VCard *card)
|
||||
{
|
||||
VEvent *new_vevent;
|
||||
|
||||
new_vevent = g_new(VEvent, 1);
|
||||
new_vevent->next = NULL;
|
||||
new_vevent->type = type;
|
||||
new_vevent->reader = vreader_reference(reader);
|
||||
new_vevent->card = vcard_reference(card);
|
||||
|
||||
return new_vevent;
|
||||
}
|
||||
|
||||
void
|
||||
vevent_delete(VEvent *vevent)
|
||||
{
|
||||
if (vevent == NULL) {
|
||||
return;
|
||||
}
|
||||
vreader_free(vevent->reader);
|
||||
vcard_free(vevent->card);
|
||||
g_free(vevent);
|
||||
}
|
||||
|
||||
/*
|
||||
* VEvent queue management
|
||||
*/
|
||||
|
||||
static VEvent *vevent_queue_head;
|
||||
static VEvent *vevent_queue_tail;
|
||||
static CompatGMutex vevent_queue_lock;
|
||||
static CompatGCond vevent_queue_condition;
|
||||
|
||||
void vevent_queue_init(void)
|
||||
{
|
||||
vevent_queue_head = vevent_queue_tail = NULL;
|
||||
}
|
||||
|
||||
void
|
||||
vevent_queue_vevent(VEvent *vevent)
|
||||
{
|
||||
vevent->next = NULL;
|
||||
g_mutex_lock(&vevent_queue_lock);
|
||||
if (vevent_queue_head) {
|
||||
assert(vevent_queue_tail);
|
||||
vevent_queue_tail->next = vevent;
|
||||
} else {
|
||||
vevent_queue_head = vevent;
|
||||
}
|
||||
vevent_queue_tail = vevent;
|
||||
g_cond_signal(&vevent_queue_condition);
|
||||
g_mutex_unlock(&vevent_queue_lock);
|
||||
}
|
||||
|
||||
/* must have lock */
|
||||
static VEvent *
|
||||
vevent_dequeue_vevent(void)
|
||||
{
|
||||
VEvent *vevent = NULL;
|
||||
if (vevent_queue_head) {
|
||||
vevent = vevent_queue_head;
|
||||
vevent_queue_head = vevent->next;
|
||||
vevent->next = NULL;
|
||||
}
|
||||
return vevent;
|
||||
}
|
||||
|
||||
VEvent *vevent_wait_next_vevent(void)
|
||||
{
|
||||
VEvent *vevent;
|
||||
|
||||
g_mutex_lock(&vevent_queue_lock);
|
||||
while ((vevent = vevent_dequeue_vevent()) == NULL) {
|
||||
g_cond_wait(&vevent_queue_condition, &vevent_queue_lock);
|
||||
}
|
||||
g_mutex_unlock(&vevent_queue_lock);
|
||||
return vevent;
|
||||
}
|
||||
|
||||
VEvent *vevent_get_next_vevent(void)
|
||||
{
|
||||
VEvent *vevent;
|
||||
|
||||
g_mutex_lock(&vevent_queue_lock);
|
||||
vevent = vevent_dequeue_vevent();
|
||||
g_mutex_unlock(&vevent_queue_lock);
|
||||
return vevent;
|
||||
}
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef EVENTT_H
|
||||
#define EVENTT_H 1
|
||||
#include "vreadert.h"
|
||||
#include "vcardt.h"
|
||||
|
||||
typedef struct VEventStruct VEvent;
|
||||
|
||||
typedef enum {
|
||||
VEVENT_READER_INSERT,
|
||||
VEVENT_READER_REMOVE,
|
||||
VEVENT_CARD_INSERT,
|
||||
VEVENT_CARD_REMOVE,
|
||||
VEVENT_LAST,
|
||||
} VEventType;
|
||||
|
||||
struct VEventStruct {
|
||||
VEvent *next;
|
||||
VEventType type;
|
||||
VReader *reader;
|
||||
VCard *card;
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
prefix=@PREFIX@
|
||||
exec_prefix=${prefix}
|
||||
libdir=@LIBDIR@
|
||||
includedir=@INCLUDEDIR@
|
||||
|
||||
Name: cacard
|
||||
Description: CA Card library
|
||||
Version: @VERSION@
|
||||
|
||||
Requires.private: nss glib-2.0
|
||||
Libs: -L${libdir} -lcacard
|
||||
Libs.private:
|
||||
Cflags: -I${includedir}
|
||||
@@ -1,77 +0,0 @@
|
||||
cac_card_init
|
||||
cac_is_cac_card
|
||||
vcard_add_applet
|
||||
vcard_apdu_delete
|
||||
vcard_apdu_new
|
||||
vcard_applet_get_aid
|
||||
vcard_buffer_response_delete
|
||||
vcard_buffer_response_new
|
||||
vcard_delete_applet
|
||||
vcard_emul_delete_key
|
||||
vcard_emul_force_card_insert
|
||||
vcard_emul_force_card_remove
|
||||
vcard_emul_get_atr
|
||||
vcard_emul_get_login_count
|
||||
vcard_emul_init
|
||||
vcard_emul_login
|
||||
vcard_emul_options
|
||||
vcard_emul_replay_insertion_events
|
||||
vcard_emul_reset
|
||||
vcard_emul_rsa_op
|
||||
vcard_emul_type_from_string
|
||||
vcard_emul_type_select
|
||||
vcard_emul_usage
|
||||
vcard_find_applet
|
||||
vcard_free
|
||||
vcard_get_atr
|
||||
vcard_get_buffer_response
|
||||
vcard_get_current_applet_private
|
||||
vcard_get_private
|
||||
vcard_get_type
|
||||
vcard_init
|
||||
vcard_make_response
|
||||
vcard_new
|
||||
vcard_new_applet
|
||||
vcard_process_apdu
|
||||
vcard_process_applet_apdu
|
||||
vcard_reference
|
||||
vcard_reset
|
||||
vcard_response_delete
|
||||
vcard_response_new
|
||||
vcard_response_new_bytes
|
||||
vcard_response_new_data
|
||||
vcard_response_new_status_bytes
|
||||
vcard_select_applet
|
||||
vcard_set_applet_private
|
||||
vcard_set_atr_func
|
||||
vcard_set_buffer_response
|
||||
vcard_set_type
|
||||
vevent_delete
|
||||
vevent_get_next_vevent
|
||||
vevent_new
|
||||
vevent_queue_init
|
||||
vevent_queue_vevent
|
||||
vevent_wait_next_vevent
|
||||
vreader_add_reader
|
||||
vreader_card_is_present
|
||||
vreader_free
|
||||
vreader_get_id
|
||||
vreader_get_name
|
||||
vreader_get_private
|
||||
vreader_get_reader_by_id
|
||||
vreader_get_reader_by_name
|
||||
vreader_get_reader_list
|
||||
vreader_init
|
||||
vreader_insert_card
|
||||
vreader_list_delete
|
||||
vreader_list_get_first
|
||||
vreader_list_get_next
|
||||
vreader_list_get_reader
|
||||
vreader_new
|
||||
vreader_power_off
|
||||
vreader_power_on
|
||||
vreader_queue_card_event
|
||||
vreader_reference
|
||||
vreader_remove_reader
|
||||
vreader_set_id
|
||||
vreader_xfr_bytes
|
||||
@@ -1,22 +0,0 @@
|
||||
/*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "vcard.h"
|
||||
|
||||
VCardStatus cac_card_init(const char *flags, VCard *card,
|
||||
const unsigned char *cert[],
|
||||
int cert_len[], VCardKey *key[] /* adopt the keys*/,
|
||||
int cert_count);
|
||||
/*
|
||||
* this will crash... just test the linkage right now
|
||||
*/
|
||||
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
VCard *card; /* no constructor yet */
|
||||
cac_card_init("", card, NULL, 0, NULL, 0);
|
||||
}
|
||||
|
||||
@@ -1,325 +0,0 @@
|
||||
/*
|
||||
* implement the Java card standard.
|
||||
*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "glib-compat.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "vcard.h"
|
||||
#include "vcard_emul.h"
|
||||
#include "card_7816t.h"
|
||||
|
||||
struct VCardAppletStruct {
|
||||
VCardApplet *next;
|
||||
VCardProcessAPDU process_apdu;
|
||||
VCardResetApplet reset_applet;
|
||||
unsigned char *aid;
|
||||
int aid_len;
|
||||
void *applet_private;
|
||||
VCardAppletPrivateFree applet_private_free;
|
||||
};
|
||||
|
||||
struct VCardStruct {
|
||||
int reference_count;
|
||||
VCardApplet *applet_list;
|
||||
VCardApplet *current_applet[MAX_CHANNEL];
|
||||
VCardBufferResponse *vcard_buffer_response;
|
||||
VCardType type;
|
||||
VCardEmul *vcard_private;
|
||||
VCardEmulFree vcard_private_free;
|
||||
VCardGetAtr vcard_get_atr;
|
||||
};
|
||||
|
||||
VCardBufferResponse *
|
||||
vcard_buffer_response_new(unsigned char *buffer, int size)
|
||||
{
|
||||
VCardBufferResponse *new_buffer;
|
||||
|
||||
new_buffer = g_new(VCardBufferResponse, 1);
|
||||
new_buffer->buffer = (unsigned char *)g_memdup(buffer, size);
|
||||
new_buffer->buffer_len = size;
|
||||
new_buffer->current = new_buffer->buffer;
|
||||
new_buffer->len = size;
|
||||
return new_buffer;
|
||||
}
|
||||
|
||||
void
|
||||
vcard_buffer_response_delete(VCardBufferResponse *buffer_response)
|
||||
{
|
||||
if (buffer_response == NULL) {
|
||||
return;
|
||||
}
|
||||
g_free(buffer_response->buffer);
|
||||
g_free(buffer_response);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* clean up state after a reset
|
||||
*/
|
||||
void
|
||||
vcard_reset(VCard *card, VCardPower power)
|
||||
{
|
||||
int i;
|
||||
VCardApplet *applet = NULL;
|
||||
|
||||
if (card->type == VCARD_DIRECT) {
|
||||
/* select the last applet */
|
||||
VCardApplet *current_applet = NULL;
|
||||
for (current_applet = card->applet_list; current_applet;
|
||||
current_applet = current_applet->next) {
|
||||
applet = current_applet;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < MAX_CHANNEL; i++) {
|
||||
card->current_applet[i] = applet;
|
||||
}
|
||||
if (card->vcard_buffer_response) {
|
||||
vcard_buffer_response_delete(card->vcard_buffer_response);
|
||||
card->vcard_buffer_response = NULL;
|
||||
}
|
||||
vcard_emul_reset(card, power);
|
||||
if (applet) {
|
||||
applet->reset_applet(card, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* applet utilities */
|
||||
|
||||
/*
|
||||
* applet utilities
|
||||
*/
|
||||
/* constructor */
|
||||
VCardApplet *
|
||||
vcard_new_applet(VCardProcessAPDU applet_process_function,
|
||||
VCardResetApplet applet_reset_function,
|
||||
unsigned char *aid, int aid_len)
|
||||
{
|
||||
VCardApplet *applet;
|
||||
|
||||
applet = g_new0(VCardApplet, 1);
|
||||
applet->process_apdu = applet_process_function;
|
||||
applet->reset_applet = applet_reset_function;
|
||||
|
||||
applet->aid = g_memdup(aid, aid_len);
|
||||
applet->aid_len = aid_len;
|
||||
return applet;
|
||||
}
|
||||
|
||||
/* destructor */
|
||||
void
|
||||
vcard_delete_applet(VCardApplet *applet)
|
||||
{
|
||||
if (applet == NULL) {
|
||||
return;
|
||||
}
|
||||
if (applet->applet_private_free) {
|
||||
applet->applet_private_free(applet->applet_private);
|
||||
}
|
||||
g_free(applet->aid);
|
||||
g_free(applet);
|
||||
}
|
||||
|
||||
/* accessor */
|
||||
void
|
||||
vcard_set_applet_private(VCardApplet *applet, VCardAppletPrivate *private,
|
||||
VCardAppletPrivateFree private_free)
|
||||
{
|
||||
if (applet->applet_private_free) {
|
||||
applet->applet_private_free(applet->applet_private);
|
||||
}
|
||||
applet->applet_private = private;
|
||||
applet->applet_private_free = private_free;
|
||||
}
|
||||
|
||||
VCard *
|
||||
vcard_new(VCardEmul *private, VCardEmulFree private_free)
|
||||
{
|
||||
VCard *new_card;
|
||||
|
||||
new_card = g_new0(VCard, 1);
|
||||
new_card->type = VCARD_VM;
|
||||
new_card->vcard_private = private;
|
||||
new_card->vcard_private_free = private_free;
|
||||
new_card->reference_count = 1;
|
||||
return new_card;
|
||||
}
|
||||
|
||||
VCard *
|
||||
vcard_reference(VCard *vcard)
|
||||
{
|
||||
if (vcard == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
vcard->reference_count++;
|
||||
return vcard;
|
||||
}
|
||||
|
||||
void
|
||||
vcard_free(VCard *vcard)
|
||||
{
|
||||
VCardApplet *current_applet;
|
||||
VCardApplet *next_applet;
|
||||
|
||||
if (vcard == NULL) {
|
||||
return;
|
||||
}
|
||||
vcard->reference_count--;
|
||||
if (vcard->reference_count != 0) {
|
||||
return;
|
||||
}
|
||||
if (vcard->vcard_private_free) {
|
||||
(*vcard->vcard_private_free)(vcard->vcard_private);
|
||||
}
|
||||
for (current_applet = vcard->applet_list; current_applet;
|
||||
current_applet = next_applet) {
|
||||
next_applet = current_applet->next;
|
||||
vcard_delete_applet(current_applet);
|
||||
}
|
||||
vcard_buffer_response_delete(vcard->vcard_buffer_response);
|
||||
g_free(vcard);
|
||||
}
|
||||
|
||||
void
|
||||
vcard_get_atr(VCard *vcard, unsigned char *atr, int *atr_len)
|
||||
{
|
||||
if (vcard->vcard_get_atr) {
|
||||
(*vcard->vcard_get_atr)(vcard, atr, atr_len);
|
||||
return;
|
||||
}
|
||||
vcard_emul_get_atr(vcard, atr, atr_len);
|
||||
}
|
||||
|
||||
void
|
||||
vcard_set_atr_func(VCard *card, VCardGetAtr vcard_get_atr)
|
||||
{
|
||||
card->vcard_get_atr = vcard_get_atr;
|
||||
}
|
||||
|
||||
|
||||
VCardStatus
|
||||
vcard_add_applet(VCard *card, VCardApplet *applet)
|
||||
{
|
||||
applet->next = card->applet_list;
|
||||
card->applet_list = applet;
|
||||
/* if our card-type is direct, always call the applet */
|
||||
if (card->type == VCARD_DIRECT) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAX_CHANNEL; i++) {
|
||||
card->current_applet[i] = applet;
|
||||
}
|
||||
}
|
||||
return VCARD_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
* manage applets
|
||||
*/
|
||||
VCardApplet *
|
||||
vcard_find_applet(VCard *card, unsigned char *aid, int aid_len)
|
||||
{
|
||||
VCardApplet *current_applet;
|
||||
|
||||
for (current_applet = card->applet_list; current_applet;
|
||||
current_applet = current_applet->next) {
|
||||
if (current_applet->aid_len != aid_len) {
|
||||
continue;
|
||||
}
|
||||
if (memcmp(current_applet->aid, aid, aid_len) == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return current_applet;
|
||||
}
|
||||
|
||||
unsigned char *
|
||||
vcard_applet_get_aid(VCardApplet *applet, int *aid_len)
|
||||
{
|
||||
if (applet == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
*aid_len = applet->aid_len;
|
||||
return applet->aid;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
vcard_select_applet(VCard *card, int channel, VCardApplet *applet)
|
||||
{
|
||||
assert(channel < MAX_CHANNEL);
|
||||
|
||||
/* If using an emulated card, make sure to log out of any already logged in
|
||||
* session. */
|
||||
vcard_emul_logout(card);
|
||||
|
||||
card->current_applet[channel] = applet;
|
||||
/* reset the applet */
|
||||
if (applet && applet->reset_applet) {
|
||||
applet->reset_applet(card, channel);
|
||||
}
|
||||
}
|
||||
|
||||
VCardAppletPrivate *
|
||||
vcard_get_current_applet_private(VCard *card, int channel)
|
||||
{
|
||||
VCardApplet *applet = card->current_applet[channel];
|
||||
|
||||
if (applet == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
return applet->applet_private;
|
||||
}
|
||||
|
||||
VCardStatus
|
||||
vcard_process_applet_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response)
|
||||
{
|
||||
if (card->current_applet[apdu->a_channel]) {
|
||||
return card->current_applet[apdu->a_channel]->process_apdu(
|
||||
card, apdu, response);
|
||||
}
|
||||
return VCARD_NEXT;
|
||||
}
|
||||
|
||||
/*
|
||||
* Accessor functions
|
||||
*/
|
||||
/* accessor functions for the response buffer */
|
||||
VCardBufferResponse *
|
||||
vcard_get_buffer_response(VCard *card)
|
||||
{
|
||||
return card->vcard_buffer_response;
|
||||
}
|
||||
|
||||
void
|
||||
vcard_set_buffer_response(VCard *card, VCardBufferResponse *buffer)
|
||||
{
|
||||
card->vcard_buffer_response = buffer;
|
||||
}
|
||||
|
||||
|
||||
/* accessor functions for the type */
|
||||
VCardType
|
||||
vcard_get_type(VCard *card)
|
||||
{
|
||||
return card->type;
|
||||
}
|
||||
|
||||
void
|
||||
vcard_set_type(VCard *card, VCardType type)
|
||||
{
|
||||
card->type = type;
|
||||
}
|
||||
|
||||
/* accessor for private data */
|
||||
VCardEmul *
|
||||
vcard_get_private(VCard *vcard)
|
||||
{
|
||||
return vcard->vcard_private;
|
||||
}
|
||||
|
||||
@@ -1,86 +0,0 @@
|
||||
/*
|
||||
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
||||
* See the COPYING.LIB file in the top-level directory.
|
||||
*/
|
||||
#ifndef VCARD_H
|
||||
#define VCARD_H 1
|
||||
|
||||
#include "vcardt.h"
|
||||
|
||||
/*
|
||||
* response buffer constructors and destructors.
|
||||
*
|
||||
* response buffers are used when we need to return more data than will fit in
|
||||
* a normal APDU response (nominally 254 bytes).
|
||||
*/
|
||||
VCardBufferResponse *vcard_buffer_response_new(unsigned char *buffer, int size);
|
||||
void vcard_buffer_response_delete(VCardBufferResponse *buffer_response);
|
||||
|
||||
|
||||
/*
|
||||
* clean up state on reset
|
||||
*/
|
||||
void vcard_reset(VCard *card, VCardPower power);
|
||||
|
||||
/*
|
||||
* applet utilities
|
||||
*/
|
||||
/*
|
||||
* Constructor for a VCardApplet
|
||||
*/
|
||||
VCardApplet *vcard_new_applet(VCardProcessAPDU applet_process_function,
|
||||
VCardResetApplet applet_reset_function,
|
||||
unsigned char *aid, int aid_len);
|
||||
|
||||
/*
|
||||
* destructor for a VCardApplet
|
||||
* Can be called with a NULL applet
|
||||
*/
|
||||
void vcard_delete_applet(VCardApplet *applet);
|
||||
|
||||
/* accessor - set the card type specific private data */
|
||||
void vcard_set_applet_private(VCardApplet *applet, VCardAppletPrivate *_private,
|
||||
VCardAppletPrivateFree private_free);
|
||||
|
||||
/* set type of vcard */
|
||||
void vcard_set_type(VCard *card, VCardType type);
|
||||
|
||||
/*
|
||||
* utilities interacting with the current applet
|
||||
*/
|
||||
/* add a new applet to a card */
|
||||
VCardStatus vcard_add_applet(VCard *card, VCardApplet *applet);
|
||||
/* find the applet on the card with the given aid */
|
||||
VCardApplet *vcard_find_applet(VCard *card, unsigned char *aid, int aid_len);
|
||||
/* set the following applet to be current on the given channel */
|
||||
void vcard_select_applet(VCard *card, int channel, VCardApplet *applet);
|
||||
/* get the card type specific private data on the given channel */
|
||||
VCardAppletPrivate *vcard_get_current_applet_private(VCard *card, int channel);
|
||||
/* fetch the applet's id */
|
||||
unsigned char *vcard_applet_get_aid(VCardApplet *applet, int *aid_len);
|
||||
|
||||
/* process the apdu for the current selected applet/file */
|
||||
VCardStatus vcard_process_applet_apdu(VCard *card, VCardAPDU *apdu,
|
||||
VCardResponse **response);
|
||||
/*
|
||||
* VCard utilities
|
||||
*/
|
||||
/* constructor */
|
||||
VCard *vcard_new(VCardEmul *_private, VCardEmulFree private_free);
|
||||
/* get a reference */
|
||||
VCard *vcard_reference(VCard *);
|
||||
/* destructor (reference counted) */
|
||||
void vcard_free(VCard *);
|
||||
/* get the atr from the card */
|
||||
void vcard_get_atr(VCard *card, unsigned char *atr, int *atr_len);
|
||||
void vcard_set_atr_func(VCard *card, VCardGetAtr vcard_get_atr);
|
||||
|
||||
/* accessor functions for the response buffer */
|
||||
VCardBufferResponse *vcard_get_buffer_response(VCard *card);
|
||||
void vcard_set_buffer_response(VCard *card, VCardBufferResponse *buffer);
|
||||
/* accessor functions for the type */
|
||||
VCardType vcard_get_type(VCard *card);
|
||||
/* get the private data */
|
||||
VCardEmul *vcard_get_private(VCard *card);
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user