/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* gkm-rpc-dispatch.h - receiver of our PKCS#11 protocol.
Copyright (C) 2008, Stef Walter
The Gnome Keyring Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The Gnome Keyring Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the Gnome Library; see the file COPYING.LIB. If not,
.
Author: Stef Walter
*/
#include "config.h"
#include "gkm-rpc-layer.h"
#include "gkm-rpc-private.h"
#include "pkcs11/pkcs11.h"
#include "pkcs11/pkcs11i.h"
#include "egg/egg-error.h"
#include "egg/egg-unix-credentials.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* Where we dispatch the calls to */
static CK_FUNCTION_LIST_PTR pkcs11_module = NULL;
/* The error returned on protocol failures */
#define PARSE_ERROR CKR_DEVICE_ERROR
#define PREP_ERROR CKR_DEVICE_MEMORY
/* -----------------------------------------------------------------------------
* LOGGING and DEBUGGING
*/
#if DEBUG_OUTPUT
#define debug(x) gkm_rpc_debug x
#else
#define debug(x)
#endif
#define warning(x) gkm_rpc_warn x
#define return_val_if_fail(x, v) \
if (!(x)) { rpc_warn ("'%s' not true at %s", #x, __func__); return v; }
void
gkm_rpc_log (const char *line)
{
g_message ("%s", line);
}
/* -------------------------------------------------------------------------------
* CALL STRUCTURES
*/
typedef struct _ClientInstance {
struct _ClientInstance *next;
CK_G_APPLICATION application;
pid_t pid;
uid_t uid;
int refcount;
} ClientInstance;
typedef struct _CallState {
GkmRpcMessage *req;
GkmRpcMessage *resp;
void *allocated;
ClientInstance *client;
} CallState;
static ClientInstance *clients = NULL;
static pthread_mutex_t clients_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
call_init (CallState *cs, uid_t uid, pid_t pid)
{
ClientInstance *cl;
assert (cs);
cs->req = gkm_rpc_message_new ((EggBufferAllocator)realloc);
cs->resp = gkm_rpc_message_new ((EggBufferAllocator)realloc);
if (!cs->req || !cs->resp) {
gkm_rpc_message_free (cs->req);
gkm_rpc_message_free (cs->resp);
return 0;
}
pthread_mutex_lock (&clients_mutex);
for (cl = clients; cl; cl = cl->next) {
if (cl->uid == uid && cl->pid == pid) {
cl->refcount++;
break;
}
}
if (!cl) {
cl = malloc (sizeof (*cl));
if (!cl) {
pthread_mutex_unlock (&clients_mutex);
return 0;
}
cl->next = clients;
clients = cl;
cl->uid = uid;
cl->pid = pid;
cl->refcount = 1;
memset (&cl->application, 0, sizeof (cl->application));
cl->application.applicationData = cl;
}
pthread_mutex_unlock (&clients_mutex);
cs->client = cl;
cs->allocated = NULL;
return 1;
}
static void*
call_alloc (CallState *cs, size_t length)
{
void **data;
assert (cs);
if (length > 0x7fffffff)
return NULL;
data = malloc (sizeof (void*) + length);
if (!data)
return NULL;
/* Munch up the memory to help catch bugs */
memset (data, 0xff, sizeof (void*) + length);
/* Store pointer to next allocated block at beginning */
*data = cs->allocated;
cs->allocated = data;
/* Data starts after first pointer */
return (void*)(data + 1);
}
static void
call_reset (CallState *cs)
{
void *allocated;
void **data;
assert (cs);
allocated = cs->allocated;
while (allocated) {
data = (void**)allocated;
/* Pointer to the next allocation */
allocated = *data;
free (data);
}
cs->allocated = NULL;
gkm_rpc_message_reset (cs->req);
gkm_rpc_message_reset (cs->resp);
}
static void
call_uninit (CallState *cs)
{
assert (cs);
call_reset (cs);
gkm_rpc_message_free (cs->req);
gkm_rpc_message_free (cs->resp);
}
/* -------------------------------------------------------------------
* PROTOCOL CODE
*/
static CK_RV
proto_read_byte_buffer (CallState *cs, CK_BYTE_PTR* buffer, CK_ULONG* n_buffer)
{
GkmRpcMessage *msg;
uint32_t length;
assert (cs);
assert (buffer);
assert (n_buffer);
msg = cs->req;
/* Check that we're supposed to be reading this at this point */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fy"));
/* The number of ulongs there's room for on the other end */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &length))
return PARSE_ERROR;
*n_buffer = length;
*buffer = NULL;
/* If set to zero, then they just want the length */
if (!length)
return CKR_OK;
*buffer = call_alloc (cs, length * sizeof (CK_BYTE));
if (!*buffer)
return CKR_DEVICE_MEMORY;
return CKR_OK;
}
static CK_RV
proto_read_byte_array (CallState *cs, CK_BYTE_PTR* array, CK_ULONG* n_array)
{
GkmRpcMessage *msg;
const unsigned char *data;
unsigned char valid;
size_t n_data;
assert (cs);
msg = cs->req;
/* Check that we're supposed to have this at this point */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "ay"));
/* Read out the byte which says whether data is present or not */
if (!egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &valid))
return PARSE_ERROR;
if (!valid) {
*array = NULL;
*n_array = 0;
return CKR_OK;
}
/* Point our arguments into the buffer */
if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed,
&data, &n_data))
return PARSE_ERROR;
*array = (CK_BYTE_PTR)data;
*n_array = n_data;
return CKR_OK;
}
static CK_RV
proto_write_byte_array (CallState *cs, CK_BYTE_PTR array, CK_ULONG len, CK_RV ret)
{
assert (cs);
/*
* When returning an byte array, in many cases we need to pass
* an invalid array along with a length, which signifies CKR_BUFFER_TOO_SMALL.
*/
switch (ret) {
case CKR_BUFFER_TOO_SMALL:
array = NULL;
/* fall through */
case CKR_OK:
break;
/* Pass all other errors straight through */
default:
return ret;
};
if (!gkm_rpc_message_write_byte_array (cs->resp, array, len))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_read_ulong_buffer (CallState *cs, CK_ULONG_PTR* buffer, CK_ULONG* n_buffer)
{
GkmRpcMessage *msg;
uint32_t length;
assert (cs);
assert (buffer);
assert (n_buffer);
msg = cs->req;
/* Check that we're supposed to be reading this at this point */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fu"));
/* The number of ulongs there's room for on the other end */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &length))
return PARSE_ERROR;
*n_buffer = length;
*buffer = NULL;
/* If set to zero, then they just want the length */
if (!length)
return CKR_OK;
*buffer = call_alloc (cs, length * sizeof (CK_ULONG));
if (!*buffer)
return CKR_DEVICE_MEMORY;
return CKR_OK;
}
static CK_RV
proto_write_ulong_array (CallState *cs, CK_ULONG_PTR array, CK_ULONG len, CK_RV ret)
{
assert (cs);
/*
* When returning an ulong array, in many cases we need to pass
* an invalid array along with a length, which signifies CKR_BUFFER_TOO_SMALL.
*/
switch (ret) {
case CKR_BUFFER_TOO_SMALL:
array = NULL;
/* fall through */
case CKR_OK:
break;
/* Pass all other errors straight through */
default:
return ret;
};
if (!gkm_rpc_message_write_ulong_array (cs->resp, array, len))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_read_attribute_buffer (CallState *cs, CK_ATTRIBUTE_PTR* result, CK_ULONG* n_result)
{
CK_ATTRIBUTE_PTR attrs;
GkmRpcMessage *msg;
uint32_t n_attrs, i;
uint32_t value;
assert (cs);
assert (result);
assert (n_result);
msg = cs->req;
/* Make sure this is in the rigth order */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fA"));
/* Read the number of attributes */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &n_attrs))
return PARSE_ERROR;
/* Allocate memory for the attribute structures */
attrs = call_alloc (cs, n_attrs * sizeof (CK_ATTRIBUTE));
if (!attrs)
return CKR_DEVICE_MEMORY;
/* Now go through and fill in each one */
for (i = 0; i < n_attrs; ++i) {
/* The attribute type */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value))
return PARSE_ERROR;
attrs[i].type = value;
/* The number of bytes to allocate */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value))
return PARSE_ERROR;
if (value == 0) {
attrs[i].pValue = NULL;
attrs[i].ulValueLen = 0;
} else {
attrs[i].pValue = call_alloc (cs, value);
if (!attrs[i].pValue)
return CKR_DEVICE_MEMORY;
attrs[i].ulValueLen = value;
}
}
*result = attrs;
*n_result = n_attrs;
return CKR_OK;
}
static CK_RV
proto_read_attribute_array (CallState *cs, CK_ATTRIBUTE_PTR* result, CK_ULONG* n_result)
{
CK_ATTRIBUTE_PTR attrs;
const unsigned char *data;
unsigned char valid;
GkmRpcMessage *msg;
uint32_t n_attrs, i;
uint32_t value;
size_t n_data;
assert (cs);
assert (result);
assert (n_result);
msg = cs->req;
/* Make sure this is in the rigth order */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "aA"));
/* Read the number of attributes */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &n_attrs))
return PARSE_ERROR;
/* Allocate memory for the attribute structures */
attrs = call_alloc (cs, n_attrs * sizeof (CK_ATTRIBUTE));
if (!attrs)
return CKR_DEVICE_MEMORY;
/* Now go through and fill in each one */
for (i = 0; i < n_attrs; ++i) {
/* The attribute type */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value))
return PARSE_ERROR;
attrs[i].type = value;
/* Whether this one is valid or not */
if (!egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &valid))
return PARSE_ERROR;
if (valid) {
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value))
return PARSE_ERROR;
if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &data, &n_data))
return PARSE_ERROR;
if (data != NULL && n_data != value) {
g_warning ("attribute length and data do not match");
return PARSE_ERROR;
}
attrs[i].pValue = (CK_VOID_PTR)data;
attrs[i].ulValueLen = value;
} else {
attrs[i].pValue = NULL;
attrs[i].ulValueLen = -1;
}
}
*result = attrs;
*n_result = n_attrs;
return CKR_OK;
}
static CK_RV
proto_write_attribute_array (CallState *cs, CK_ATTRIBUTE_PTR array, CK_ULONG len, CK_RV ret)
{
assert (cs);
/*
* When returning an attribute array, certain errors aren't
* actually real errors, these are passed through to the other
* side along with the attribute array.
*/
switch (ret) {
case CKR_ATTRIBUTE_SENSITIVE:
case CKR_ATTRIBUTE_TYPE_INVALID:
case CKR_BUFFER_TOO_SMALL:
case CKR_OK:
break;
/* Pass all other errors straight through */
default:
return ret;
};
if (!gkm_rpc_message_write_attribute_array (cs->resp, array, len) ||
!gkm_rpc_message_write_ulong (cs->resp, ret))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_read_null_string (CallState *cs, CK_UTF8CHAR_PTR* val)
{
GkmRpcMessage *msg;
const unsigned char *data;
size_t n_data;
assert (cs);
assert (val);
msg = cs->req;
/* Check that we're supposed to have this at this point */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "z"));
if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &data, &n_data))
return PARSE_ERROR;
/* Allocate a block of memory for it */
*val = call_alloc (cs, n_data);
if (!*val)
return CKR_DEVICE_MEMORY;
memcpy (*val, data, n_data);
(*val)[n_data] = 0;
return CKR_OK;
}
static CK_RV
proto_read_mechanism (CallState *cs, CK_MECHANISM_PTR mech)
{
GkmRpcMessage *msg;
const unsigned char *data;
uint32_t value;
size_t n_data;
assert (cs);
assert (mech);
msg = cs->req;
/* Make sure this is in the right order */
assert (!msg->signature || gkm_rpc_message_verify_part (msg, "M"));
/* The mechanism type */
if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &msg->parsed, &value))
return PARSE_ERROR;
/* The mechanism data */
if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &data, &n_data))
return PARSE_ERROR;
mech->mechanism = value;
mech->pParameter = (CK_VOID_PTR)data;
mech->ulParameterLen = n_data;
return CKR_OK;
}
static CK_RV
proto_write_info (CallState *cs, CK_INFO_PTR info)
{
GkmRpcMessage *msg;
assert (cs);
assert (info);
msg = cs->resp;
if (!gkm_rpc_message_write_version (msg, &info->cryptokiVersion) ||
!gkm_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
!gkm_rpc_message_write_ulong (msg, info->flags) ||
!gkm_rpc_message_write_space_string (msg, info->libraryDescription, 32) ||
!gkm_rpc_message_write_version (msg, &info->libraryVersion))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_write_slot_info (CallState *cs, CK_SLOT_INFO_PTR info)
{
GkmRpcMessage *msg;
assert (cs);
assert (info);
msg = cs->resp;
if (!gkm_rpc_message_write_space_string (msg, info->slotDescription, 64) ||
!gkm_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
!gkm_rpc_message_write_ulong (msg, info->flags) ||
!gkm_rpc_message_write_version (msg, &info->hardwareVersion) ||
!gkm_rpc_message_write_version (msg, &info->firmwareVersion))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_write_token_info (CallState *cs, CK_TOKEN_INFO_PTR info)
{
GkmRpcMessage *msg;
assert (cs);
assert (info);
msg = cs->resp;
if (!gkm_rpc_message_write_space_string (msg, info->label, 32) ||
!gkm_rpc_message_write_space_string (msg, info->manufacturerID, 32) ||
!gkm_rpc_message_write_space_string (msg, info->model, 16) ||
!gkm_rpc_message_write_space_string (msg, info->serialNumber, 16) ||
!gkm_rpc_message_write_ulong (msg, info->flags) ||
!gkm_rpc_message_write_ulong (msg, info->ulMaxSessionCount) ||
!gkm_rpc_message_write_ulong (msg, info->ulSessionCount) ||
!gkm_rpc_message_write_ulong (msg, info->ulMaxRwSessionCount) ||
!gkm_rpc_message_write_ulong (msg, info->ulRwSessionCount) ||
!gkm_rpc_message_write_ulong (msg, info->ulMaxPinLen) ||
!gkm_rpc_message_write_ulong (msg, info->ulMinPinLen) ||
!gkm_rpc_message_write_ulong (msg, info->ulTotalPublicMemory) ||
!gkm_rpc_message_write_ulong (msg, info->ulFreePublicMemory) ||
!gkm_rpc_message_write_ulong (msg, info->ulTotalPrivateMemory) ||
!gkm_rpc_message_write_ulong (msg, info->ulFreePrivateMemory) ||
!gkm_rpc_message_write_version (msg, &info->hardwareVersion) ||
!gkm_rpc_message_write_version (msg, &info->firmwareVersion) ||
!gkm_rpc_message_write_space_string (msg, info->utcTime, 16))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_write_mechanism_info (CallState *cs, CK_MECHANISM_INFO_PTR info)
{
GkmRpcMessage *msg;
assert (cs);
assert (info);
msg = cs->resp;
if (!gkm_rpc_message_write_ulong (msg, info->ulMinKeySize) ||
!gkm_rpc_message_write_ulong (msg, info->ulMaxKeySize) ||
!gkm_rpc_message_write_ulong (msg, info->flags))
return PREP_ERROR;
return CKR_OK;
}
static CK_RV
proto_write_session_info (CallState *cs, CK_SESSION_INFO_PTR info)
{
GkmRpcMessage *msg;
assert (cs);
assert (info);
msg = cs->resp;
if (!gkm_rpc_message_write_ulong (msg, info->slotID) ||
!gkm_rpc_message_write_ulong (msg, info->state) ||
!gkm_rpc_message_write_ulong (msg, info->flags) ||
!gkm_rpc_message_write_ulong (msg, info->ulDeviceError))
return PREP_ERROR;
return CKR_OK;
}
/* -------------------------------------------------------------------
* CALL MACROS
*/
#define BEGIN_CALL(call_id) \
debug ((#call_id ": enter")); \
assert (cs); \
assert (pkcs11_module); \
{ \
CK_ ## call_id _func = pkcs11_module-> call_id; \
CK_RV _ret = CKR_OK; \
if (!_func) { _ret = CKR_GENERAL_ERROR; goto _cleanup; }
#define PROCESS_CALL(args)\
assert (gkm_rpc_message_is_verified (cs->req)); \
_ret = _func args
#define END_CALL \
_cleanup: \
debug (("ret: %d", _ret)); \
return _ret; \
}
#define IN_BYTE(val) \
if (!gkm_rpc_message_read_byte (cs->req, &val)) \
{ _ret = PARSE_ERROR; goto _cleanup; }
#define IN_ULONG(val) \
if (!gkm_rpc_message_read_ulong (cs->req, &val)) \
{ _ret = PARSE_ERROR; goto _cleanup; }
#define IN_STRING(val) \
_ret = proto_read_null_string (cs, &val); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_BYTE_BUFFER(buffer, buffer_len) \
_ret = proto_read_byte_buffer (cs, &buffer, &buffer_len); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_BYTE_ARRAY(buffer, buffer_len) \
_ret = proto_read_byte_array (cs, &buffer, &buffer_len); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_ULONG_BUFFER(buffer, buffer_len) \
_ret = proto_read_ulong_buffer (cs, &buffer, &buffer_len); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_ATTRIBUTE_BUFFER(buffer, buffer_len) \
_ret = proto_read_attribute_buffer (cs, &buffer, &buffer_len); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_ATTRIBUTE_ARRAY(attrs, n_attrs) \
_ret = proto_read_attribute_array (cs, &attrs, &n_attrs); \
if (_ret != CKR_OK) goto _cleanup;
#define IN_MECHANISM(mech) \
_ret = proto_read_mechanism (cs, &mech); \
if (_ret != CKR_OK) goto _cleanup;
#define OUT_ULONG(val) \
if (_ret == CKR_OK && !gkm_rpc_message_write_ulong (cs->resp, val)) \
_ret = PREP_ERROR;
#define OUT_BYTE_ARRAY(array, len) \
/* Note how we filter return codes */ \
_ret = proto_write_byte_array (cs, array, len, _ret);
#define OUT_ULONG_ARRAY(array, len) \
/* Note how we filter return codes */ \
_ret = proto_write_ulong_array (cs, array, len, _ret);
#define OUT_ATTRIBUTE_ARRAY(array, len) \
/* Note how we filter return codes */ \
_ret = proto_write_attribute_array (cs, array, len, _ret);
#define OUT_INFO(val) \
if (_ret == CKR_OK) \
_ret = proto_write_info (cs, &val);
#define OUT_SLOT_INFO(val) \
if (_ret == CKR_OK) \
_ret = proto_write_slot_info (cs, &val);
#define OUT_TOKEN_INFO(val) \
if (_ret == CKR_OK) \
_ret = proto_write_token_info (cs, &val);
#define OUT_MECHANISM_INFO(val) \
if (_ret == CKR_OK) \
_ret = proto_write_mechanism_info (cs, &val);
#define OUT_SESSION_INFO(val) \
if (_ret == CKR_OK) \
_ret = proto_write_session_info (cs, &val);
/* ---------------------------------------------------------------------------
* DISPATCH SPECIFIC CALLS
*/
static CK_RV
rpc_C_Initialize (CallState *cs)
{
CK_BYTE_PTR handshake;
CK_ULONG n_handshake;
CK_RV ret = CKR_OK;
debug (("C_Initialize: enter"));
assert (cs);
assert (pkcs11_module);
ret = proto_read_byte_array (cs, &handshake, &n_handshake);
if (ret == CKR_OK) {
/* Check to make sure the header matches */
if (n_handshake != GKM_RPC_HANDSHAKE_LEN ||
memcmp (handshake, GKM_RPC_HANDSHAKE, n_handshake) != 0) {
gkm_rpc_warn ("invalid handshake received from connecting module");
ret = CKR_GENERAL_ERROR;
}
assert (gkm_rpc_message_is_verified (cs->req));
}
/*
* We don't actually C_Initialize lower layers. It's assumed
* that they'll already be initialzied by the code that loaded us.
*/
debug (("ret: %d", ret));
return ret;
}
static CK_RV
rpc_C_Finalize (CallState *cs)
{
CK_SLOT_ID_PTR slots;
CK_ULONG n_slots, i;
CK_RV ret = CKR_OK;
debug (("C_Finalize: enter"));
assert (cs);
assert (pkcs11_module);
/*
* We don't actually C_Finalize lower layers, since this would finalize
* for all appartments, client applications. Anyway this is done by
* the code that loaded us.
*
* But we do need to cleanup resources used by this client, so instead
* we call C_CloseAllSessions for each slot for this client application.
*/
if (cs->client->application.applicationId) {
ret = (pkcs11_module->C_GetSlotList) (TRUE, NULL, &n_slots);
if (ret == CKR_OK) {
slots = calloc (n_slots, sizeof (CK_SLOT_ID));
if (slots == NULL) {
ret = CKR_DEVICE_MEMORY;
} else {
ret = (pkcs11_module->C_GetSlotList) (TRUE, slots, &n_slots);
for (i = 0; ret == CKR_OK && i < n_slots; ++i)
ret = (pkcs11_module->C_CloseAllSessions) (slots[i] | cs->client->application.applicationId);
free (slots);
}
}
}
debug (("ret: %d", ret));
return ret;
}
static CK_RV
rpc_C_GetInfo (CallState *cs)
{
CK_INFO info;
BEGIN_CALL (C_GetInfo);
PROCESS_CALL ((&info));
OUT_INFO (info);
END_CALL;
}
static CK_RV
rpc_C_GetSlotList (CallState *cs)
{
CK_BBOOL token_present;
CK_SLOT_ID_PTR slot_list;
CK_ULONG count;
BEGIN_CALL (C_GetSlotList);
IN_BYTE (token_present);
IN_ULONG_BUFFER (slot_list, count);
PROCESS_CALL ((token_present, slot_list, &count));
OUT_ULONG_ARRAY (slot_list, count);
END_CALL;
}
static CK_RV
rpc_C_GetSlotInfo (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_SLOT_INFO info;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_GetSlotInfo);
IN_ULONG (slot_id);
PROCESS_CALL ((slot_id, &info));
OUT_SLOT_INFO (info);
END_CALL;
}
static CK_RV
rpc_C_GetTokenInfo (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_TOKEN_INFO info;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_GetTokenInfo);
IN_ULONG (slot_id);
PROCESS_CALL ((slot_id, &info));
OUT_TOKEN_INFO (info);
END_CALL;
}
static CK_RV
rpc_C_GetMechanismList (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_MECHANISM_TYPE_PTR mechanism_list;
CK_ULONG count;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_GetMechanismList);
IN_ULONG (slot_id);
IN_ULONG_BUFFER (mechanism_list, count);
PROCESS_CALL ((slot_id, mechanism_list, &count));
OUT_ULONG_ARRAY (mechanism_list, count);
END_CALL;
}
static CK_RV
rpc_C_GetMechanismInfo (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_MECHANISM_TYPE type;
CK_MECHANISM_INFO info;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_GetMechanismInfo);
IN_ULONG (slot_id);
IN_ULONG (type);
PROCESS_CALL ((slot_id, type, &info));
OUT_MECHANISM_INFO (info);
END_CALL;
}
static CK_RV
rpc_C_InitToken (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_UTF8CHAR_PTR pin;
CK_ULONG pin_len;
CK_UTF8CHAR_PTR label;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_InitToken);
IN_ULONG (slot_id);
IN_BYTE_ARRAY (pin, pin_len);
IN_STRING (label);
PROCESS_CALL ((slot_id, pin, pin_len, label));
END_CALL;
}
static CK_RV
rpc_C_WaitForSlotEvent (CallState *cs)
{
CK_FLAGS flags;
CK_SLOT_ID slot_id;
/* Get slot id from appartment lower layers use. */
BEGIN_CALL (C_WaitForSlotEvent);
IN_ULONG (flags);
PROCESS_CALL ((flags, &slot_id, NULL));
OUT_ULONG (slot_id);
END_CALL;
}
static CK_RV
rpc_C_OpenSession (CallState *cs)
{
CK_SLOT_ID slot_id;
CK_FLAGS flags;
CK_SESSION_HANDLE session;
/* Slot id becomes appartment so lower layers can tell clients apart. */
/*
* IMPORTANT: When we open sessions on behalf of a client caller
* we always specify CKF_G_APPLICATION_SESSION. This allows the module
* to know whether they're talking to the daemon or a client app.
*
* This is a security feature.
*/
BEGIN_CALL (C_OpenSession);
IN_ULONG (slot_id);
IN_ULONG (flags);
flags |= CKF_G_APPLICATION_SESSION;
PROCESS_CALL ((slot_id, flags, &cs->client->application, NULL, &session));
OUT_ULONG (session);
END_CALL;
}
static CK_RV
rpc_C_CloseSession (CallState *cs)
{
CK_SESSION_HANDLE session;
BEGIN_CALL (C_CloseSession);
IN_ULONG (session);
PROCESS_CALL ((session));
END_CALL;
}
static CK_RV
rpc_C_CloseAllSessions (CallState *cs)
{
CK_SLOT_ID slot_id;
/* Slot id becomes appartment so lower layers can tell clients apart. */
BEGIN_CALL (C_CloseAllSessions);
IN_ULONG (slot_id);
slot_id |= cs->client->application.applicationId;
PROCESS_CALL ((slot_id));
END_CALL;
}
static CK_RV
rpc_C_GetFunctionStatus (CallState *cs)
{
CK_SESSION_HANDLE session;
BEGIN_CALL (C_GetFunctionStatus);
IN_ULONG (session);
PROCESS_CALL ((session));
END_CALL;
}
static CK_RV
rpc_C_CancelFunction (CallState *cs)
{
CK_SESSION_HANDLE session;
BEGIN_CALL (C_CancelFunction);
IN_ULONG (session);
PROCESS_CALL ((session));
END_CALL;
}
static CK_RV
rpc_C_GetSessionInfo (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_SESSION_INFO info;
/* Get slot id from appartment lower layers use. */
BEGIN_CALL (C_GetSessionInfo);
IN_ULONG (session);
PROCESS_CALL ((session, &info));
OUT_SESSION_INFO (info);
END_CALL;
}
static CK_RV
rpc_C_InitPIN (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_UTF8CHAR_PTR pin;
CK_ULONG pin_len;
BEGIN_CALL (C_InitPIN);
IN_ULONG (session);
IN_BYTE_ARRAY (pin, pin_len);
PROCESS_CALL ((session, pin, pin_len));
END_CALL;
}
static CK_RV
rpc_C_SetPIN (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_UTF8CHAR_PTR old_pin;
CK_ULONG old_len;
CK_UTF8CHAR_PTR new_pin;
CK_ULONG new_len;
BEGIN_CALL (C_SetPIN);
IN_ULONG (session);
IN_BYTE_ARRAY (old_pin, old_len);
IN_BYTE_ARRAY (new_pin, new_len);
PROCESS_CALL ((session, old_pin, old_len, new_pin, new_len));
END_CALL;
}
static CK_RV
rpc_C_GetOperationState (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR operation_state;
CK_ULONG operation_state_len;
BEGIN_CALL (C_GetOperationState);
IN_ULONG (session);
IN_BYTE_BUFFER (operation_state, operation_state_len);
PROCESS_CALL ((session, operation_state, &operation_state_len));
OUT_BYTE_ARRAY (operation_state, operation_state_len);
END_CALL;
}
static CK_RV
rpc_C_SetOperationState (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR operation_state;
CK_ULONG operation_state_len;
CK_OBJECT_HANDLE encryption_key;
CK_OBJECT_HANDLE authentication_key;
BEGIN_CALL (C_SetOperationState);
IN_ULONG (session);
IN_BYTE_ARRAY (operation_state, operation_state_len);
IN_ULONG (encryption_key);
IN_ULONG (authentication_key);
PROCESS_CALL ((session, operation_state, operation_state_len, encryption_key, authentication_key));
END_CALL;
}
static CK_RV
rpc_C_Login (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_USER_TYPE user_type;
CK_UTF8CHAR_PTR pin;
CK_ULONG pin_len;
BEGIN_CALL (C_Login);
IN_ULONG (session);
IN_ULONG (user_type);
IN_BYTE_ARRAY (pin, pin_len);
PROCESS_CALL ((session, user_type, pin, pin_len));
END_CALL;
}
static CK_RV
rpc_C_Logout (CallState *cs)
{
CK_SESSION_HANDLE session;
BEGIN_CALL (C_Logout);
IN_ULONG (session);
PROCESS_CALL ((session));
END_CALL;
}
/* -----------------------------------------------------------------------------
* OBJECT OPERATIONS
*/
static CK_RV
rpc_C_CreateObject (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
CK_OBJECT_HANDLE new_object;
BEGIN_CALL (C_CreateObject);
IN_ULONG (session);
IN_ATTRIBUTE_ARRAY (template, count);
PROCESS_CALL ((session, template, count, &new_object));
OUT_ULONG (new_object);
END_CALL;
}
static CK_RV
rpc_C_CopyObject (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
CK_OBJECT_HANDLE new_object;
BEGIN_CALL (C_CopyObject);
IN_ULONG (session);
IN_ULONG (object);
IN_ATTRIBUTE_ARRAY (template, count);
PROCESS_CALL ((session, object, template, count, &new_object));
OUT_ULONG (new_object);
END_CALL;
}
static CK_RV
rpc_C_DestroyObject (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
BEGIN_CALL (C_DestroyObject);
IN_ULONG (session);
IN_ULONG (object);
PROCESS_CALL ((session, object));
END_CALL;
}
static CK_RV
rpc_C_GetObjectSize (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
CK_ULONG size;
BEGIN_CALL (C_GetObjectSize);
IN_ULONG (session);
IN_ULONG (object);
PROCESS_CALL ((session, object, &size));
OUT_ULONG (size);
END_CALL;
}
static CK_RV
rpc_C_GetAttributeValue (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
BEGIN_CALL (C_GetAttributeValue);
IN_ULONG (session);
IN_ULONG (object);
IN_ATTRIBUTE_BUFFER (template, count);
PROCESS_CALL ((session, object, template, count));
OUT_ATTRIBUTE_ARRAY (template, count);
END_CALL;
}
static CK_RV
rpc_C_SetAttributeValue (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE object;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
BEGIN_CALL (C_SetAttributeValue);
IN_ULONG (session);
IN_ULONG (object);
IN_ATTRIBUTE_ARRAY (template, count);
PROCESS_CALL ((session, object, template, count));
END_CALL;
}
static CK_RV
rpc_C_FindObjectsInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
BEGIN_CALL (C_FindObjectsInit);
IN_ULONG (session);
IN_ATTRIBUTE_ARRAY (template, count);
PROCESS_CALL ((session, template, count));
END_CALL;
}
static CK_RV
rpc_C_FindObjects (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE_PTR objects;
CK_ULONG max_object_count;
CK_ULONG object_count;
BEGIN_CALL (C_FindObjects);
IN_ULONG (session);
IN_ULONG_BUFFER (objects, max_object_count);
PROCESS_CALL ((session, objects, max_object_count, &object_count));
OUT_ULONG_ARRAY (objects, object_count);
END_CALL;
}
static CK_RV
rpc_C_FindObjectsFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
BEGIN_CALL (C_FindObjectsFinal);
IN_ULONG (session);
PROCESS_CALL ((session));
END_CALL;
}
static CK_RV
rpc_C_EncryptInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_EncryptInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_Encrypt (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR data;
CK_ULONG data_len;
CK_BYTE_PTR encrypted_data;
CK_ULONG encrypted_data_len;
BEGIN_CALL (C_Encrypt);
IN_ULONG (session);
IN_BYTE_ARRAY (data, data_len);
IN_BYTE_BUFFER (encrypted_data, encrypted_data_len);
PROCESS_CALL ((session, data, data_len, encrypted_data, &encrypted_data_len));
OUT_BYTE_ARRAY (encrypted_data, encrypted_data_len);
END_CALL;
}
static CK_RV
rpc_C_EncryptUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
BEGIN_CALL (C_EncryptUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
END_CALL;
}
static CK_RV
rpc_C_EncryptFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR last_encrypted_part;
CK_ULONG last_encrypted_part_len;
BEGIN_CALL (C_EncryptFinal);
IN_ULONG (session);
IN_BYTE_BUFFER (last_encrypted_part, last_encrypted_part_len);
PROCESS_CALL ((session, last_encrypted_part, &last_encrypted_part_len));
OUT_BYTE_ARRAY (last_encrypted_part, last_encrypted_part_len);
END_CALL;
}
static CK_RV
rpc_C_DecryptInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_DecryptInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_Decrypt (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR encrypted_data;
CK_ULONG encrypted_data_len;
CK_BYTE_PTR data;
CK_ULONG data_len;
BEGIN_CALL (C_Decrypt);
IN_ULONG (session);
IN_BYTE_ARRAY (encrypted_data, encrypted_data_len);
IN_BYTE_BUFFER (data, data_len);
PROCESS_CALL ((session, encrypted_data, encrypted_data_len, data, &data_len));
OUT_BYTE_ARRAY (data, data_len);
END_CALL;
}
static CK_RV
rpc_C_DecryptUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_DecryptUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
IN_BYTE_BUFFER (part, part_len);
PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
OUT_BYTE_ARRAY (part, part_len);
END_CALL;
}
static CK_RV
rpc_C_DecryptFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR last_part;
CK_ULONG last_part_len;
BEGIN_CALL (C_DecryptFinal);
IN_ULONG (session);
IN_BYTE_BUFFER (last_part, last_part_len);
PROCESS_CALL ((session, last_part, &last_part_len));
OUT_BYTE_ARRAY (last_part, last_part_len);
END_CALL;
}
static CK_RV
rpc_C_DigestInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
BEGIN_CALL (C_DigestInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
PROCESS_CALL ((session, &mechanism));
END_CALL;
}
static CK_RV
rpc_C_Digest (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR data;
CK_ULONG data_len;
CK_BYTE_PTR digest;
CK_ULONG digest_len;
BEGIN_CALL (C_Digest);
IN_ULONG (session);
IN_BYTE_ARRAY (data, data_len);
IN_BYTE_BUFFER (digest, digest_len);
PROCESS_CALL ((session, data, data_len, digest, &digest_len));
OUT_BYTE_ARRAY (digest, digest_len);
END_CALL;
}
static CK_RV
rpc_C_DigestUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_DigestUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
PROCESS_CALL ((session, part, part_len));
END_CALL;
}
static CK_RV
rpc_C_DigestKey (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_DigestKey);
IN_ULONG (session);
IN_ULONG (key);
PROCESS_CALL ((session, key));
END_CALL;
}
static CK_RV
rpc_C_DigestFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR digest;
CK_ULONG digest_len;
BEGIN_CALL (C_DigestFinal);
IN_ULONG (session);
IN_BYTE_BUFFER (digest, digest_len);
PROCESS_CALL ((session, digest, &digest_len));
OUT_BYTE_ARRAY (digest, digest_len);
END_CALL;
}
static CK_RV
rpc_C_SignInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_SignInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_Sign (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
BEGIN_CALL (C_Sign);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
IN_BYTE_BUFFER (signature, signature_len);
PROCESS_CALL ((session, part, part_len, signature, &signature_len));
OUT_BYTE_ARRAY (signature, signature_len);
END_CALL;
}
static CK_RV
rpc_C_SignUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_SignUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
PROCESS_CALL ((session, part, part_len));
END_CALL;
}
static CK_RV
rpc_C_SignFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
BEGIN_CALL (C_SignFinal);
IN_ULONG (session);
IN_BYTE_BUFFER (signature, signature_len);
PROCESS_CALL ((session, signature, &signature_len));
OUT_BYTE_ARRAY (signature, signature_len);
END_CALL;
}
static CK_RV
rpc_C_SignRecoverInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_SignRecoverInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_SignRecover (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR data;
CK_ULONG data_len;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
BEGIN_CALL (C_SignRecover);
IN_ULONG (session);
IN_BYTE_ARRAY (data, data_len);
IN_BYTE_BUFFER (signature, signature_len);
PROCESS_CALL ((session, data, data_len, signature, &signature_len));
OUT_BYTE_ARRAY (signature, signature_len);
END_CALL;
}
static CK_RV
rpc_C_VerifyInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_VerifyInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_Verify (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR data;
CK_ULONG data_len;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
BEGIN_CALL (C_Verify);
IN_ULONG (session);
IN_BYTE_ARRAY (data, data_len);
IN_BYTE_ARRAY (signature, signature_len);
PROCESS_CALL ((session, data, data_len, signature, signature_len));
END_CALL;
}
static CK_RV
rpc_C_VerifyUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_VerifyUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
PROCESS_CALL ((session, part, part_len));
END_CALL;
}
static CK_RV
rpc_C_VerifyFinal (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
BEGIN_CALL (C_VerifyFinal);
IN_ULONG (session);
IN_BYTE_ARRAY (signature, signature_len);
PROCESS_CALL ((session, signature, signature_len));
END_CALL;
}
static CK_RV
rpc_C_VerifyRecoverInit (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_VerifyRecoverInit);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (key);
PROCESS_CALL ((session, &mechanism, key));
END_CALL;
}
static CK_RV
rpc_C_VerifyRecover (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR signature;
CK_ULONG signature_len;
CK_BYTE_PTR data;
CK_ULONG data_len;
BEGIN_CALL (C_VerifyRecover);
IN_ULONG (session);
IN_BYTE_ARRAY (signature, signature_len);
IN_BYTE_BUFFER (data, data_len);
PROCESS_CALL ((session, signature, signature_len, data, &data_len));
OUT_BYTE_ARRAY (data, data_len);
END_CALL;
}
static CK_RV
rpc_C_DigestEncryptUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
BEGIN_CALL (C_DigestEncryptUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
END_CALL;
}
static CK_RV
rpc_C_DecryptDigestUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_DecryptDigestUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
IN_BYTE_BUFFER (part, part_len);
PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
OUT_BYTE_ARRAY (part, part_len);
END_CALL;
}
static CK_RV
rpc_C_SignEncryptUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR part;
CK_ULONG part_len;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
BEGIN_CALL (C_SignEncryptUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (part, part_len);
IN_BYTE_BUFFER (encrypted_part, encrypted_part_len);
PROCESS_CALL ((session, part, part_len, encrypted_part, &encrypted_part_len));
OUT_BYTE_ARRAY (encrypted_part, encrypted_part_len);
END_CALL;
}
static CK_RV
rpc_C_DecryptVerifyUpdate (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR encrypted_part;
CK_ULONG encrypted_part_len;
CK_BYTE_PTR part;
CK_ULONG part_len;
BEGIN_CALL (C_DecryptVerifyUpdate);
IN_ULONG (session);
IN_BYTE_ARRAY (encrypted_part, encrypted_part_len);
IN_BYTE_BUFFER (part, part_len);
PROCESS_CALL ((session, encrypted_part, encrypted_part_len, part, &part_len));
OUT_BYTE_ARRAY (part, part_len);
END_CALL;
}
/* -----------------------------------------------------------------------------
* KEY OPERATIONS
*/
static CK_RV
rpc_C_GenerateKey (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_GenerateKey);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ATTRIBUTE_ARRAY (template, count);
PROCESS_CALL ((session, &mechanism, template, count, &key));
OUT_ULONG (key);
END_CALL;
}
static CK_RV
rpc_C_GenerateKeyPair (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_ATTRIBUTE_PTR public_key_template;
CK_ULONG public_key_attribute_count;
CK_ATTRIBUTE_PTR private_key_template;
CK_ULONG private_key_attribute_count;
CK_OBJECT_HANDLE public_key;
CK_OBJECT_HANDLE private_key;
BEGIN_CALL (C_GenerateKeyPair);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ATTRIBUTE_ARRAY (public_key_template, public_key_attribute_count);
IN_ATTRIBUTE_ARRAY (private_key_template, private_key_attribute_count);
PROCESS_CALL ((session, &mechanism, public_key_template, public_key_attribute_count, private_key_template, private_key_attribute_count, &public_key, &private_key));
OUT_ULONG (public_key);
OUT_ULONG (private_key);
END_CALL;
}
static CK_RV
rpc_C_WrapKey (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE wrapping_key;
CK_OBJECT_HANDLE key;
CK_BYTE_PTR wrapped_key;
CK_ULONG wrapped_key_len;
BEGIN_CALL (C_WrapKey);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (wrapping_key);
IN_ULONG (key);
IN_BYTE_BUFFER (wrapped_key, wrapped_key_len);
PROCESS_CALL ((session, &mechanism, wrapping_key, key, wrapped_key, &wrapped_key_len));
OUT_BYTE_ARRAY (wrapped_key, wrapped_key_len);
END_CALL;
}
static CK_RV
rpc_C_UnwrapKey (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE unwrapping_key;
CK_BYTE_PTR wrapped_key;
CK_ULONG wrapped_key_len;
CK_ATTRIBUTE_PTR template;
CK_ULONG attribute_count;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_UnwrapKey);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (unwrapping_key);
IN_BYTE_ARRAY (wrapped_key, wrapped_key_len);
IN_ATTRIBUTE_ARRAY (template, attribute_count);
PROCESS_CALL ((session, &mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, attribute_count, &key));
OUT_ULONG (key);
END_CALL;
}
static CK_RV
rpc_C_DeriveKey (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_MECHANISM mechanism;
CK_OBJECT_HANDLE base_key;
CK_ATTRIBUTE_PTR template;
CK_ULONG attribute_count;
CK_OBJECT_HANDLE key;
BEGIN_CALL (C_DeriveKey);
IN_ULONG (session);
IN_MECHANISM (mechanism);
IN_ULONG (base_key);
IN_ATTRIBUTE_ARRAY (template, attribute_count);
PROCESS_CALL ((session, &mechanism, base_key, template, attribute_count, &key));
OUT_ULONG (key);
END_CALL;
}
static CK_RV
rpc_C_SeedRandom (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR seed;
CK_ULONG seed_len;
BEGIN_CALL (C_SeedRandom);
IN_ULONG (session);
IN_BYTE_ARRAY (seed, seed_len);
PROCESS_CALL ((session, seed, seed_len));
END_CALL;
}
static CK_RV
rpc_C_GenerateRandom (CallState *cs)
{
CK_SESSION_HANDLE session;
CK_BYTE_PTR random_data;
CK_ULONG random_len;
BEGIN_CALL (C_GenerateRandom);
IN_ULONG (session);
IN_BYTE_BUFFER (random_data, random_len);
PROCESS_CALL ((session, random_data, random_len));
OUT_BYTE_ARRAY (random_data, random_len);
END_CALL;
}
/* ---------------------------------------------------------------------------
* DISPATCH THREAD HANDLING
*/
static int
dispatch_call (CallState *cs)
{
GkmRpcMessage *req, *resp;
CK_RV ret = CKR_OK;
assert (cs);
req = cs->req;
resp = cs->resp;
/* This should have been checked by the parsing code */
assert (req->call_id > GKM_RPC_CALL_ERROR);
assert (req->call_id < GKM_RPC_CALL_MAX);
/* Prepare a response for the function to fill in */
if (!gkm_rpc_message_prep (resp, req->call_id, GKM_RPC_RESPONSE)) {
gkm_rpc_warn ("couldn't prepare message");
return 0;
}
switch(req->call_id) {
#define CASE_CALL(name) \
case GKM_RPC_CALL_##name: \
ret = rpc_##name (cs); \
break;
CASE_CALL(C_Initialize)
CASE_CALL(C_Finalize)
CASE_CALL(C_GetInfo)
CASE_CALL(C_GetSlotList)
CASE_CALL(C_GetSlotInfo)
CASE_CALL(C_GetTokenInfo)
CASE_CALL(C_GetMechanismList)
CASE_CALL(C_GetMechanismInfo)
CASE_CALL(C_InitToken)
CASE_CALL(C_WaitForSlotEvent)
CASE_CALL(C_OpenSession)
CASE_CALL(C_CloseSession)
CASE_CALL(C_CloseAllSessions)
CASE_CALL(C_GetFunctionStatus)
CASE_CALL(C_CancelFunction)
CASE_CALL(C_GetSessionInfo)
CASE_CALL(C_InitPIN)
CASE_CALL(C_SetPIN)
CASE_CALL(C_GetOperationState)
CASE_CALL(C_SetOperationState)
CASE_CALL(C_Login)
CASE_CALL(C_Logout)
CASE_CALL(C_CreateObject)
CASE_CALL(C_CopyObject)
CASE_CALL(C_DestroyObject)
CASE_CALL(C_GetObjectSize)
CASE_CALL(C_GetAttributeValue)
CASE_CALL(C_SetAttributeValue)
CASE_CALL(C_FindObjectsInit)
CASE_CALL(C_FindObjects)
CASE_CALL(C_FindObjectsFinal)
CASE_CALL(C_EncryptInit)
CASE_CALL(C_Encrypt)
CASE_CALL(C_EncryptUpdate)
CASE_CALL(C_EncryptFinal)
CASE_CALL(C_DecryptInit)
CASE_CALL(C_Decrypt)
CASE_CALL(C_DecryptUpdate)
CASE_CALL(C_DecryptFinal)
CASE_CALL(C_DigestInit)
CASE_CALL(C_Digest)
CASE_CALL(C_DigestUpdate)
CASE_CALL(C_DigestKey)
CASE_CALL(C_DigestFinal)
CASE_CALL(C_SignInit)
CASE_CALL(C_Sign)
CASE_CALL(C_SignUpdate)
CASE_CALL(C_SignFinal)
CASE_CALL(C_SignRecoverInit)
CASE_CALL(C_SignRecover)
CASE_CALL(C_VerifyInit)
CASE_CALL(C_Verify)
CASE_CALL(C_VerifyUpdate)
CASE_CALL(C_VerifyFinal)
CASE_CALL(C_VerifyRecoverInit)
CASE_CALL(C_VerifyRecover)
CASE_CALL(C_DigestEncryptUpdate)
CASE_CALL(C_DecryptDigestUpdate)
CASE_CALL(C_SignEncryptUpdate)
CASE_CALL(C_DecryptVerifyUpdate)
CASE_CALL(C_GenerateKey)
CASE_CALL(C_GenerateKeyPair)
CASE_CALL(C_WrapKey)
CASE_CALL(C_UnwrapKey)
CASE_CALL(C_DeriveKey)
CASE_CALL(C_SeedRandom)
CASE_CALL(C_GenerateRandom)
#undef CASE_CALL
default:
/* This should have been caught by the parse code */
assert (0 && "Unchecked call");
break;
};
if (ret == CKR_OK) {
/* Parsing errors? */
if (gkm_rpc_message_buffer_error (req)) {
gkm_rpc_warn ("invalid request from module, probably too short");
ret = PARSE_ERROR;
}
/* Out of memory errors? */
if (gkm_rpc_message_buffer_error (resp)) {
gkm_rpc_warn ("out of memory error putting together message");
ret = PREP_ERROR;
}
}
/* A filled in response */
if (ret == CKR_OK) {
/*
* Since we're dealing with many many functions above generating
* these messages we want to make sure each of them actually
* does what it's supposed to.
*/
assert (gkm_rpc_message_is_verified (resp));
assert (resp->call_type == GKM_RPC_RESPONSE);
assert (resp->call_id == req->call_id);
assert (gkm_rpc_calls[resp->call_id].response);
assert (strcmp (gkm_rpc_calls[resp->call_id].response,
resp->signature) == 0);
/* Fill in an error respnose */
} else {
if (!gkm_rpc_message_prep (resp, GKM_RPC_CALL_ERROR, GKM_RPC_RESPONSE) ||
!gkm_rpc_message_write_ulong (resp, (uint32_t)ret) ||
gkm_rpc_message_buffer_error (resp)) {
gkm_rpc_warn ("out of memory responding with error");
return 0;
}
}
return 1;
}
static int
read_all (int sock, unsigned char* data, size_t len)
{
int r;
assert (sock >= 0);
assert (data);
assert (len > 0);
while (len > 0) {
r = read (sock, data, len);
if (r == 0) {
/* Connection was closed on client */
return 0;
} else if (r == -1) {
if (errno != EAGAIN && errno != EINTR) {
gkm_rpc_warn ("couldn't receive data: %s", strerror (errno));
return 0;
}
} else {
data += r;
len -= r;
}
}
return 1;
}
static int
write_all (int sock, unsigned char* data, size_t len)
{
int r;
assert (sock >= 0);
assert (data);
assert (len > 0);
while (len > 0) {
r = write (sock, data, len);
if (r == -1) {
if (errno == EPIPE) {
/* Connection closed from client */
return 0;
} else if (errno != EAGAIN && errno != EINTR) {
gkm_rpc_warn ("couldn't send data: %s", strerror (errno));
return 0;
}
} else {
data += r;
len -= r;
}
}
return 1;
}
static void
run_dispatch_loop (int sock)
{
CallState cs;
pid_t pid;
uid_t uid;
unsigned char buf[4];
uint32_t len;
assert (sock != -1);
if (egg_unix_credentials_read (sock, &pid, &uid) < 0) {
gkm_rpc_warn ("couldn't read socket credentials");
return;
}
/* Setup our buffers */
if (!call_init (&cs, uid, pid)) {
gkm_rpc_warn ("out of memory");
return;
}
/* The main thread loop */
while (TRUE) {
call_reset (&cs);
/* Read the number of bytes ... */
if (!read_all (sock, buf, 4))
break;
/* Calculate the number of bytes */
len = egg_buffer_decode_uint32 (buf);
if (len >= 0x0FFFFFFF) {
gkm_rpc_warn ("invalid message size from module: %u bytes", len);
break;
}
/* Allocate memory */
egg_buffer_reserve (&cs.req->buffer, cs.req->buffer.len + len);
if (egg_buffer_has_error (&cs.req->buffer)) {
gkm_rpc_warn ("error allocating buffer for message");
break;
}
/* ... and read/parse in the actual message */
if (!read_all (sock, cs.req->buffer.buf, len))
break;
egg_buffer_add_empty (&cs.req->buffer, len);
if (!gkm_rpc_message_parse (cs.req, GKM_RPC_REQUEST))
break;
/* ... send for processing ... */
if (!dispatch_call (&cs))
break;
/* .. send back response length, and then response data */
egg_buffer_encode_uint32 (buf, cs.resp->buffer.len);
if(!write_all (sock, buf, 4) ||
!write_all (sock, cs.resp->buffer.buf, cs.resp->buffer.len))
break;
}
/*
* Close all sessions for the client application
*
* EXTENSION: In our extended application PKCS#11 model
* C_CloseAllSessions accepts an application identifier as well
* as slot ids. Calling with an application identifier closes all
* sessions for just that application identifier.
*/
pthread_mutex_lock (&clients_mutex);
if (!--cs.client->refcount) {
ClientInstance **cl = &clients;
while (*cl) {
if (*cl == cs.client) {
*cl = cs.client->next;
break;
}
cl = &(*cl)->next;
}
if (cs.client->application.applicationId)
(pkcs11_module->C_CloseAllSessions) (cs.client->application.applicationId);
free (cs.client);
cs.client = NULL;
}
pthread_mutex_unlock (&clients_mutex);
call_uninit (&cs);
}
static void*
run_dispatch_thread (void *arg)
{
int *sock = arg;
assert (*sock != -1);
run_dispatch_loop (*sock);
/* The thread closes the socket and marks as done */
assert (*sock != -1);
close (*sock);
*sock = -1;
return NULL;
}
/* ---------------------------------------------------------------------------
* MAIN THREAD
*/
typedef struct _DispatchState {
struct _DispatchState *next;
GThread *thread;
int socket;
} DispatchState;
/* The main daemon socket that we're listening on */
static int pkcs11_socket = -1;
/* The unix socket path, that we listen on */
static char *pkcs11_socket_path = NULL;
/* A linked list of dispatcher threads */
static DispatchState *pkcs11_dispatchers = NULL;
void
gkm_rpc_layer_accept (void)
{
struct sockaddr_un addr;
DispatchState *ds, **here;
GError *error = NULL;
socklen_t addrlen;
int new_fd;
assert (pkcs11_socket != -1);
/* Cleanup any completed dispatch threads */
for (here = &pkcs11_dispatchers, ds = *here; ds != NULL; ds = *here) {
if (ds->socket == -1) {
g_thread_join (ds->thread);
*here = ds->next;
free (ds);
} else {
here = &ds->next;
}
}
addrlen = sizeof (addr);
new_fd = accept (pkcs11_socket, (struct sockaddr*) &addr, &addrlen);
if (new_fd < 0) {
gkm_rpc_warn ("cannot accept pkcs11 connection: %s", strerror (errno));
return;
}
ds = calloc (1, sizeof (DispatchState));
if (ds == NULL) {
gkm_rpc_warn ("out of memory");
close (new_fd);
return;
}
ds->socket = new_fd;
ds->thread = g_thread_new ("dispatch", run_dispatch_thread, &(ds->socket));
if (!ds->thread) {
gkm_rpc_warn ("couldn't start thread: %s", egg_error_message (error));
close (new_fd);
free (ds);
return;
}
ds->next = pkcs11_dispatchers;
pkcs11_dispatchers = ds;
}
int
gkm_rpc_layer_initialize (CK_FUNCTION_LIST_PTR module)
{
assert (module);
/* cannot be called more than once */
assert (!pkcs11_module);
pkcs11_module = module;
return 1;
}
void
gkm_rpc_layer_uninitialize (void)
{
DispatchState *ds, *next;
if (!pkcs11_module)
return;
/* Close our main listening socket */
if (pkcs11_socket != -1)
close (pkcs11_socket);
pkcs11_socket = -1;
/* Delete our unix socket */
if(pkcs11_socket_path) {
unlink (pkcs11_socket_path);
free (pkcs11_socket_path);
pkcs11_socket_path = NULL;
}
ds = pkcs11_dispatchers;
pkcs11_dispatchers = NULL;
/* Stop all of the dispatch threads */
for (; ds; ds = next) {
next = ds->next;
/* Forcibly shutdown the connection */
if (ds->socket)
shutdown (ds->socket, SHUT_RDWR);
g_thread_join (ds->thread);
/* This is always closed by dispatch thread */
assert (ds->socket == -1);
free (ds);
}
pkcs11_module = NULL;
}
int
gkm_rpc_layer_startup (const char *prefix)
{
struct sockaddr_un addr;
int sock;
#ifdef _DEBUG
GKM_RPC_CHECK_CALLS ();
#endif
assert (prefix);
/* cannot be called more than once */
assert (pkcs11_socket == -1);
assert (pkcs11_dispatchers == NULL);
free (pkcs11_socket_path);
pkcs11_socket_path = malloc (strlen (prefix) + strlen ("/pkcs11") + 1);
if (pkcs11_socket_path == NULL) {
gkm_rpc_warn ("couldn't allocate memory");
return -1;
}
sprintf (pkcs11_socket_path, "%s/pkcs11", prefix);
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
gkm_rpc_warn ("couldn't create pkcs11 socket: %s", strerror (errno));
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
unlink (pkcs11_socket_path);
g_strlcpy (addr.sun_path, pkcs11_socket_path, sizeof (addr.sun_path));
if (bind (sock, (struct sockaddr*)&addr, sizeof (addr)) < 0) {
gkm_rpc_warn ("couldn't bind to pkcs11 socket: %s: %s",
pkcs11_socket_path, strerror (errno));
return -1;
}
if (listen (sock, 128) < 0) {
gkm_rpc_warn ("couldn't listen on pkcs11 socket: %s: %s",
pkcs11_socket_path, strerror (errno));
return -1;
}
pkcs11_socket = sock;
pkcs11_dispatchers = NULL;
return sock;
}
void
gkm_rpc_layer_shutdown (void)
{
DispatchState *ds, *next;
/* Close our main listening socket */
if (pkcs11_socket != -1)
close (pkcs11_socket);
pkcs11_socket = -1;
/* Delete our unix socket */
if(pkcs11_socket_path) {
unlink (pkcs11_socket_path);
free (pkcs11_socket_path);
pkcs11_socket_path = NULL;
}
ds = pkcs11_dispatchers;
pkcs11_dispatchers = NULL;
/* Stop all of the dispatch threads */
for (; ds; ds = next) {
next = ds->next;
/* Forcibly shutdown the connection */
if (ds->socket)
shutdown (ds->socket, SHUT_RDWR);
g_thread_join (ds->thread);
/* This is always closed by dispatch thread */
assert (ds->socket == -1);
free (ds);
}
}