7 files changed, 149 insertions, 150 deletions

diff --git a/src/libstrongswan/credentials/cred_encoding.c b/src/libstrongswan/credentials/cred_encoding.c
index 2969b3e08..edd76205b 100644
--- a/src/libstrongswan/credentials/cred_encoding.c
+++ b/src/libstrongswan/credentials/cred_encoding.c
@@ -21,25 +21,25 @@
 #include <utils/hashtable.h>
 #include <threading/rwlock.h>
 
-typedef struct private_key_encoding_t private_key_encoding_t;
+typedef struct private_cred_encoding_t private_cred_encoding_t;
 
 /**
- * Private data of an key_encoding_t object.
+ * Private data of an cred_encoding_t object.
  */
-struct private_key_encoding_t {
+struct private_cred_encoding_t {
 
 	/**
-	 * Public key_encoding_t interface.
+	 * Public cred_encoding_t interface.
 	 */
-	key_encoding_t public;
+	cred_encoding_t public;
 
 	/**
 	 * cached encodings, a table for each encoding_type_t, containing chunk_t*
 	 */
-	hashtable_t *cache[KEY_ENCODING_MAX];
+	hashtable_t *cache[CRED_ENCODING_MAX];
 
 	/**
-	 * Registered encoding fuctions, key_encoder_t
+	 * Registered encoding fuctions, cred_encoder_t
 	 */
 	linked_list_t *encoders;
 
@@ -52,7 +52,7 @@ struct private_key_encoding_t {
 /**
  * See header.
  */
-bool key_encoding_args(va_list args, ...)
+bool cred_encoding_args(va_list args, ...)
 {
 	va_list parts, copy;
 	bool failed = FALSE;
@@ -61,12 +61,12 @@ bool key_encoding_args(va_list args, ...)
 
 	while (!failed)
 	{
-		key_encoding_part_t current, target;
+		cred_encoding_part_t current, target;
 		chunk_t *out, data;
 
 		/* get the part we are looking for */
-		target = va_arg(parts, key_encoding_part_t);
-		if (target == KEY_PART_END)
+		target = va_arg(parts, cred_encoding_part_t);
+		if (target == CRED_PART_END)
 		{
 			break;
 		}
@@ -75,8 +75,8 @@ bool key_encoding_args(va_list args, ...)
 		va_copy(copy, args);
 		while (!failed)
 		{
-			current = va_arg(copy, key_encoding_part_t);
-			if (current == KEY_PART_END)
+			current = va_arg(copy, cred_encoding_part_t);
+			if (current == CRED_PART_END)
 			{
 				failed = TRUE;
 				break;
@@ -111,14 +111,14 @@ static bool equals(void *key1, void *key2)
 }
 
 /**
- * Implementation of key_encoding_t.get_cache
+ * Implementation of cred_encoding_t.get_cache
  */
-static bool get_cache(private_key_encoding_t *this, key_encoding_type_t type,
+static bool get_cache(private_cred_encoding_t *this, cred_encoding_type_t type,
 					  void *cache, chunk_t *encoding)
 {
 	chunk_t *chunk;
 
-	if (type >= KEY_ENCODING_MAX || type < 0)
+	if (type >= CRED_ENCODING_MAX || type < 0)
 	{
 		return FALSE;
 	}
@@ -133,18 +133,18 @@ static bool get_cache(private_key_encoding_t *this, key_encoding_type_t type,
 }
 
 /**
- * Implementation of key_encoding_t.encode
+ * Implementation of cred_encoding_t.encode
  */
-static bool encode(private_key_encoding_t *this, key_encoding_type_t type,
+static bool encode(private_cred_encoding_t *this, cred_encoding_type_t type,
 				   void *cache, chunk_t *encoding, ...)
 {
 	enumerator_t *enumerator;
 	va_list args, copy;
-	key_encoder_t encode;
+	cred_encoder_t encode;
 	bool success = FALSE;
 	chunk_t *chunk;
 
-	if (type >= KEY_ENCODING_MAX || type < 0)
+	if (type >= CRED_ENCODING_MAX || type < 0)
 	{
 		return FALSE;
 	}
@@ -187,14 +187,14 @@ static bool encode(private_key_encoding_t *this, key_encoding_type_t type,
 }
 
 /**
- * Implementation of key_encoding_t.cache
+ * Implementation of cred_encoding_t.cache
  */
-static void cache(private_key_encoding_t *this, key_encoding_type_t type,
+static void cache(private_cred_encoding_t *this, cred_encoding_type_t type,
 				  void *cache, chunk_t encoding)
 {
 	chunk_t *chunk;
 
-	if (type >= KEY_ENCODING_MAX || type < 0)
+	if (type >= CRED_ENCODING_MAX || type < 0)
 	{
 		return free(encoding.ptr);
 	}
@@ -212,15 +212,15 @@ static void cache(private_key_encoding_t *this, key_encoding_type_t type,
 }
 
 /**
- * Implementation of key_encoding_t.clear_cache
+ * Implementation of cred_encoding_t.clear_cache
  */
-static void clear_cache(private_key_encoding_t *this, void *cache)
+static void clear_cache(private_cred_encoding_t *this, void *cache)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t *chunk;
 
 	this->lock->write_lock(this->lock);
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
 		chunk = this->cache[type]->remove(this->cache[type], cache);
 		if (chunk)
@@ -233,9 +233,9 @@ static void clear_cache(private_key_encoding_t *this, void *cache)
 }
 
 /**
- * Implementation of key_encoding_t.add_encoder
+ * Implementation of cred_encoding_t.add_encoder
  */
-static void add_encoder(private_key_encoding_t *this, key_encoder_t encoder)
+static void add_encoder(private_cred_encoding_t *this, cred_encoder_t encoder)
 {
 	this->lock->write_lock(this->lock);
 	this->encoders->insert_last(this->encoders, encoder);
@@ -243,9 +243,9 @@ static void add_encoder(private_key_encoding_t *this, key_encoder_t encoder)
 }
 
 /**
- * Implementation of key_encoding_t.remove_encoder
+ * Implementation of cred_encoding_t.remove_encoder
  */
-static void remove_encoder(private_key_encoding_t *this, key_encoder_t encoder)
+static void remove_encoder(private_cred_encoding_t *this, cred_encoder_t encoder)
 {
 	this->lock->write_lock(this->lock);
 	this->encoders->remove(this->encoders, encoder, NULL);
@@ -253,18 +253,18 @@ static void remove_encoder(private_key_encoding_t *this, key_encoder_t encoder)
 }
 
 /**
- * Implementation of key_encoder_t.destroy.
+ * Implementation of cred_encoder_t.destroy.
  */
-static void destroy(private_key_encoding_t *this)
+static void destroy(private_cred_encoding_t *this)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
-		/* We explicitly do not free remaining encodings. All keys should
+		/* We explicitly do not free remaining encodings. All creds should
 		 * have gone now, and they are responsible for cleaning out their
 		 * cache entries. Not flushing here allows the leak detective to
-		 * complain if a key did not flush cached encodings. */
+		 * complain if a credential did not flush cached encodings. */
 		this->cache[type]->destroy(this->cache[type]);
 	}
 	this->encoders->destroy(this->encoders);
@@ -275,20 +275,20 @@ static void destroy(private_key_encoding_t *this)
 /**
  * See header
  */
-key_encoding_t *key_encoding_create()
+cred_encoding_t *cred_encoding_create()
 {
-	private_key_encoding_t *this = malloc_thing(private_key_encoding_t);
-	key_encoding_type_t type;
-
-	this->public.encode = (bool(*)(key_encoding_t*, key_encoding_type_t type, void *cache, chunk_t *encoding, ...))encode;
-	this->public.get_cache = (bool(*)(key_encoding_t*, key_encoding_type_t type, void *cache, chunk_t *encoding))get_cache;
-	this->public.cache = (void(*)(key_encoding_t*, key_encoding_type_t type, void *cache, chunk_t encoding))cache;
-	this->public.clear_cache = (void(*)(key_encoding_t*, void *cache))clear_cache;
-	this->public.add_encoder = (void(*)(key_encoding_t*, key_encoder_t encoder))add_encoder;
-	this->public.remove_encoder = (void(*)(key_encoding_t*, key_encoder_t encoder))remove_encoder;
-	this->public.destroy = (void(*)(key_encoding_t*))destroy;
-
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	private_cred_encoding_t *this = malloc_thing(private_cred_encoding_t);
+	cred_encoding_type_t type;
+
+	this->public.encode = (bool(*)(cred_encoding_t*, cred_encoding_type_t type, void *cache, chunk_t *encoding, ...))encode;
+	this->public.get_cache = (bool(*)(cred_encoding_t*, cred_encoding_type_t type, void *cache, chunk_t *encoding))get_cache;
+	this->public.cache = (void(*)(cred_encoding_t*, cred_encoding_type_t type, void *cache, chunk_t encoding))cache;
+	this->public.clear_cache = (void(*)(cred_encoding_t*, void *cache))clear_cache;
+	this->public.add_encoder = (void(*)(cred_encoding_t*, cred_encoder_t encoder))add_encoder;
+	this->public.remove_encoder = (void(*)(cred_encoding_t*, cred_encoder_t encoder))remove_encoder;
+	this->public.destroy = (void(*)(cred_encoding_t*))destroy;
+
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
 		this->cache[type] = hashtable_create(hash, equals, 8);
 	}
diff --git a/src/libstrongswan/credentials/cred_encoding.h b/src/libstrongswan/credentials/cred_encoding.h
index d8435f4b4..04104fdad 100644
--- a/src/libstrongswan/credentials/cred_encoding.h
+++ b/src/libstrongswan/credentials/cred_encoding.h
@@ -14,134 +14,134 @@
  */
 
 /**
- * @defgroup key_encoding key_encoding
- * @{ @ingroup keys
+ * @defgroup cred_encoding cred_encoding
+ * @{ @ingroup credentials
  */
 
-#ifndef KEY_ENCODING_H_
-#define KEY_ENCODING_H_
+#ifndef CRED_ENCODING_H_
+#define CRED_ENCODING_H_
 
-typedef struct key_encoding_t key_encoding_t;
-typedef enum key_encoding_type_t key_encoding_type_t;
-typedef enum key_encoding_part_t key_encoding_part_t;
+typedef struct cred_encoding_t cred_encoding_t;
+typedef enum cred_encoding_type_t cred_encoding_type_t;
+typedef enum cred_encoding_part_t cred_encoding_part_t;
 
 #include <library.h>
 
 /**
- * Key encoder function implementing encoding/fingerprinting.
+ * Credential encoder function implementing encoding/fingerprinting.
  *
- * The variable argument list takes key_encoding_part_t, followed by part
+ * The variable argument list takes cred_encoding_part_t, followed by part
  * specific arguments, terminated by KEY_PART_END.
  *
- * @param type		format to encode the key to
- * @param args		list of (key_encoding_part_t, data)
+ * @param type		format to encode the credential to
+ * @param args		list of (cred_encoding_part_t, data)
  * @param encoding	encoding result, allocated
  * @return			TRUE if encoding successful
  */
-typedef bool (*key_encoder_t)(key_encoding_type_t type, chunk_t *encoding,
-							  va_list args);
+typedef bool (*cred_encoder_t)(cred_encoding_type_t type, chunk_t *encoding,
+							   va_list args);
 
 /**
- * Helper function for key_encoder_t implementations to parse argument list.
+ * Helper function for cred_encoder_t implementations to parse argument list.
  *
- * Key encoder functions get a variable argument list to parse. To simplify
- * the job, this function reads the arguments and returns chunks for each
- * part.
- * The argument list of this function takes a key_encoding_part_t, followed
- * by a data pointer receiving the value, terminated by KEY_PART_END.
+ * Credential encoder functions get a variable argument list to parse. To
+ * simplify the job, this function reads the arguments and returns chunks for
+ * each part.
+ * The argument list of this function takes a cred_encoding_part_t, followed
+ * by a data pointer receiving the value, terminated by CRED_PART_END.
  *
- * @param args		argument list passed to key encoder function
- * @param ...		list of (key_encoding_part_t, data*)
+ * @param args		argument list passed to credential encoder function
+ * @param ...		list of (cred_encoding_part_t, data*)
  * @return			TRUE if all parts found, FALSE otherwise
  */
-bool key_encoding_args(va_list args, ...);
+bool cred_encoding_args(va_list args, ...);
 
 /**
- * Encoding type of a fingerprint/private-/public-key.
+ * Encoding type of a fingerprint/credential.
  *
- * Fingerprints have have the KEY_ID_*, public keys the KEY_PUB_* and
- * private keys the KEY_PRIV_* prefix.
+ * Fingerprints have have the KEYID_*, public keys the PUBKEY_* and
+ * private keys the PRIVKEY_* prefix.
  */
-enum key_encoding_type_t {
+enum cred_encoding_type_t {
 	/** SHA1 fingerprint over subjectPublicKeyInfo */
-	KEY_ID_PUBKEY_INFO_SHA1 = 0,
+	KEYID_PUBKEY_INFO_SHA1 = 0,
 	/** SHA1 fingerprint over subjectPublicKey */
-	KEY_ID_PUBKEY_SHA1,
+	KEYID_PUBKEY_SHA1,
 	/** PGPv3 fingerprint */
-	KEY_ID_PGPV3,
+	KEYID_PGPV3,
 	/** PGPv4 fingerprint */
-	KEY_ID_PGPV4,
+	KEYID_PGPV4,
 
-	KEY_ID_MAX,
+	KEYID_MAX,
 
 	/** PKCS#1 and similar ASN.1 key encoding */
-	KEY_PUB_ASN1_DER,
-	KEY_PRIV_ASN1_DER,
+	PUBKEY_ASN1_DER,
+	PRIVKEY_ASN1_DER,
 	/** subjectPublicKeyInfo encoding */
-	KEY_PUB_SPKI_ASN1_DER,
+	PUBKEY_SPKI_ASN1_DER,
 	/** PEM encoded PKCS#1 key */
-	KEY_PUB_PEM,
-	KEY_PRIV_PEM,
+	PUBKEY_PEM,
+	PRIVKEY_PEM,
 	/** PGP key encoding */
-	KEY_PUB_PGP,
-	KEY_PRIV_PGP,
+	PUBKEY_PGP,
+	PRIVKEY_PGP,
 
-	KEY_ENCODING_MAX,
+	CRED_ENCODING_MAX,
 };
 
 /**
- * Parts of a key to encode.
+ * Parts of a credential to encode.
  */
-enum key_encoding_part_t {
+enum cred_encoding_part_t {
 	/** modulus of a RSA key, n */
-	KEY_PART_RSA_MODULUS,
+	CRED_PART_RSA_MODULUS,
 	/** public exponent of a RSA key, e */
-	KEY_PART_RSA_PUB_EXP,
+	CRED_PART_RSA_PUB_EXP,
 	/** private exponent of a RSA key, d */
-	KEY_PART_RSA_PRIV_EXP,
+	CRED_PART_RSA_PRIV_EXP,
 	/** prime1 a RSA key, p */
-	KEY_PART_RSA_PRIME1,
+	CRED_PART_RSA_PRIME1,
 	/** prime2 a RSA key, q */
-	KEY_PART_RSA_PRIME2,
+	CRED_PART_RSA_PRIME2,
 	/** exponent1 a RSA key, exp1 */
-	KEY_PART_RSA_EXP1,
+	CRED_PART_RSA_EXP1,
 	/** exponent1 a RSA key, exp2 */
-	KEY_PART_RSA_EXP2,
+	CRED_PART_RSA_EXP2,
 	/** coefficient of RSA key, coeff */
-	KEY_PART_RSA_COEFF,
+	CRED_PART_RSA_COEFF,
 	/** a DER encoded RSA public key */
-	KEY_PART_RSA_PUB_ASN1_DER,
+	CRED_PART_RSA_PUB_ASN1_DER,
 	/** a DER encoded RSA private key */
-	KEY_PART_RSA_PRIV_ASN1_DER,
+	CRED_PART_RSA_PRIV_ASN1_DER,
 	/** a DER encoded ECDSA public key */
-	KEY_PART_ECDSA_PUB_ASN1_DER,
+	CRED_PART_ECDSA_PUB_ASN1_DER,
 	/** a DER encoded ECDSA private key */
-	KEY_PART_ECDSA_PRIV_ASN1_DER,
+	CRED_PART_ECDSA_PRIV_ASN1_DER,
 
-	KEY_PART_END,
+	CRED_PART_END,
 };
 
 /**
- * Private/Public key encoding and fingerprinting facility.
+ * Credential encoding and fingerprinting facility.
  */
-struct key_encoding_t {
+struct cred_encoding_t {
 
 	/**
-	 * Encode a key into a format using several key parts, optional caching.
+	 * Encode a credential in a format using several parts, optional caching.
 	 *
-	 * The variable argument list takes key_encoding_part_t, followed by part
-	 * specific arguments, terminated by KEY_PART_END.
+	 * The variable argument list takes cred_encoding_part_t, followed by part
+	 * specific arguments, terminated by CRED_PART_END.
 	 * If a cache key is given, the returned encoding points to internal data:
 	 * do not free or modify. If no cache key is given, the encoding is
 	 * allocated and must be freed by the caller.
 	 *
-	 * @param type			format the key should be encoded to
+	 * @param type			format the credential should be encoded to
 	 * @param cache			key to use for caching, NULL to not cache
 	 * @param encoding		encoding result, allocated if caching disabled
-	 * @param ...			list of (key_encoding_part_t, data)
+	 * @param ...			list of (cred_encoding_part_t, data)
 	 * @return				TRUE if encoding successful
 	 */
-	bool (*encode)(key_encoding_t *this, key_encoding_type_t type, void *cache,
+	bool (*encode)(cred_encoding_t *this, cred_encoding_type_t type, void *cache,
 				   chunk_t *encoding, ...);
 
 	/**
@@ -149,55 +149,55 @@ struct key_encoding_t {
 	 *
 	 * @param cache			key used in encode() for caching
 	 */
-	void (*clear_cache)(key_encoding_t *this, void *cache);
+	void (*clear_cache)(cred_encoding_t *this, void *cache);
 
 	/**
 	 * Check for a cached encoding.
 	 *
-	 * @param type			format of the key encoding
+	 * @param type			format of the credential encoding
 	 * @param cache			key to use for caching, as given to encode()
 	 * @param encoding		encoding result, internal data
 	 * @return				TRUE if cache entry found
 	 */
-	bool (*get_cache)(key_encoding_t *this, key_encoding_type_t type,
+	bool (*get_cache)(cred_encoding_t *this, cred_encoding_type_t type,
 					  void *cache, chunk_t *encoding);
 
 	/**
-	 * Cache a key encoding created externally.
+	 * Cache a credential encoding created externally.
 	 *
-	 * After calling cache(), the passed encoding is owned by the key encoding
+	 * After calling cache(), the passed encoding is owned by the cred encoding
 	 * facility.
 	 *
-	 * @param type			format of the key encoding
+	 * @param type			format of the credential encoding
 	 * @param cache			key to use for caching, as given to encode()
 	 * @param encoding		encoding to cache, gets owned by this
 	 */
-	void (*cache)(key_encoding_t *this, key_encoding_type_t type, void *cache,
+	void (*cache)(cred_encoding_t *this, cred_encoding_type_t type, void *cache,
 				  chunk_t encoding);
 
 	/**
-	 * Register a key encoder function.
+	 * Register a credential encoder function.
 	 *
-	 * @param encoder		key encoder function to add
+	 * @param encoder		credential encoder function to add
 	 */
-	void (*add_encoder)(key_encoding_t *this, key_encoder_t encoder);
+	void (*add_encoder)(cred_encoding_t *this, cred_encoder_t encoder);
 
 	/**
-	 * Unregister a previously registered key encoder function.
+	 * Unregister a previously registered credential encoder function.
 	 *
-	 * @param encoder		key encoder function to remove
+	 * @param encoder		credential encoder function to remove
 	 */
-	void (*remove_encoder)(key_encoding_t *this, key_encoder_t encoder);
+	void (*remove_encoder)(cred_encoding_t *this, cred_encoder_t encoder);
 
 	/**
-	 * Destroy a key_encoding_t.
+	 * Destroy a cred_encoding_t.
 	 */
-	void (*destroy)(key_encoding_t *this);
+	void (*destroy)(cred_encoding_t *this);
 };
 
 /**
- * Create a key_encoding instance.
+ * Create a cred_encoding instance.
  */
-key_encoding_t *key_encoding_create();
+cred_encoding_t *cred_encoding_create();
 
-#endif /** KEY_ENCODING_H_ @}*/
+#endif /** CRED_ENCODING_H_ @}*/
diff --git a/src/libstrongswan/credentials/credential_manager.c b/src/libstrongswan/credentials/credential_manager.c
index 3b671c71f..46c36c941 100644
--- a/src/libstrongswan/credentials/credential_manager.c
+++ b/src/libstrongswan/credentials/credential_manager.c
@@ -909,7 +909,7 @@ static private_key_t *get_private_by_cert(private_credential_manager_t *this,
 	public = cert->get_public_key(cert);
 	if (public)
 	{
-		if (public->get_fingerprint(public, KEY_ID_PUBKEY_SHA1, &chunk))
+		if (public->get_fingerprint(public, KEYID_PUBKEY_SHA1, &chunk))
 		{
 			keyid = identification_create_from_encoding(ID_KEY_ID, chunk);
 			private = get_private_by_keyid(this, type, keyid);
diff --git a/src/libstrongswan/credentials/keys/private_key.c b/src/libstrongswan/credentials/keys/private_key.c
index c3b5ac55b..8292af495 100644
--- a/src/libstrongswan/credentials/keys/private_key.c
+++ b/src/libstrongswan/credentials/keys/private_key.c
@@ -20,7 +20,7 @@
  */
 bool private_key_equals(private_key_t *this, private_key_t *other)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t a, b;
 
 	if (this == other)
@@ -28,7 +28,7 @@ bool private_key_equals(private_key_t *this, private_key_t *other)
 		return TRUE;
 	}
 
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
 		if (this->get_fingerprint(this, type, &a) &&
 			other->get_fingerprint(other, type, &b))
@@ -44,10 +44,10 @@ bool private_key_equals(private_key_t *this, private_key_t *other)
  */
 bool private_key_belongs_to(private_key_t *private, public_key_t *public)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t a, b;
 
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
 		if (private->get_fingerprint(private, type, &a) &&
 			public->get_fingerprint(public, type, &b))
@@ -63,10 +63,10 @@ bool private_key_belongs_to(private_key_t *private, public_key_t *public)
  */
 bool private_key_has_fingerprint(private_key_t *private, chunk_t fingerprint)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t current;
 
-	for (type = 0; type < KEY_ID_MAX; type++)
+	for (type = 0; type < KEYID_MAX; type++)
 	{
 		if (private->get_fingerprint(private, type, &current) &&
 			chunk_equals(current, fingerprint))
diff --git a/src/libstrongswan/credentials/keys/private_key.h b/src/libstrongswan/credentials/keys/private_key.h
index 0ff186f02..27f4ab098 100644
--- a/src/libstrongswan/credentials/keys/private_key.h
+++ b/src/libstrongswan/credentials/keys/private_key.h
@@ -90,11 +90,11 @@ struct private_key_t {
 	/**
 	 * Get the fingerprint of the key.
 	 *
-	 * @param type		type of fingerprint, one of KEY_ID_*
+	 * @param type		type of fingerprint, one of KEYID_*
 	 * @param fp		fingerprint, points to internal data
 	 * @return			TRUE if fingerprint type supported
 	 */
-	bool (*get_fingerprint)(private_key_t *this, key_encoding_type_t type,
+	bool (*get_fingerprint)(private_key_t *this, cred_encoding_type_t type,
 							chunk_t *fp);
 
 	/**
@@ -108,11 +108,11 @@ struct private_key_t {
 	/**
 	 * Get the key in an encoded form as a chunk.
 	 *
-	 * @param type		type of the encoding, one of KEY_PRIV_*
+	 * @param type		type of the encoding, one of PRIVKEY_*
 	 * @param encoding	encoding of the key, allocated
 	 * @return			TRUE if encoding supported
 	 */
-	bool (*get_encoding)(private_key_t *this, key_encoding_type_t type,
+	bool (*get_encoding)(private_key_t *this, cred_encoding_type_t type,
 						 chunk_t *encoding);
 
 	/**
diff --git a/src/libstrongswan/credentials/keys/public_key.c b/src/libstrongswan/credentials/keys/public_key.c
index ba3036793..ce342de33 100644
--- a/src/libstrongswan/credentials/keys/public_key.c
+++ b/src/libstrongswan/credentials/keys/public_key.c
@@ -47,7 +47,7 @@ ENUM(signature_scheme_names, SIGN_UNKNOWN, SIGN_ECDSA_521,
  */
 bool public_key_equals(public_key_t *this, public_key_t *other)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t a, b;
 
 	if (this == other)
@@ -55,7 +55,7 @@ bool public_key_equals(public_key_t *this, public_key_t *other)
 		return TRUE;
 	}
 
-	for (type = 0; type < KEY_ENCODING_MAX; type++)
+	for (type = 0; type < CRED_ENCODING_MAX; type++)
 	{
 		if (this->get_fingerprint(this, type, &a) &&
 			other->get_fingerprint(other, type, &b))
@@ -71,10 +71,10 @@ bool public_key_equals(public_key_t *this, public_key_t *other)
  */
 bool public_key_has_fingerprint(public_key_t *public, chunk_t fingerprint)
 {
-	key_encoding_type_t type;
+	cred_encoding_type_t type;
 	chunk_t current;
 
-	for (type = 0; type < KEY_ID_MAX; type++)
+	for (type = 0; type < KEYID_MAX; type++)
 	{
 		if (public->get_fingerprint(public, type, &current) &&
 			chunk_equals(current, fingerprint))
diff --git a/src/libstrongswan/credentials/keys/public_key.h b/src/libstrongswan/credentials/keys/public_key.h
index 33ad9418e..ff827a189 100644
--- a/src/libstrongswan/credentials/keys/public_key.h
+++ b/src/libstrongswan/credentials/keys/public_key.h
@@ -23,7 +23,6 @@
 
 typedef struct public_key_t public_key_t;
 typedef enum key_type_t key_type_t;
-typedef enum key_id_type_t key_id_type_t;
 typedef enum signature_scheme_t signature_scheme_t;
 
 #include <library.h>
@@ -147,11 +146,11 @@ struct public_key_t {
 	/**
 	 * Get the fingerprint of the key.
 	 *
-	 * @param type		type of fingerprint, one of KEY_ID_*
+	 * @param type		type of fingerprint, one of KEYID_*
 	 * @param fp		fingerprint, points to internal data
 	 * @return			TRUE if fingerprint type supported
 	 */
-	bool (*get_fingerprint)(public_key_t *this, key_encoding_type_t type,
+	bool (*get_fingerprint)(public_key_t *this, cred_encoding_type_t type,
 							chunk_t *fp);
 
 	/**
@@ -165,11 +164,11 @@ struct public_key_t {
 	/**
 	 * Get the key in an encoded form as a chunk.
 	 *
-	 * @param type		type of the encoding, one of KEY_PRIV_*
+	 * @param type		type of the encoding, one of PRIVKEY_*
 	 * @param encoding	encoding of the key, allocated
 	 * @return			TRUE if encoding supported
 	 */
-	bool (*get_encoding)(public_key_t *this, key_encoding_type_t type,
+	bool (*get_encoding)(public_key_t *this, cred_encoding_type_t type,
 						 chunk_t *encoding);
 
 	/**