/* * 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-xdg-assertion.h" #include "gkm-xdg-trust.h" #include "egg/egg-asn1x.h" #include "egg/egg-asn1-defs.h" #include "gkm/gkm-assertion.h" #include "gkm/gkm-attributes.h" #define DEBUG_FLAG GKM_DEBUG_OBJECT #include "gkm/gkm-debug.h" #include "gkm/gkm-object.h" #include "gkm/gkm-oids.h" #include "gkm/gkm-serializable.h" #include "gkm/gkm-session.h" #include "gkm/gkm-transaction.h" #include "gkm/gkm-util.h" #include "pkcs11/pkcs11i.h" #include "pkcs11/pkcs11n.h" #include "pkcs11/pkcs11x.h" #include extern const struct _EggAsn1xDef xdg_asn1_tab[]; struct _GkmXdgTrustPrivate { GHashTable *assertions; GNode *asn; GBytes *bytes; }; static void gkm_xdg_trust_serializable (GkmSerializableIface *iface); G_DEFINE_TYPE_EXTENDED (GkmXdgTrust, gkm_xdg_trust, GKM_TYPE_TRUST, 0, G_IMPLEMENT_INTERFACE (GKM_TYPE_SERIALIZABLE, gkm_xdg_trust_serializable) G_ADD_PRIVATE (GkmXdgTrust)); static GQuark QDATA_ASSERTION_KEY = 0; /* Forward declarations */ static void add_assertion_to_trust (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction); static void remove_assertion_from_trust (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction); /* ----------------------------------------------------------------------------- * QUARKS */ static GQuark TRUST_UNKNOWN; static GQuark TRUST_DISTRUSTED; static GQuark TRUST_TRUSTED; static GQuark TRUST_TRUSTED_ANCHOR; static void init_quarks (void) { static gsize quarks_inited = 0; if (g_once_init_enter (&quarks_inited)) { #define QUARK(name, value) \ name = g_quark_from_static_string(value) QUARK (TRUST_UNKNOWN, "trustUnknown"); QUARK (TRUST_DISTRUSTED, "distrusted"); QUARK (TRUST_TRUSTED, "trusted"); QUARK (TRUST_TRUSTED_ANCHOR, "trustedAnchor"); #undef QUARK g_once_init_leave (&quarks_inited, 1); } } /* ----------------------------------------------------------------------------- * INTERNAL */ static CK_RV trust_get_der (GkmXdgTrust *self, const gchar *part, CK_ATTRIBUTE_PTR attr) { GNode *node; GBytes *element; CK_RV rv; g_assert (GKM_XDG_IS_TRUST (self)); node = egg_asn1x_node (self->pv->asn, "reference", "certReference", part, NULL); g_return_val_if_fail (node, CKR_GENERAL_ERROR); /* If the assertion doesn't contain this info ... */ if (!egg_asn1x_have (node)) { gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: %s wants %s which is not part of assertion", gkm_log_attr_type (attr->type), part); return CKR_ATTRIBUTE_TYPE_INVALID; } element = egg_asn1x_get_element_raw (node); rv = gkm_attribute_set_bytes (attr, element); g_bytes_unref (element); return rv; } static CK_RV trust_get_integer (GkmXdgTrust *self, const gchar *part, CK_ATTRIBUTE_PTR attr) { GNode *node; GBytes *integer; CK_RV rv; g_assert (GKM_XDG_IS_TRUST (self)); node = egg_asn1x_node (self->pv->asn, "reference", "certReference", part, NULL); g_return_val_if_fail (node, CKR_GENERAL_ERROR); /* If the assertion doesn't contain this info ... */ if (!egg_asn1x_have (node)) { gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: %s wants %s which is not part of assertion", gkm_log_attr_type (attr->type), part); return CKR_ATTRIBUTE_TYPE_INVALID; } integer = egg_asn1x_get_integer_as_raw (node); g_return_val_if_fail (integer, CKR_GENERAL_ERROR); rv = gkm_attribute_set_bytes (attr, integer); g_bytes_unref (integer); return rv; } static CK_RV trust_get_hash (GkmXdgTrust *self, GChecksumType ctype, CK_ATTRIBUTE_PTR attr) { GNode *cert; GBytes *element; CK_RV rv; cert = egg_asn1x_node (self->pv->asn, "reference", "certComplete", NULL); g_return_val_if_fail (cert, CKR_GENERAL_ERROR); /* If it's not stored, then this attribute is not present */ if (!egg_asn1x_have (cert)) { gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: %s wants certComplete which is not part of assertion", gkm_log_attr_type (attr->type)); return CKR_ATTRIBUTE_TYPE_INVALID; } element = egg_asn1x_get_element_raw (cert); g_return_val_if_fail (element != NULL, CKR_GENERAL_ERROR); rv = gkm_attribute_set_checksum (attr, ctype, g_bytes_get_data (element, NULL), g_bytes_get_size (element)); g_bytes_unref (element); return rv; } static CK_RV trust_get_complete (GkmXdgTrust *self, CK_ATTRIBUTE_PTR attr) { GNode *cert; GBytes *element; CK_RV rv; cert = egg_asn1x_node (self->pv->asn, "reference", "certComplete", NULL); g_return_val_if_fail (cert, CKR_GENERAL_ERROR); /* If it's not stored, then this attribute is not present */ if (!egg_asn1x_have (cert)) { gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: %s wants certComplete which is not part of assertion", gkm_log_attr_type (attr->type)); return CKR_ATTRIBUTE_TYPE_INVALID; } element = egg_asn1x_get_element_raw (cert); g_return_val_if_fail (element != NULL, CKR_GENERAL_ERROR); rv = gkm_attribute_set_bytes (attr, element); g_bytes_unref (element); return rv; } static gboolean validate_der (CK_ATTRIBUTE_PTR attr, const gchar *asn_type) { GNode *asn; gboolean valid = TRUE; GBytes *data; if (!attr->pValue || attr->ulValueLen == (CK_ULONG)-1) return FALSE; asn = egg_asn1x_create (pkix_asn1_tab, asn_type); g_return_val_if_fail (asn, FALSE); data = g_bytes_new_static (attr->pValue, attr->ulValueLen); valid = egg_asn1x_decode (asn, data); g_bytes_unref (data); if (!valid) g_message ("failed to parse certificate passed to trust assertion: %s", egg_asn1x_message (asn)); /* Yes, this is an expensive check, but worthwhile */ egg_asn1x_destroy (asn); return valid; } static gboolean validate_integer (CK_ATTRIBUTE_PTR attr) { return attr->pValue != NULL && attr->ulValueLen > 0 && attr->ulValueLen != (CK_ULONG)-1; } static GQuark assertion_type_to_level_enum (CK_X_ASSERTION_TYPE type) { switch (type) { case CKT_X_DISTRUSTED_CERTIFICATE: return TRUST_DISTRUSTED; case CKT_X_ANCHORED_CERTIFICATE: return TRUST_TRUSTED_ANCHOR; case CKT_X_PINNED_CERTIFICATE: return TRUST_TRUSTED; default: return 0; }; } static gboolean level_enum_to_assertion_type (GQuark level, CK_X_ASSERTION_TYPE *type) { if (level == TRUST_DISTRUSTED) *type = CKT_X_DISTRUSTED_CERTIFICATE; else if (level == TRUST_TRUSTED_ANCHOR) *type = CKT_X_ANCHORED_CERTIFICATE; else if (level == TRUST_TRUSTED) *type = CKT_X_PINNED_CERTIFICATE; else if (level == TRUST_UNKNOWN) *type = 0; else return FALSE; return TRUE; } static void check_and_unref_assertion (gpointer data) { g_assert (GKM_IS_ASSERTION (data)); g_assert (g_object_get_qdata (data, QDATA_ASSERTION_KEY) != NULL); g_object_run_dispose (data); g_object_unref (data); } static GHashTable* create_assertions (void) { return g_hash_table_new_full (g_bytes_hash, g_bytes_equal, (GDestroyNotify)g_bytes_unref, check_and_unref_assertion); } static GkmAssertion* create_assertion (GkmXdgTrust *self, GNode *asn) { CK_X_ASSERTION_TYPE type = 0; GkmAssertion *assertion; GQuark level; gchar *purpose; gchar *peer; GNode *node; /* Get the trust level */ level = egg_asn1x_get_enumerated (egg_asn1x_node (asn, "level", NULL)); g_return_val_if_fail (level != 0, NULL); if (!level_enum_to_assertion_type (level, &type)) g_message ("unsupported trust level %s in trust object", g_quark_to_string (level)); else if (type == 0) return NULL; /* A purpose */ purpose = egg_asn1x_get_string_as_utf8 (egg_asn1x_node (asn, "purpose", NULL), NULL); g_return_val_if_fail (purpose, NULL); /* A peer name */ node = egg_asn1x_node (asn, "peer", NULL); if (egg_asn1x_have (node)) peer = egg_asn1x_get_string_as_utf8 (node, NULL); else peer = NULL; assertion = g_object_new (GKM_XDG_TYPE_ASSERTION, "module", gkm_object_get_module (GKM_OBJECT (self)), "manager", gkm_object_get_manager (GKM_OBJECT (self)), "trust", self, "type", type, "purpose", purpose, "peer", peer, NULL); g_free (purpose); g_free (peer); return assertion; } static GBytes * create_assertion_key (const gchar *purpose, const gchar *peer) { GString *string; gsize len; g_return_val_if_fail (purpose, NULL); string = g_string_sized_new (32); g_string_append (string, purpose); if (peer != NULL) { g_string_append_len (string, "\0", 1); g_string_append (string, peer); } len = string->len; return g_bytes_new_take (g_string_free (string, FALSE), len); } static GBytes * lookup_assertion_key (GkmAssertion *assertion) { return g_object_get_qdata (G_OBJECT (assertion), QDATA_ASSERTION_KEY); } static GBytes * lookup_or_create_assertion_key (GkmAssertion *assertion) { GBytes *key; key = lookup_assertion_key (assertion); if (key == NULL) { key = create_assertion_key (gkm_assertion_get_purpose (assertion), gkm_assertion_get_peer (assertion)); g_object_set_qdata_full (G_OBJECT (assertion), QDATA_ASSERTION_KEY, key, (GDestroyNotify)g_bytes_unref); } return key; } static gboolean complete_add_assertion (GkmTransaction *transaction, GObject *object, gpointer user_data) { GkmAssertion *assertion = GKM_ASSERTION (user_data); GkmXdgTrust *self = GKM_XDG_TRUST (object); if (gkm_transaction_get_failed (transaction)) remove_assertion_from_trust (self, assertion, NULL); g_object_unref (assertion); return TRUE; } static void add_assertion_to_trust (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction) { GBytes *key; key = lookup_or_create_assertion_key (assertion); g_assert (key != NULL); g_hash_table_insert (self->pv->assertions, g_bytes_ref (key), g_object_ref (assertion)); gkm_object_expose (GKM_OBJECT (assertion), gkm_object_is_exposed (GKM_OBJECT (self))); if (transaction != NULL) gkm_transaction_add (transaction, self, complete_add_assertion, g_object_ref (assertion)); } static gboolean complete_remove_assertion (GkmTransaction *transaction, GObject *object, gpointer user_data) { GkmXdgTrust *self = GKM_XDG_TRUST (object); GkmAssertion *assertion = GKM_ASSERTION (user_data); if (gkm_transaction_get_failed (transaction)) add_assertion_to_trust (self, assertion, NULL); else g_object_run_dispose (G_OBJECT (assertion)); g_object_unref (assertion); return TRUE; } static void remove_assertion_from_trust (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction) { GBytes *key; key = lookup_assertion_key (assertion); g_assert (key != NULL); gkm_object_expose (GKM_OBJECT (assertion), FALSE); if (transaction == NULL) { if (!g_hash_table_remove (self->pv->assertions, key)) g_return_if_reached (); } else { if (!g_hash_table_steal (self->pv->assertions, key)) g_return_if_reached (); gkm_transaction_add (transaction, self, complete_remove_assertion, assertion); g_bytes_unref (key); } } static gboolean load_assertions (GkmXdgTrust *self, GNode *asn) { GHashTable *assertions; GkmAssertion *assertion; GBytes *key; GNode *node; guint count, i; g_assert (self); g_assert (asn); assertions = self->pv->assertions; self->pv->assertions = create_assertions (); count = egg_asn1x_count (egg_asn1x_node (asn, "assertions", NULL)); for (i = 0; i < count; ++i) { node = egg_asn1x_node (asn, "assertions", i + 1, NULL); g_return_val_if_fail (node != NULL, FALSE); /* We use the raw DER encoding as an assertion */ key = egg_asn1x_get_element_raw (node); g_return_val_if_fail (key != NULL, FALSE); /* Already have this assertion? */ assertion = g_hash_table_lookup (assertions, key); if (assertion) { if (!g_hash_table_steal (assertions, key)) g_assert_not_reached (); /* Create a new assertion */ } else { assertion = create_assertion (self, node); } add_assertion_to_trust (self, assertion, NULL); g_bytes_unref (key); g_object_unref (assertion); } /* Override the stored assertions and netscape trust */ g_hash_table_remove_all (assertions); g_hash_table_unref (assertions); return TRUE; } static gboolean save_assertion (GNode *asn, GkmAssertion *assertion) { const gchar *purpose; const gchar *peer; GQuark level; level = assertion_type_to_level_enum (gkm_assertion_get_trust_type (assertion)); purpose = gkm_assertion_get_purpose (assertion); peer = gkm_assertion_get_peer (assertion); if (!egg_asn1x_set_string_as_utf8 (egg_asn1x_node (asn, "purpose", NULL), g_strdup (purpose), g_free)) g_return_val_if_reached (FALSE); egg_asn1x_set_enumerated (egg_asn1x_node (asn, "level", NULL), level); if (peer && !egg_asn1x_set_string_as_utf8 (egg_asn1x_node (asn, "peer", NULL), g_strdup (peer), g_free)) g_return_val_if_reached (FALSE); return TRUE; } static gboolean save_assertions (GkmXdgTrust *self, GNode *asn) { GHashTableIter iter; GNode *pair, *node; gpointer value; g_assert (GKM_XDG_IS_TRUST (self)); g_assert (asn); node = egg_asn1x_node (asn, "assertions", NULL); egg_asn1x_clear (node); g_hash_table_iter_init (&iter, self->pv->assertions); while (g_hash_table_iter_next (&iter, NULL, &value)) { pair = egg_asn1x_append (node); g_return_val_if_fail (pair, FALSE); save_assertion (pair, GKM_ASSERTION (value)); } return TRUE; } static GkmXdgTrust* create_trust_for_reference (GkmModule *module, GkmManager *manager, CK_ATTRIBUTE_PTR serial, CK_ATTRIBUTE_PTR issuer) { GkmXdgTrust *trust; GNode *asn, *ref, *node; GBytes *bytes; asn = egg_asn1x_create (xdg_asn1_tab, "trust-1"); g_return_val_if_fail (asn, NULL); ref = egg_asn1x_node (asn, "reference", NULL); node = egg_asn1x_node (ref, "certReference", NULL); egg_asn1x_set_choice (ref, node); bytes = g_bytes_new (serial->pValue, serial->ulValueLen); egg_asn1x_set_integer_as_raw (egg_asn1x_node (node, "serialNumber", NULL), bytes); g_bytes_unref (bytes); bytes = g_bytes_new (issuer->pValue, issuer->ulValueLen); egg_asn1x_set_any_raw (egg_asn1x_node (node, "issuer", NULL), bytes); g_bytes_unref (bytes); trust = g_object_new (GKM_XDG_TYPE_TRUST, "module", module, "manager", manager, NULL); trust->pv->asn = asn; /* Encode it, so we have read access to all the data */ trust->pv->bytes = egg_asn1x_encode (asn, NULL); if (!trust->pv->bytes) { g_warning ("created invalid trust object: %s", egg_asn1x_message (asn)); return NULL; } return trust; } static GkmXdgTrust* create_trust_for_complete (GkmModule *module, GkmManager *manager, CK_ATTRIBUTE_PTR cert) { GkmXdgTrust *trust; GNode *asn, *ref, *node; GBytes *bytes; asn = egg_asn1x_create (xdg_asn1_tab, "trust-1"); g_return_val_if_fail (asn, NULL); ref = egg_asn1x_node (asn, "reference", NULL); node = egg_asn1x_node (ref, "certComplete", NULL); egg_asn1x_set_choice (ref, node); bytes = g_bytes_new (cert->pValue, cert->ulValueLen); egg_asn1x_set_any_raw (node, bytes); g_bytes_unref (bytes); trust = g_object_new (GKM_XDG_TYPE_TRUST, "module", module, "manager", manager, NULL); trust->pv->asn = asn; /* Encode it, which validates, and so we have read access to all the data */ trust->pv->bytes = egg_asn1x_encode (asn, NULL); if (!trust->pv->bytes) { g_warning ("created invalid trust object: %s", egg_asn1x_message (asn)); return NULL; } return trust; } /* ----------------------------------------------------------------------------- * OBJECT */ static CK_RV gkm_xdg_trust_get_attribute (GkmObject *base, GkmSession *session, CK_ATTRIBUTE_PTR attr) { GkmXdgTrust *self = GKM_XDG_TRUST (base); switch (attr->type) { case CKA_PRIVATE: return gkm_attribute_set_bool (attr, CK_FALSE); case CKA_TRUST_STEP_UP_APPROVED: return gkm_attribute_set_bool (attr, CK_FALSE); case CKA_CLASS: return gkm_attribute_set_ulong (attr, CKO_NETSCAPE_TRUST); case CKA_MODIFIABLE: return gkm_attribute_set_bool (attr, CK_FALSE); /* Certificate reference values */ case CKA_SUBJECT: return trust_get_der (self, "subject", attr); case CKA_SERIAL_NUMBER: return trust_get_integer (self, "serialNumber", attr); case CKA_ISSUER: return trust_get_der (self, "issuer", attr); case CKA_X_CERTIFICATE_VALUE: return trust_get_complete (self, attr); /* Certificate hash values */ case CKA_CERT_MD5_HASH: return trust_get_hash (self, G_CHECKSUM_MD5, attr); case CKA_CERT_SHA1_HASH: return trust_get_hash (self, G_CHECKSUM_SHA1, attr); default: break; }; return GKM_OBJECT_CLASS (gkm_xdg_trust_parent_class)->get_attribute (base, session, attr); } static void gkm_xdg_trust_expose_object (GkmObject *base, gboolean expose) { GHashTableIter iter; gpointer value; GKM_OBJECT_CLASS (gkm_xdg_trust_parent_class)->expose_object (base, expose); g_hash_table_iter_init (&iter, GKM_XDG_TRUST (base)->pv->assertions); while (g_hash_table_iter_next (&iter, NULL, &value)) gkm_object_expose (value, expose); } static GkmTrustLevel gkm_xdg_trust_get_level (GkmTrust *base, const gchar *purpose) { GkmXdgTrust *self = GKM_XDG_TRUST (base); GkmAssertion *assertion; GBytes *key; gulong type; key = create_assertion_key (purpose, NULL); assertion = g_hash_table_lookup (self->pv->assertions, key); g_bytes_unref (key); if (!assertion) return GKM_TRUST_UNKNOWN; type = gkm_assertion_get_trust_type (assertion); if (type == CKT_X_ANCHORED_CERTIFICATE) return GKM_TRUST_ANCHOR; else if (type == CKT_X_PINNED_CERTIFICATE) return GKM_TRUST_TRUSTED; else if (type == CKT_X_DISTRUSTED_CERTIFICATE) return GKM_TRUST_DISTRUSTED; else g_return_val_if_reached (GKM_TRUST_UNKNOWN); } static void gkm_xdg_trust_init (GkmXdgTrust *self) { self->pv = gkm_xdg_trust_get_instance_private (self); self->pv->assertions = create_assertions (); } static void gkm_xdg_trust_finalize (GObject *obj) { GkmXdgTrust *self = GKM_XDG_TRUST (obj); if (self->pv->asn) egg_asn1x_destroy (self->pv->asn); self->pv->asn = NULL; if (self->pv->assertions) g_hash_table_destroy (self->pv->assertions); self->pv->assertions = NULL; if (self->pv->bytes) g_bytes_unref (self->pv->bytes); self->pv->bytes = NULL; G_OBJECT_CLASS (gkm_xdg_trust_parent_class)->finalize (obj); } static void gkm_xdg_trust_class_init (GkmXdgTrustClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GkmObjectClass *gkm_class = GKM_OBJECT_CLASS (klass); GkmTrustClass *trust_class = GKM_TRUST_CLASS (klass); gobject_class->finalize = gkm_xdg_trust_finalize; gkm_class->get_attribute = gkm_xdg_trust_get_attribute; gkm_class->expose_object = gkm_xdg_trust_expose_object; trust_class->get_trust_level = gkm_xdg_trust_get_level; QDATA_ASSERTION_KEY = g_quark_from_static_string ("gkm-xdg-trust-assertion-key"); init_quarks (); } static gboolean gkm_xdg_trust_real_load (GkmSerializable *base, GkmSecret *login, GBytes *data) { GkmXdgTrust *self = GKM_XDG_TRUST (base); GNode *asn = NULL; if (g_bytes_get_size (data) == 0) return FALSE; asn = egg_asn1x_create (xdg_asn1_tab, "trust-1"); g_return_val_if_fail (asn, FALSE); if (!egg_asn1x_decode (asn, data)) { g_warning ("couldn't parse trust data: %s", egg_asn1x_message (asn)); egg_asn1x_destroy (asn); return FALSE; } /* Next parse out all the pairs */ if (!load_assertions (self, asn)) { egg_asn1x_destroy (asn); return FALSE; } /* Take ownership of this new data */ if (self->pv->bytes) g_bytes_unref (self->pv->bytes); self->pv->bytes = g_bytes_ref (data); egg_asn1x_destroy (self->pv->asn); self->pv->asn = asn; return TRUE; } static GBytes * gkm_xdg_trust_real_save (GkmSerializable *base, GkmSecret *login) { GkmXdgTrust *self = GKM_XDG_TRUST (base); GBytes *bytes; g_return_val_if_fail (GKM_XDG_IS_TRUST (self), FALSE); g_return_val_if_fail (self->pv->asn, FALSE); if (!save_assertions (self, self->pv->asn)) return FALSE; bytes = egg_asn1x_encode (self->pv->asn, NULL); if (bytes == NULL) { g_warning ("encoding trust failed: %s", egg_asn1x_message (self->pv->asn)); return FALSE; } if (self->pv->bytes) g_bytes_unref (self->pv->bytes); self->pv->bytes = bytes; return g_bytes_ref (bytes); } static void gkm_xdg_trust_serializable (GkmSerializableIface *iface) { iface->extension = ".trust"; iface->load = gkm_xdg_trust_real_load; iface->save = gkm_xdg_trust_real_save; } /* ----------------------------------------------------------------------------- * PUBLIC */ GkmXdgTrust* gkm_xdg_trust_create_for_assertion (GkmModule *module, GkmManager *manager, GkmTransaction *transaction, CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs) { CK_ATTRIBUTE_PTR serial, issuer, cert; GkmXdgTrust *trust; g_return_val_if_fail (GKM_IS_MODULE (module), NULL); g_return_val_if_fail (GKM_IS_MANAGER (manager), NULL); g_return_val_if_fail (attrs || !n_attrs, NULL); serial = gkm_attributes_find (attrs, n_attrs, CKA_SERIAL_NUMBER); issuer = gkm_attributes_find (attrs, n_attrs, CKA_ISSUER); cert = gkm_attributes_find (attrs, n_attrs, CKA_X_CERTIFICATE_VALUE); /* A trust object with just serial + issuer */ if (serial != NULL && issuer != NULL) { if (cert != NULL) { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT); return NULL; } if (!validate_der (issuer, "Name") || !validate_integer (serial)) { gkm_transaction_fail (transaction, CKR_ATTRIBUTE_VALUE_INVALID); return NULL; } trust = create_trust_for_reference (module, manager, serial, issuer); /* A trust object with a full certificate */ } else if (cert != NULL) { if (serial != NULL || issuer != NULL) { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCONSISTENT); return NULL; } if (!validate_der (cert, "Certificate")) { gkm_transaction_fail (transaction, CKR_ATTRIBUTE_VALUE_INVALID); return NULL; } trust = create_trust_for_complete (module, manager, cert); /* Not sure what this is */ } else { gkm_transaction_fail (transaction, CKR_TEMPLATE_INCOMPLETE); return NULL; } gkm_attributes_consume (attrs, n_attrs, CKA_X_CERTIFICATE_VALUE, CKA_ISSUER, CKA_SERIAL_NUMBER, G_MAXULONG); return trust; } void gkm_xdg_trust_replace_assertion (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction) { GkmAssertion *previous; GBytes *key; g_return_if_fail (GKM_XDG_IS_TRUST (self)); g_return_if_fail (GKM_IS_ASSERTION (assertion)); g_return_if_fail (!transaction || GKM_IS_TRANSACTION (transaction)); /* Build up a key if we don't have one */ key = lookup_or_create_assertion_key (assertion); /* Remove any previous assertion with this key */ previous = g_hash_table_lookup (self->pv->assertions, key); if (previous != NULL) remove_assertion_from_trust (self, previous, transaction); add_assertion_to_trust (self, assertion, transaction); } void gkm_xdg_trust_remove_assertion (GkmXdgTrust *self, GkmAssertion *assertion, GkmTransaction *transaction) { GBytes *key; g_return_if_fail (GKM_XDG_IS_TRUST (self)); g_return_if_fail (GKM_IS_ASSERTION (assertion)); g_return_if_fail (!transaction || GKM_IS_TRANSACTION (transaction)); key = lookup_assertion_key (assertion); g_return_if_fail (key); /* Assertion needs to be from this trust object */ g_return_if_fail (g_hash_table_lookup (self->pv->assertions, key) == assertion); remove_assertion_from_trust (self, assertion, transaction); } gboolean gkm_xdg_trust_have_assertion (GkmXdgTrust *self) { g_return_val_if_fail (GKM_XDG_IS_TRUST (self), FALSE); return g_hash_table_size (self->pv->assertions); }