/* * gnome-keyring * * Copyright (C) 2010 Stefan Walter * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This program 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this program; if not, see * . */ #include "config.h" #include "gkm-wrap-layer.h" #include "gkm-wrap-prompt.h" #include "pkcs11/pkcs11.h" #include "pkcs11/pkcs11i.h" #include #include typedef struct _Mapping { CK_SLOT_ID wrap_slot; CK_SLOT_ID real_slot; CK_FUNCTION_LIST_PTR funcs; } Mapping; typedef struct _Session { gint wrap_session; CK_SESSION_HANDLE real_session; CK_G_APPLICATION_ID app_id; CK_SLOT_ID wrap_slot; CK_OBJECT_HANDLE specific; } Session; G_LOCK_DEFINE_STATIC (wrap_layer); static GList *wrap_modules = NULL; static Mapping *wrap_mappings = NULL; static guint n_wrap_mappings = 0; static GHashTable *wrap_sessions = NULL; static gint last_handle = 16; #define MANUFACTURER_ID "GNOME Keyring " #define LIBRARY_DESCRIPTION "GNOME Keyring Daemon Core " #define LIBRARY_VERSION_MAJOR 1 #define LIBRARY_VERSION_MINOR 1 /* Start wrap slots slightly higher for testing */ #define PLEX_MAPPING_OFFSET 0x10 static CK_RV map_slot_unlocked (CK_SLOT_ID slot, Mapping *mapping) { if (!wrap_mappings) return CKR_CRYPTOKI_NOT_INITIALIZED; if (slot < PLEX_MAPPING_OFFSET) return CKR_SLOT_ID_INVALID; slot -= PLEX_MAPPING_OFFSET; g_assert (mapping); if (slot > n_wrap_mappings) { return CKR_SLOT_ID_INVALID; } else { memcpy (mapping, &wrap_mappings[slot], sizeof (Mapping)); return CKR_OK; } } static CK_RV map_slot_to_real (CK_SLOT_ID_PTR slot, Mapping *mapping) { CK_RV rv; g_assert (mapping); G_LOCK (wrap_layer); rv = map_slot_unlocked (*slot, mapping); if (rv == CKR_OK) *slot = mapping->real_slot; G_UNLOCK (wrap_layer); return rv; } static CK_RV map_session_to_real (CK_SESSION_HANDLE_PTR handle, Mapping *mapping, Session *session) { CK_RV rv = CKR_OK; Session *sess; g_assert (handle); g_assert (mapping); G_LOCK (wrap_layer); if (!wrap_sessions) { rv = CKR_CRYPTOKI_NOT_INITIALIZED; } else { sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)*handle)); if (sess != NULL) { *handle = sess->real_session; rv = map_slot_unlocked (sess->wrap_slot, mapping); if (session != NULL) memcpy (session, sess, sizeof (Session)); } else { rv = CKR_SESSION_HANDLE_INVALID; } } G_UNLOCK (wrap_layer); return rv; } static void lookup_session_specific (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE_PTR key) { Session *sess; g_assert (key); *key = 0; G_LOCK (wrap_layer); if (wrap_sessions) { sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)handle)); if (sess == NULL) g_warning ("sessions out of sync with lower layer"); else *key = sess->specific; } G_UNLOCK (wrap_layer); } static void store_session_specific (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE key) { Session *sess; G_LOCK (wrap_layer); if (wrap_sessions) { sess = g_hash_table_lookup (wrap_sessions, GINT_TO_POINTER ((gint)handle)); if (sess == NULL) g_warning ("sessions out of sync with lower layer"); else sess->specific = key; } G_UNLOCK (wrap_layer); } static CK_RV wrap_C_Initialize (CK_VOID_PTR init_args) { CK_FUNCTION_LIST_PTR funcs; GArray *mappings = NULL; CK_SLOT_ID_PTR slots; Mapping mapping; CK_ULONG i, count; CK_RV rv = CKR_OK; GList *l; mappings = g_array_new (FALSE, TRUE, sizeof (Mapping)); G_LOCK (wrap_layer); if (wrap_mappings) rv = CKR_CRYPTOKI_ALREADY_INITIALIZED; for (l = wrap_modules; rv == CKR_OK && l != NULL; l = g_list_next (l)) { funcs = l->data; /* Initialize each module */ rv = (funcs->C_Initialize) (init_args); if (rv == CKR_CRYPTOKI_ALREADY_INITIALIZED) rv = CKR_OK; if (rv != CKR_OK) break; /* And then ask it for its slots */ rv = (funcs->C_GetSlotList) (FALSE, NULL, &count); if (rv != CKR_OK) break; if (!count) continue; slots = g_new0 (CK_SLOT_ID, count); rv = (funcs->C_GetSlotList) (FALSE, slots, &count); if (rv != CKR_OK) { g_free (slots); break; } /* And now add a mapping for each of those slots */ for (i = 0; i < count; ++i) { memset (&mapping, 0, sizeof (mapping)); mapping.wrap_slot = mappings->len + PLEX_MAPPING_OFFSET; mapping.real_slot = slots[i]; mapping.funcs = funcs; g_array_append_val (mappings, mapping); } g_free (slots); } /* If failed, then finalize all the ones that succeeded */ if (rv != CKR_OK && l != NULL) { for (l = g_list_previous (l); l; l = g_list_previous (l)) { funcs = l->data; (funcs->C_Finalize) (NULL); } } /* If succeeded then swap in mappings */ if (rv == CKR_OK) { g_assert (!wrap_mappings); n_wrap_mappings = mappings->len; wrap_mappings = (Mapping*)g_array_free (mappings, FALSE); mappings = NULL; wrap_sessions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); } G_UNLOCK (wrap_layer); /* If failed or somehow unused then free */ if (mappings) g_array_free (mappings, TRUE); return rv; } static CK_RV wrap_C_Finalize (CK_VOID_PTR reserved) { CK_FUNCTION_LIST_PTR funcs; GList *l; G_LOCK (wrap_layer); for (l = wrap_modules; l != NULL; l = g_list_next (l)) { funcs = l->data; (funcs->C_Finalize) (NULL); } g_free (wrap_mappings); wrap_mappings = NULL; g_hash_table_destroy (wrap_sessions); wrap_sessions = NULL; G_UNLOCK (wrap_layer); return CKR_OK; } static CK_RV wrap_C_GetInfo (CK_INFO_PTR info) { if (info == NULL) return CKR_ARGUMENTS_BAD; info->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR; info->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR; info->libraryVersion.major = LIBRARY_VERSION_MAJOR; info->libraryVersion.minor = LIBRARY_VERSION_MINOR; info->flags = 0; memcpy ((char*)info->manufacturerID, MANUFACTURER_ID, 32); memcpy ((char*)info->libraryDescription, LIBRARY_DESCRIPTION, 32); return CKR_OK; } static CK_RV wrap_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list) { if (!list) return CKR_ARGUMENTS_BAD; *list = gkm_wrap_layer_get_functions_no_prompts (); return CKR_OK; } static CK_RV auth_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list) { if (!list) return CKR_ARGUMENTS_BAD; *list = gkm_wrap_layer_get_functions (); return CKR_OK; } static CK_RV wrap_C_GetSlotList (CK_BBOOL token_present, CK_SLOT_ID_PTR slot_list, CK_ULONG_PTR count) { CK_SLOT_INFO info; Mapping *mapping; CK_ULONG index; CK_RV rv; guint i; if (!count) return CKR_ARGUMENTS_BAD; G_LOCK (wrap_layer); rv = CKR_OK; index = 0; /* Go through and build up a map */ for (i = 0; i < n_wrap_mappings; ++i) { mapping = &wrap_mappings[i]; /* Skip ones without a token if requested */ if (token_present) { rv = (mapping->funcs->C_GetSlotInfo) (mapping->real_slot, &info); if (rv != CKR_OK) break; if (!(info.flags & CKF_TOKEN_PRESENT)) continue; } /* Fill in the slot if we can */ if (slot_list && *count > index) slot_list[index] = mapping->wrap_slot; ++index; } if (slot_list && *count < index) rv = CKR_BUFFER_TOO_SMALL; *count = index; G_UNLOCK (wrap_layer); return rv; } static CK_RV wrap_C_GetSlotInfo (CK_SLOT_ID id, CK_SLOT_INFO_PTR info) { Mapping map; CK_RV rv; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; return (map.funcs->C_GetSlotInfo) (id, info); } static CK_RV wrap_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info) { Mapping map; CK_RV rv; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; return (map.funcs->C_GetTokenInfo) (id, info); } static CK_RV auth_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info) { CK_RV rv = wrap_C_GetTokenInfo (id, info); if (rv == CKR_OK) info->flags |= CKF_PROTECTED_AUTHENTICATION_PATH; return rv; } static CK_RV wrap_C_GetMechanismList (CK_SLOT_ID id, CK_MECHANISM_TYPE_PTR mechanism_list, CK_ULONG_PTR count) { Mapping map; CK_RV rv; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; return (map.funcs->C_GetMechanismList) (id, mechanism_list, count); } static CK_RV wrap_C_GetMechanismInfo (CK_SLOT_ID id, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR info) { Mapping map; CK_RV rv; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; return (map.funcs->C_GetMechanismInfo) (id, type, info); } static CK_RV wrap_C_InitToken (CK_SLOT_ID id, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len, CK_UTF8CHAR_PTR label) { Mapping map; CK_RV rv; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; return (map.funcs->C_InitToken) (id, pin, pin_len, label); } static CK_RV wrap_C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID_PTR slot, CK_VOID_PTR reserved) { /* TODO: We could implement this by polling, esp. the nonblock case. */ return CKR_NO_EVENT; } static CK_RV wrap_C_OpenSession (CK_SLOT_ID id, CK_FLAGS flags, CK_VOID_PTR user_data, CK_NOTIFY callback, CK_SESSION_HANDLE_PTR handle) { Session *sess; Mapping map; CK_RV rv; if (handle == NULL) return CKR_ARGUMENTS_BAD; rv = map_slot_to_real (&id, &map); if (rv != CKR_OK) return rv; rv = (map.funcs->C_OpenSession) (id, flags, user_data, callback, handle); if (rv == CKR_OK) { G_LOCK (wrap_layer); sess = g_new (Session, 1); if (flags & CKF_G_APPLICATION_SESSION) sess->app_id = ((CK_G_APPLICATION_PTR)user_data)->applicationId; sess->wrap_slot = map.wrap_slot; sess->real_session = *handle; sess->wrap_session = ++last_handle; /* TODO: Handle wrapping, and then collisions */ g_hash_table_replace (wrap_sessions, GINT_TO_POINTER (sess->wrap_session), sess); *handle = (CK_ULONG)sess->wrap_session; G_UNLOCK (wrap_layer); } return rv; } static CK_RV wrap_C_CloseSession (CK_SESSION_HANDLE handle) { gint key = (gint)handle; Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; rv = (map.funcs->C_CloseSession) (handle); if (rv == CKR_OK) { G_LOCK (wrap_layer); g_hash_table_remove (wrap_sessions, GINT_TO_POINTER (key)); G_UNLOCK (wrap_layer); } return rv; } static CK_RV wrap_C_CloseAllSessions (CK_SLOT_ID id) { GHashTableIter iter; CK_SESSION_HANDLE handle; gpointer key, value; Session *sess; GArray *to_close; gint i; to_close = g_array_new (FALSE, FALSE, sizeof (CK_SESSION_HANDLE)); G_LOCK (wrap_layer); g_hash_table_iter_init (&iter, wrap_sessions); while (g_hash_table_iter_next (&iter, &key, &value)) { sess = value; if ((sess->app_id | sess->wrap_slot) == id) { handle = (CK_SESSION_HANDLE)sess->wrap_session; g_array_append_val (to_close, handle); } } G_UNLOCK (wrap_layer); for (i = 0; i < to_close->len; ++i) wrap_C_CloseSession (g_array_index (to_close, CK_SESSION_HANDLE, i)); g_array_free (to_close, TRUE); return CKR_OK; } static CK_RV wrap_C_GetFunctionStatus (CK_SESSION_HANDLE handle) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GetFunctionStatus) (handle); } static CK_RV wrap_C_CancelFunction (CK_SESSION_HANDLE handle) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_CancelFunction) (handle); } static CK_RV wrap_C_GetSessionInfo (CK_SESSION_HANDLE handle, CK_SESSION_INFO_PTR info) { Mapping map; CK_RV rv; if (info == NULL) return CKR_ARGUMENTS_BAD; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; rv = (map.funcs->C_GetSessionInfo) (handle, info); if (rv == CKR_OK) info->slotID = map.wrap_slot; return rv; } static CK_RV wrap_C_InitPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_InitPIN) (handle, pin, pin_len); } static CK_RV auth_C_InitPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) { GkmWrapPrompt *prompt; CK_RV rv = CKR_OK; prompt = gkm_wrap_prompt_for_init_pin (gkm_wrap_layer_get_functions_no_prompts(), handle, pin, pin_len); for (;;) { if (prompt && !gkm_wrap_prompt_do_init_pin (prompt, rv, &pin, &pin_len)) break; rv = wrap_C_InitPIN (handle, pin, pin_len); if (!prompt || rv != CKR_PIN_INVALID || rv != CKR_PIN_LEN_RANGE) break; } if (prompt) { gkm_wrap_prompt_done_init_pin (prompt, rv); g_object_unref (prompt); } return rv; } static CK_RV wrap_C_SetPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SetPIN) (handle, old_pin, old_pin_len, new_pin, new_pin_len); } static CK_RV auth_C_SetPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len) { GkmWrapPrompt *prompt; CK_RV rv = CKR_OK; prompt = gkm_wrap_prompt_for_set_pin (gkm_wrap_layer_get_functions_no_prompts(), handle, old_pin, old_pin_len, new_pin, new_pin_len); for (;;) { if (prompt && !gkm_wrap_prompt_do_set_pin (prompt, rv, &old_pin, &old_pin_len, &new_pin, &new_pin_len)) break; rv = wrap_C_SetPIN (handle, old_pin, old_pin_len, new_pin, new_pin_len); if (!prompt || rv != CKR_PIN_INCORRECT || rv != CKR_PIN_INVALID || rv != CKR_PIN_LEN_RANGE) break; } if (prompt) { gkm_wrap_prompt_done_set_pin (prompt, rv); g_object_unref (prompt); } return rv; } static CK_RV wrap_C_GetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state, CK_ULONG_PTR operation_state_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GetOperationState) (handle, operation_state, operation_state_len); } static CK_RV wrap_C_SetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state, CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key, CK_OBJECT_HANDLE authentication_key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SetOperationState) (handle, operation_state, operation_state_len, encryption_key, authentication_key); } static CK_RV wrap_C_Login (CK_SESSION_HANDLE handle, CK_USER_TYPE user_type, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Login) (handle, user_type, pin, pin_len); } static CK_RV auth_C_Login (CK_SESSION_HANDLE handle, CK_USER_TYPE user_type, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) { GkmWrapPrompt *prompt; CK_OBJECT_HANDLE specific; CK_RV rv; lookup_session_specific (handle, &specific); prompt = gkm_wrap_prompt_for_login (gkm_wrap_layer_get_functions_no_prompts(), user_type, handle, specific, pin, pin_len); for (;;) { rv = wrap_C_Login (handle, user_type, pin, pin_len); if (!prompt || rv != CKR_PIN_INCORRECT) break; if (!gkm_wrap_prompt_do_login (prompt, user_type, rv, &pin, &pin_len)) break; } if (prompt) { gkm_wrap_prompt_done_login (prompt, user_type, rv); g_object_unref (prompt); } return rv; } static CK_RV wrap_C_Logout (CK_SESSION_HANDLE handle) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Logout) (handle); } static CK_RV wrap_C_CreateObject (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_CreateObject) (handle, template, count, new_object); } static CK_RV auth_C_CreateObject (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object) { GkmWrapPrompt *prompt = NULL; CK_RV rv; for (;;) { rv = wrap_C_CreateObject (handle, template, count, new_object); if (rv != CKR_PIN_INCORRECT) break; if (!prompt) { prompt = gkm_wrap_prompt_for_credential (gkm_wrap_layer_get_functions_no_prompts(), handle, template, count); if (prompt == NULL) break; } if (!gkm_wrap_prompt_do_credential (prompt, &template, &count)) break; } if (prompt) { gkm_wrap_prompt_done_credential (prompt, rv); g_object_unref (prompt); } return rv; } static CK_RV wrap_C_CopyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_CopyObject) (handle, object, template, count, new_object); } static CK_RV wrap_C_DestroyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DestroyObject) (handle, object); } static CK_RV wrap_C_GetObjectSize (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object, CK_ULONG_PTR size) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GetObjectSize) (handle, object, size); } static CK_RV wrap_C_GetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GetAttributeValue) (handle, object, template, count); } static CK_RV wrap_C_SetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR template, CK_ULONG count) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SetAttributeValue) (handle, object, template, count); } static CK_RV wrap_C_FindObjectsInit (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template, CK_ULONG count) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_FindObjectsInit) (handle, template, count); } static CK_RV wrap_C_FindObjects (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE_PTR objects, CK_ULONG max_count, CK_ULONG_PTR count) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_FindObjects) (handle, objects, max_count, count); } static CK_RV wrap_C_FindObjectsFinal (CK_SESSION_HANDLE handle) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_FindObjectsFinal) (handle); } static CK_RV wrap_C_EncryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_EncryptInit) (handle, mechanism, key); } static CK_RV auth_C_EncryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_EncryptInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_Encrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Encrypt) (handle, data, data_len, encrypted_data, encrypted_data_len); } static CK_RV wrap_C_EncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR encrypted_part, CK_ULONG_PTR encrypted_part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_EncryptUpdate) (handle, part, part_len, encrypted_part, encrypted_part_len); } static CK_RV wrap_C_EncryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part, CK_ULONG_PTR last_part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_EncryptFinal) (handle, last_part, last_part_len); } static CK_RV wrap_C_DecryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DecryptInit) (handle, mechanism, key); } static CK_RV auth_C_DecryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_DecryptInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_Decrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_data, CK_ULONG enc_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Decrypt) (handle, enc_data, enc_data_len, data, data_len); } static CK_RV wrap_C_DecryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DecryptUpdate) (handle, enc_part, enc_part_len, part, part_len); } static CK_RV wrap_C_DecryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part, CK_ULONG_PTR last_part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DecryptFinal) (handle, last_part, last_part_len); } static CK_RV wrap_C_DigestInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DigestInit) (handle, mechanism); } static CK_RV wrap_C_Digest (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Digest) (handle, data, data_len, digest, digest_len); } static CK_RV wrap_C_DigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DigestUpdate) (handle, part, part_len); } static CK_RV wrap_C_DigestKey (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DigestKey) (handle, key); } static CK_RV wrap_C_DigestFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DigestFinal) (handle, digest, digest_len); } static CK_RV wrap_C_SignInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignInit) (handle, mechanism, key); } static CK_RV auth_C_SignInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_SignInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_Sign (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Sign) (handle, data, data_len, signature, signature_len); } static CK_RV wrap_C_SignUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignUpdate) (handle, part, part_len); } static CK_RV wrap_C_SignFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignFinal) (handle, signature, signature_len); } static CK_RV wrap_C_SignRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignRecoverInit) (handle, mechanism, key); } static CK_RV auth_C_SignRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_SignRecoverInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_SignRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignRecover) (handle, data, data_len, signature, signature_len); } static CK_RV wrap_C_VerifyInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_VerifyInit) (handle, mechanism, key); } static CK_RV auth_C_VerifyInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_VerifyInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_Verify (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG signature_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_Verify) (handle, data, data_len, signature, signature_len); } static CK_RV wrap_C_VerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_VerifyUpdate) (handle, part, part_len); } static CK_RV wrap_C_VerifyFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature, CK_ULONG signature_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_VerifyFinal) (handle, signature, signature_len); } static CK_RV wrap_C_VerifyRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_VerifyRecoverInit) (handle, mechanism, key); } static CK_RV auth_C_VerifyRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE key) { CK_RV rv = wrap_C_VerifyInit (handle, mechanism, key); if (rv == CKR_OK) store_session_specific (handle, key); return rv; } static CK_RV wrap_C_VerifyRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature, CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_VerifyRecover) (handle, signature, signature_len, data, data_len); } static CK_RV wrap_C_DigestEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR enc_part, CK_ULONG_PTR enc_part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DigestEncryptUpdate) (handle, part, part_len, enc_part, enc_part_len); } static CK_RV wrap_C_DecryptDigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DecryptDigestUpdate) (handle, enc_part, enc_part_len, part, part_len); } static CK_RV wrap_C_SignEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR enc_part, CK_ULONG_PTR enc_part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SignEncryptUpdate) (handle, part, part_len, enc_part, enc_part_len); } static CK_RV wrap_C_DecryptVerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part, CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DecryptVerifyUpdate) (handle, enc_part, enc_part_len, part, part_len); } static CK_RV wrap_C_GenerateKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GenerateKey) (handle, mechanism, template, count, key); } static CK_RV wrap_C_GenerateKeyPair (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_ATTRIBUTE_PTR pub_template, CK_ULONG pub_count, CK_ATTRIBUTE_PTR priv_template, CK_ULONG priv_count, CK_OBJECT_HANDLE_PTR pub_key, CK_OBJECT_HANDLE_PTR priv_key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GenerateKeyPair) (handle, mechanism, pub_template, pub_count, priv_template, priv_count, pub_key, priv_key); } static CK_RV wrap_C_WrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key, CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_WrapKey) (handle, mechanism, wrapping_key, key, wrapped_key, wrapped_key_len); } static CK_RV wrap_C_UnwrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key, CK_ULONG wrapped_key_len, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_UnwrapKey) (handle, mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, count, key); } static CK_RV wrap_C_DeriveKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism, CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE_PTR template, CK_ULONG count, CK_OBJECT_HANDLE_PTR key) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_DeriveKey) (handle, mechanism, base_key, template, count, key); } static CK_RV wrap_C_SeedRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR seed, CK_ULONG seed_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_SeedRandom) (handle, seed, seed_len); } static CK_RV wrap_C_GenerateRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR random_data, CK_ULONG random_len) { Mapping map; CK_RV rv; rv = map_session_to_real (&handle, &map, NULL); if (rv != CKR_OK) return rv; return (map.funcs->C_GenerateRandom) (handle, random_data, random_len); } /* -------------------------------------------------------------------- * MODULE ENTRY POINT */ static CK_FUNCTION_LIST wrap_function_list = { { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */ wrap_C_Initialize, wrap_C_Finalize, wrap_C_GetInfo, wrap_C_GetFunctionList, wrap_C_GetSlotList, wrap_C_GetSlotInfo, wrap_C_GetTokenInfo, wrap_C_GetMechanismList, wrap_C_GetMechanismInfo, wrap_C_InitToken, wrap_C_InitPIN, wrap_C_SetPIN, wrap_C_OpenSession, wrap_C_CloseSession, wrap_C_CloseAllSessions, wrap_C_GetSessionInfo, wrap_C_GetOperationState, wrap_C_SetOperationState, wrap_C_Login, wrap_C_Logout, wrap_C_CreateObject, wrap_C_CopyObject, wrap_C_DestroyObject, wrap_C_GetObjectSize, wrap_C_GetAttributeValue, wrap_C_SetAttributeValue, wrap_C_FindObjectsInit, wrap_C_FindObjects, wrap_C_FindObjectsFinal, wrap_C_EncryptInit, wrap_C_Encrypt, wrap_C_EncryptUpdate, wrap_C_EncryptFinal, wrap_C_DecryptInit, wrap_C_Decrypt, wrap_C_DecryptUpdate, wrap_C_DecryptFinal, wrap_C_DigestInit, wrap_C_Digest, wrap_C_DigestUpdate, wrap_C_DigestKey, wrap_C_DigestFinal, wrap_C_SignInit, wrap_C_Sign, wrap_C_SignUpdate, wrap_C_SignFinal, wrap_C_SignRecoverInit, wrap_C_SignRecover, wrap_C_VerifyInit, wrap_C_Verify, wrap_C_VerifyUpdate, wrap_C_VerifyFinal, wrap_C_VerifyRecoverInit, wrap_C_VerifyRecover, wrap_C_DigestEncryptUpdate, wrap_C_DecryptDigestUpdate, wrap_C_SignEncryptUpdate, wrap_C_DecryptVerifyUpdate, wrap_C_GenerateKey, wrap_C_GenerateKeyPair, wrap_C_WrapKey, wrap_C_UnwrapKey, wrap_C_DeriveKey, wrap_C_SeedRandom, wrap_C_GenerateRandom, wrap_C_GetFunctionStatus, wrap_C_CancelFunction, wrap_C_WaitForSlotEvent }; static CK_FUNCTION_LIST auth_function_list = { { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */ wrap_C_Initialize, wrap_C_Finalize, wrap_C_GetInfo, auth_C_GetFunctionList, wrap_C_GetSlotList, wrap_C_GetSlotInfo, auth_C_GetTokenInfo, wrap_C_GetMechanismList, wrap_C_GetMechanismInfo, wrap_C_InitToken, auth_C_InitPIN, auth_C_SetPIN, wrap_C_OpenSession, wrap_C_CloseSession, wrap_C_CloseAllSessions, wrap_C_GetSessionInfo, wrap_C_GetOperationState, wrap_C_SetOperationState, auth_C_Login, wrap_C_Logout, auth_C_CreateObject, wrap_C_CopyObject, wrap_C_DestroyObject, wrap_C_GetObjectSize, wrap_C_GetAttributeValue, wrap_C_SetAttributeValue, wrap_C_FindObjectsInit, wrap_C_FindObjects, wrap_C_FindObjectsFinal, auth_C_EncryptInit, wrap_C_Encrypt, wrap_C_EncryptUpdate, wrap_C_EncryptFinal, auth_C_DecryptInit, wrap_C_Decrypt, wrap_C_DecryptUpdate, wrap_C_DecryptFinal, wrap_C_DigestInit, wrap_C_Digest, wrap_C_DigestUpdate, wrap_C_DigestKey, wrap_C_DigestFinal, auth_C_SignInit, wrap_C_Sign, wrap_C_SignUpdate, wrap_C_SignFinal, auth_C_SignRecoverInit, wrap_C_SignRecover, auth_C_VerifyInit, wrap_C_Verify, wrap_C_VerifyUpdate, wrap_C_VerifyFinal, auth_C_VerifyRecoverInit, wrap_C_VerifyRecover, wrap_C_DigestEncryptUpdate, wrap_C_DecryptDigestUpdate, wrap_C_SignEncryptUpdate, wrap_C_DecryptVerifyUpdate, wrap_C_GenerateKey, wrap_C_GenerateKeyPair, wrap_C_WrapKey, wrap_C_UnwrapKey, wrap_C_DeriveKey, wrap_C_SeedRandom, wrap_C_GenerateRandom, wrap_C_GetFunctionStatus, wrap_C_CancelFunction, wrap_C_WaitForSlotEvent }; /* ----------------------------------------------------------------------------------------- * PUBLIC FUNCTIONS */ CK_FUNCTION_LIST_PTR gkm_wrap_layer_get_functions (void) { return &auth_function_list; } CK_FUNCTION_LIST_PTR gkm_wrap_layer_get_functions_no_prompts (void) { return &wrap_function_list; } void gkm_wrap_layer_reset_modules (void) { G_LOCK (wrap_layer); g_assert (!wrap_mappings); g_assert (!wrap_sessions); g_list_free (wrap_modules); wrap_modules = NULL; G_UNLOCK (wrap_layer); } void gkm_wrap_layer_add_module (CK_FUNCTION_LIST_PTR funcs) { g_assert (funcs); G_LOCK (wrap_layer); g_assert (!wrap_mappings); g_assert (!wrap_sessions); wrap_modules = g_list_append (wrap_modules, funcs); G_UNLOCK (wrap_layer); }