/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* p11-rpc-message.c - our marshalled 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 #ifdef G_DISABLE_ASSERT #define assert(x) #else #include #endif GkmRpcMessage* gkm_rpc_message_new (EggBufferAllocator allocator) { GkmRpcMessage *msg; assert (allocator); msg = (GkmRpcMessage*) (allocator)(NULL, sizeof (GkmRpcMessage)); if (!msg) return NULL; memset (msg, 0, sizeof (*msg)); if (!egg_buffer_init_full (&msg->buffer, 64, allocator)) { (allocator) (msg, 0); /* Frees allocation */ return NULL; } gkm_rpc_message_reset (msg); return msg; } void gkm_rpc_message_free (GkmRpcMessage *msg) { EggBufferAllocator allocator; if (msg) { assert (msg->buffer.allocator); allocator = msg->buffer.allocator; egg_buffer_uninit (&msg->buffer); /* frees data buffer */ (allocator) (msg, 0); } } void gkm_rpc_message_reset (GkmRpcMessage *msg) { assert (msg); msg->call_id = 0; msg->call_type = 0; msg->signature = NULL; msg->sigverify = NULL; msg->parsed = 0; egg_buffer_reset (&msg->buffer); } int gkm_rpc_message_prep (GkmRpcMessage *msg, int call_id, GkmRpcMessageType type) { int len; assert (type); assert (call_id >= GKM_RPC_CALL_ERROR); assert (call_id < GKM_RPC_CALL_MAX); gkm_rpc_message_reset (msg); if (call_id != GKM_RPC_CALL_ERROR) { /* The call id and signature */ if (type == GKM_RPC_REQUEST) msg->signature = gkm_rpc_calls[call_id].request; else if (type == GKM_RPC_RESPONSE) msg->signature = gkm_rpc_calls[call_id].response; else assert (0 && "invalid message type"); assert (msg->signature); msg->sigverify = msg->signature; } msg->call_id = call_id; msg->call_type = type; /* Encode the two of them */ egg_buffer_add_uint32 (&msg->buffer, call_id); if (msg->signature) { len = strlen (msg->signature); egg_buffer_add_byte_array (&msg->buffer, (unsigned char*)msg->signature, len); } msg->parsed = 0; return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_parse (GkmRpcMessage *msg, GkmRpcMessageType type) { const unsigned char *val; size_t len; uint32_t call_id; msg->parsed = 0; /* Pull out the call identifier */ if (!egg_buffer_get_uint32 (&msg->buffer, msg->parsed, &(msg->parsed), &call_id)) { gkm_rpc_warn ("invalid message: couldn't read call identifier"); return 0; } msg->signature = msg->sigverify = NULL; /* If it's an error code then no more processing */ if (call_id == GKM_RPC_CALL_ERROR) { if (type == GKM_RPC_REQUEST) { gkm_rpc_warn ("invalid message: error code in request"); return 0; } return 1; } /* The call id and signature */ if (call_id <= 0 || call_id >= GKM_RPC_CALL_MAX) { gkm_rpc_warn ("invalid message: bad call id: %d", call_id); return 0; } if (type == GKM_RPC_REQUEST) msg->signature = gkm_rpc_calls[call_id].request; else if (type == GKM_RPC_RESPONSE) msg->signature = gkm_rpc_calls[call_id].response; else assert (0 && "invalid message type"); msg->call_id = call_id; msg->call_type = type; msg->sigverify = msg->signature; /* Verify the incoming signature */ if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &(msg->parsed), &val, &len)) { gkm_rpc_warn ("invalid message: couldn't read signature"); return 0; } if ((strlen (msg->signature) != len) || (memcmp (val, msg->signature, len) != 0)) { gkm_rpc_warn ("invalid message: signature doesn't match"); return 0; } return 1; } int gkm_rpc_message_equals (GkmRpcMessage *m1, GkmRpcMessage *m2) { assert (m1 && m2); /* Any errors and messages are never equal */ if (egg_buffer_has_error (&m1->buffer) || egg_buffer_has_error (&m2->buffer)) return 0; /* Calls and signatures must be identical */ if (m1->call_id != m2->call_id) return 0; if (m1->call_type != m2->call_type) return 0; if (m1->signature && m2->signature) { if (strcmp (m1->signature, m2->signature) != 0) return 0; } else if (m1->signature != m2->signature) { return 0; } /* Data in buffer must be identical */ return egg_buffer_equal (&m1->buffer, &m2->buffer); } int gkm_rpc_message_verify_part (GkmRpcMessage *msg, const char* part) { int len, ok; if (!msg->sigverify) return 1; len = strlen (part); ok = (strncmp (msg->sigverify, part, len) == 0); if (ok) msg->sigverify += len; return ok; } int gkm_rpc_message_write_attribute_buffer (GkmRpcMessage *msg, CK_ATTRIBUTE_PTR arr, CK_ULONG num) { CK_ATTRIBUTE_PTR attr; CK_ULONG i; assert (!num || arr); assert (msg); /* Make sure this is in the rigth order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fA")); /* Write the number of items */ egg_buffer_add_uint32 (&msg->buffer, num); for (i = 0; i < num; ++i) { attr = &(arr[i]); /* The attribute type */ egg_buffer_add_uint32 (&msg->buffer, attr->type); /* And the attribute buffer length */ egg_buffer_add_uint32 (&msg->buffer, attr->pValue ? attr->ulValueLen : 0); } return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_write_attribute_array (GkmRpcMessage *msg, CK_ATTRIBUTE_PTR arr, CK_ULONG num) { CK_ULONG i; CK_ATTRIBUTE_PTR attr; unsigned char validity; assert (!num || arr); assert (msg); /* Make sure this is in the rigth order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "aA")); /* Write the number of items */ egg_buffer_add_uint32 (&msg->buffer, num); for (i = 0; i < num; ++i) { attr = &(arr[i]); /* The attribute type */ egg_buffer_add_uint32 (&msg->buffer, attr->type); /* Write out the attribute validity */ validity = (((CK_LONG)attr->ulValueLen) == -1) ? 0 : 1; egg_buffer_add_byte (&msg->buffer, validity); /* The attribute length and value */ if (validity) { egg_buffer_add_uint32 (&msg->buffer, attr->ulValueLen); egg_buffer_add_byte_array (&msg->buffer, attr->pValue, attr->ulValueLen); } } return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_read_byte (GkmRpcMessage *msg, CK_BYTE *val) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "y")); return egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, val); } int gkm_rpc_message_write_byte (GkmRpcMessage *msg, CK_BYTE val) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "y")); return egg_buffer_add_byte (&msg->buffer, val); } int gkm_rpc_message_read_ulong (GkmRpcMessage *msg, CK_ULONG *val) { uint64_t v; assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "u")); if (!egg_buffer_get_uint64 (&msg->buffer, msg->parsed, &msg->parsed, &v)) return 0; if (val) *val = (CK_ULONG)v; return 1; } int gkm_rpc_message_write_ulong (GkmRpcMessage *msg, CK_ULONG val) { assert (msg); /* Make sure this is in the rigth order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "u")); return egg_buffer_add_uint64 (&msg->buffer, val); } int gkm_rpc_message_write_byte_buffer (GkmRpcMessage *msg, CK_ULONG count) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fy")); return egg_buffer_add_uint32 (&msg->buffer, count); } int gkm_rpc_message_write_byte_array (GkmRpcMessage *msg, CK_BYTE_PTR arr, CK_ULONG num) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "ay")); /* No array, no data, just length */ if (!arr) { egg_buffer_add_byte (&msg->buffer, 0); egg_buffer_add_uint32 (&msg->buffer, num); } else { egg_buffer_add_byte (&msg->buffer, 1); egg_buffer_add_byte_array (&msg->buffer, arr, num); } return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_write_ulong_buffer (GkmRpcMessage *msg, CK_ULONG count) { assert (msg); /* Make sure this is in the right order */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "fu")); return egg_buffer_add_uint32 (&msg->buffer, count); } int gkm_rpc_message_write_ulong_array (GkmRpcMessage *msg, CK_ULONG_PTR array, CK_ULONG n_array) { CK_ULONG i; assert (msg); /* Check that we're supposed to have this at this point */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "au")); /* We send a byte which determines whether there's actual data present or not */ egg_buffer_add_byte (&msg->buffer, array ? 1 : 0); egg_buffer_add_uint32 (&msg->buffer, n_array); /* Now send the data if valid */ if (array) { for (i = 0; i < n_array; ++i) egg_buffer_add_uint64 (&msg->buffer, array[i]); } return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_read_version (GkmRpcMessage *msg, CK_VERSION* version) { assert (msg); assert (version); /* Check that we're supposed to have this at this point */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "v")); return egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &version->major) && egg_buffer_get_byte (&msg->buffer, msg->parsed, &msg->parsed, &version->minor); } int gkm_rpc_message_write_version (GkmRpcMessage *msg, CK_VERSION* version) { assert (msg); assert (version); /* Check that we're supposed to have this at this point */ assert (!msg->signature || gkm_rpc_message_verify_part (msg, "v")); egg_buffer_add_byte (&msg->buffer, version->major); egg_buffer_add_byte (&msg->buffer, version->minor); return !egg_buffer_has_error (&msg->buffer); } int gkm_rpc_message_read_space_string (GkmRpcMessage *msg, CK_UTF8CHAR* buffer, CK_ULONG length) { const unsigned char *data; size_t n_data; assert (msg); assert (buffer); assert (length); assert (!msg->signature || gkm_rpc_message_verify_part (msg, "s")); if (!egg_buffer_get_byte_array (&msg->buffer, msg->parsed, &msg->parsed, &data, &n_data)) return 0; if (n_data != length) { gkm_rpc_warn ("invalid length space padded string received: %d != %d", length, n_data); return 0; } memcpy (buffer, data, length); return 1; } int gkm_rpc_message_write_space_string (GkmRpcMessage *msg, CK_UTF8CHAR* buffer, CK_ULONG length) { assert (msg); assert (buffer); assert (length); assert (!msg->signature || gkm_rpc_message_verify_part (msg, "s")); return egg_buffer_add_byte_array (&msg->buffer, buffer, length); } int gkm_rpc_message_write_zero_string (GkmRpcMessage *msg, CK_UTF8CHAR* string) { assert (msg); assert (string); assert (!msg->signature || gkm_rpc_message_verify_part (msg, "z")); return egg_buffer_add_string (&msg->buffer, (const char*)string); }