X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilccrypt%2Fsilcpkcs.c;h=9611866171e7af8ba286dc5dc92cfb7a1a5102ea;hp=fe3b09c065c8da6381526a3e26065dc1deb823c5;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hpb=e64d05fc085b50c65c56748790fb42e5f71b8027

diff --git a/lib/silccrypt/silcpkcs.c b/lib/silccrypt/silcpkcs.c
index fe3b09c0..96118661 100644
--- a/lib/silccrypt/silcpkcs.c
+++ b/lib/silccrypt/silcpkcs.c
@@ -2,15 +2,14 @@
 
   silcpkcs.c
 
-  Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+  Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2000 Pekka Riikonen
+  Copyright (C) 1997 - 2007 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-  
+  the Free Software Foundation; version 2 of the License.
+
   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
@@ -19,806 +18,1058 @@
 */
 /* $Id$ */
 
-#include "silcincludes.h"
-
-#include "rsa.h"
-
-/* List of all PKCS's in SILC. PKCS's don't support SIM's thus
-   only static declarations are possible. XXX: I hope this to change
-   real soon. */
-SilcPKCSObject silc_pkcs_list[] =
+#include "silc.h"
+#include "silcpk_i.h"
+#include "silcpkcs1_i.h"
+#include "dsa.h"
+#ifdef SILC_DIST_SSH
+#include "silcssh_pkcs.h"
+#endif /* SILC_DIST_SSH */
+
+#ifndef SILC_SYMBIAN
+/* Dynamically registered list of PKCS. */
+SilcDList silc_pkcs_list = NULL;
+SilcDList silc_pkcs_alg_list = NULL;
+#define SILC_PKCS_LIST silc_pkcs_list
+#define SILC_PKCS_ALG_LIST silc_pkcs_alg_list
+#else
+#define SILC_PKCS_LIST TRUE
+#define SILC_PKCS_ALG_LIST TRUE
+#endif /* SILC_SYMBIAN */
+
+/* Static list of PKCS for silc_pkcs_register_default(). */
+const SilcPKCSObject silc_default_pkcs[] =
 {
-  { "rsa", &silc_rsa_data_context, 
-    silc_rsa_init, silc_rsa_clear_keys, silc_rsa_get_public_key,
-    silc_rsa_get_private_key, silc_rsa_set_public_key,
-    silc_rsa_set_private_key, silc_rsa_context_len,
-    silc_rsa_data_context_len, silc_rsa_set_arg,
-    silc_rsa_encrypt, silc_rsa_decrypt,
-    silc_rsa_sign, silc_rsa_verify },
-
-  { NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL }
+  /* SILC PKCS */
+  {
+    SILC_PKCS_SILC,
+    silc_pkcs_silc_get_algorithm,
+    silc_pkcs_silc_import_public_key_file,
+    silc_pkcs_silc_import_public_key,
+    silc_pkcs_silc_export_public_key_file,
+    silc_pkcs_silc_export_public_key,
+    silc_pkcs_silc_public_key_bitlen,
+    silc_pkcs_silc_public_key_copy,
+    silc_pkcs_silc_public_key_compare,
+    silc_pkcs_silc_public_key_free,
+    silc_pkcs_silc_import_private_key_file,
+    silc_pkcs_silc_import_private_key,
+    silc_pkcs_silc_export_private_key_file,
+    silc_pkcs_silc_export_private_key,
+    silc_pkcs_silc_private_key_bitlen,
+    silc_pkcs_silc_private_key_free,
+    silc_pkcs_silc_encrypt,
+    silc_pkcs_silc_decrypt,
+    silc_pkcs_silc_sign,
+    silc_pkcs_silc_verify,
+  },
+
+#ifdef SILC_DIST_SSH
+  /* SSH2 PKCS */
+  {
+    SILC_PKCS_SSH2,
+    silc_pkcs_ssh_get_algorithm,
+    silc_pkcs_ssh_import_public_key_file,
+    silc_pkcs_ssh_import_public_key,
+    silc_pkcs_ssh_export_public_key_file,
+    silc_pkcs_ssh_export_public_key,
+    silc_pkcs_ssh_public_key_bitlen,
+    silc_pkcs_ssh_public_key_copy,
+    silc_pkcs_ssh_public_key_compare,
+    silc_pkcs_ssh_public_key_free,
+    silc_pkcs_ssh_import_private_key_file,
+    silc_pkcs_ssh_import_private_key,
+    silc_pkcs_ssh_export_private_key_file,
+    silc_pkcs_ssh_export_private_key,
+    silc_pkcs_ssh_private_key_bitlen,
+    silc_pkcs_ssh_private_key_free,
+    silc_pkcs_ssh_encrypt,
+    silc_pkcs_ssh_decrypt,
+    silc_pkcs_ssh_sign,
+    silc_pkcs_ssh_verify,
+  },
+#endif /* SILC_DIST_SSH */
+
+  {
+    0, NULL, NULL, NULL, NULL, NULL,
+       NULL, NULL, NULL, NULL, NULL
+  }
 };
 
-/* Allocates a new SilcPKCS object. The new allocated object is returned
-   to the 'new_pkcs' argument. This function also initializes the data
-   context structure. Function returns 1 on success and 0 on error.
-
-*/
-int silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs)
+/* Builtin PKCS algorithms */
+const SilcPKCSAlgorithm silc_default_pkcs_alg[] =
 {
-  int i;
+  /* PKCS #1, Version 1.5 without hash OIDs */
+  {
+    "rsa",
+    "pkcs1-no-oid",
+    "sha1,md5",
+    silc_pkcs1_generate_key,
+    silc_pkcs1_import_public_key,
+    silc_pkcs1_export_public_key,
+    silc_pkcs1_public_key_bitlen,
+    silc_pkcs1_public_key_copy,
+    silc_pkcs1_public_key_compare,
+    silc_pkcs1_public_key_free,
+    silc_pkcs1_import_private_key,
+    silc_pkcs1_export_private_key,
+    silc_pkcs1_private_key_bitlen,
+    silc_pkcs1_private_key_free,
+    silc_pkcs1_encrypt,
+    silc_pkcs1_decrypt,
+    silc_pkcs1_sign_no_oid,
+    silc_pkcs1_verify_no_oid
+  },
+
+  /* PKCS #1, Version 1.5 */
+  {
+    "rsa",
+    "pkcs1",
+    "sha1,md5",
+    silc_pkcs1_generate_key,
+    silc_pkcs1_import_public_key,
+    silc_pkcs1_export_public_key,
+    silc_pkcs1_public_key_bitlen,
+    silc_pkcs1_public_key_copy,
+    silc_pkcs1_public_key_compare,
+    silc_pkcs1_public_key_free,
+    silc_pkcs1_import_private_key,
+    silc_pkcs1_export_private_key,
+    silc_pkcs1_private_key_bitlen,
+    silc_pkcs1_private_key_free,
+    silc_pkcs1_encrypt,
+    silc_pkcs1_decrypt,
+    silc_pkcs1_sign,
+    silc_pkcs1_verify
+  },
+
+  /* DSS */
+  {
+    "dsa",
+    "dss",
+    "sha1",
+    silc_dsa_generate_key,
+    silc_dsa_import_public_key,
+    silc_dsa_export_public_key,
+    silc_dsa_public_key_bitlen,
+    silc_dsa_public_key_copy,
+    silc_dsa_public_key_compare,
+    silc_dsa_public_key_free,
+    silc_dsa_import_private_key,
+    silc_dsa_export_private_key,
+    silc_dsa_private_key_bitlen,
+    silc_dsa_private_key_free,
+    silc_dsa_encrypt,
+    silc_dsa_decrypt,
+    silc_dsa_sign,
+    silc_dsa_verify
+  },
+
+#ifdef SILC_DIST_SSH
+  /* PKCS #1, SSH2 style public keys */
+  {
+    "rsa",
+    "ssh",
+    "sha1",
+    silc_pkcs1_generate_key,
+    silc_ssh_rsa_import_public_key,
+    silc_ssh_rsa_export_public_key,
+    silc_pkcs1_public_key_bitlen,
+    silc_pkcs1_public_key_copy,
+    silc_pkcs1_public_key_compare,
+    silc_pkcs1_public_key_free,
+    silc_pkcs1_import_private_key,
+    silc_pkcs1_export_private_key,
+    silc_pkcs1_private_key_bitlen,
+    silc_pkcs1_private_key_free,
+    silc_pkcs1_encrypt,
+    silc_pkcs1_decrypt,
+    silc_pkcs1_sign,
+    silc_pkcs1_verify
+  },
+
+  /* DSS, SSH2 style public keys */
+  {
+    "dsa",
+    "ssh",
+    "sha1",
+    silc_dsa_generate_key,
+    silc_ssh_dsa_import_public_key,
+    silc_ssh_dsa_export_public_key,
+    silc_dsa_public_key_bitlen,
+    silc_dsa_public_key_copy,
+    silc_dsa_public_key_compare,
+    silc_dsa_public_key_free,
+    silc_dsa_import_private_key,
+    silc_dsa_export_private_key,
+    silc_dsa_private_key_bitlen,
+    silc_dsa_private_key_free,
+    silc_dsa_encrypt,
+    silc_dsa_decrypt,
+    silc_dsa_sign,
+    silc_dsa_verify
+  },
+#endif /* SILC_DIST_SSH */
+
+  {
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, NULL, NULL,
+    NULL, NULL
+  }
+};
 
-  SILC_LOG_DEBUG(("Allocating new PKCS object"));
+/* Register a new PKCS */
 
-  for (i = 0; silc_pkcs_list[i].name; i++) {
-    if (!strcmp(silc_pkcs_list[i].name, name))
-      break;
+SilcBool silc_pkcs_register(const SilcPKCSObject *pkcs)
+{
+#ifndef SILC_SYMBIAN
+  SilcPKCSObject *newpkcs;
+
+  SILC_LOG_DEBUG(("Registering new PKCS"));
+
+  /* Check if exists already */
+  if (silc_pkcs_list) {
+    SilcPKCSObject *entry;
+    silc_dlist_start(silc_pkcs_list);
+    while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
+      if (entry->type == pkcs->type)
+        return FALSE;
+    }
   }
 
-  if (silc_pkcs_list[i].name == NULL)
+  newpkcs = silc_calloc(1, sizeof(*newpkcs));
+  if (!newpkcs)
     return FALSE;
+  *newpkcs = *pkcs;
 
-  *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
-
-  /* Set the pointers */
-  (*new_pkcs)->pkcs = &silc_pkcs_list[i];
-  (*new_pkcs)->pkcs->data_context = 
-    silc_calloc(1, (*new_pkcs)->pkcs->data_context_len());
-  (*new_pkcs)->context = silc_calloc(1, (*new_pkcs)->pkcs->context_len());
-  (*new_pkcs)->get_key_len = silc_pkcs_get_key_len;
+  /* Add to list */
+  if (silc_pkcs_list == NULL)
+    silc_pkcs_list = silc_dlist_init();
+  silc_dlist_add(silc_pkcs_list, newpkcs);
 
+#endif /* SILC_SYMBIAN */
   return TRUE;
 }
 
-/* Free's the PKCS object */
+/* Unregister a PKCS */
 
-void silc_pkcs_free(SilcPKCS pkcs)
+SilcBool silc_pkcs_unregister(SilcPKCSObject *pkcs)
 {
-  if (pkcs)
-    silc_free(pkcs->context);
-}
+#ifndef SILC_SYMBIAN
+  SilcPKCSObject *entry;
 
-/* Return TRUE if PKCS algorithm `name' is supported. */
+  SILC_LOG_DEBUG(("Unregistering PKCS"));
 
-int silc_pkcs_is_supported(const unsigned char *name)
-{
-  int i;
+  if (!silc_pkcs_list)
+    return FALSE;
+
+  silc_dlist_start(silc_pkcs_list);
+  while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
+    if (pkcs == SILC_ALL_PKCS || entry == pkcs) {
+      silc_dlist_del(silc_pkcs_list, entry);
+      silc_free(entry);
+
+      if (silc_dlist_count(silc_pkcs_list) == 0) {
+	silc_dlist_uninit(silc_pkcs_list);
+	silc_pkcs_list = NULL;
+      }
 
-  for (i = 0; silc_pkcs_list[i].name; i++) {
-    if (!strcmp(silc_pkcs_list[i].name, name))
       return TRUE;
+    }
   }
 
+#endif /* SILC_SYMBIAN */
   return FALSE;
 }
 
-/* Returns comma separated list of supported PKCS algorithms */
+/* Register algorithm */
 
-char *silc_pkcs_get_supported()
+SilcBool silc_pkcs_algorithm_register(const SilcPKCSAlgorithm *pkcs)
 {
-  char *list = NULL;
-  int i, len;
+#ifndef SILC_SYMBIAN
+  SilcPKCSAlgorithm *newalg;
+
+  SILC_LOG_DEBUG(("Registering new PKCS algorithm %s",
+		  pkcs->name));
+
+  /* Check if exists already */
+  if (silc_pkcs_alg_list) {
+    SilcPKCSAlgorithm *entry;
+    silc_dlist_start(silc_pkcs_alg_list);
+    while ((entry = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+      if (!strcmp(entry->name, pkcs->name) &&
+	  entry->scheme && pkcs->scheme &&
+	  !strcmp(entry->scheme, pkcs->scheme))
+        return FALSE;
+    }
+  }
 
-  len = 0;
-  for (i = 0; silc_pkcs_list[i].name; i++) {
-    len += strlen(silc_pkcs_list[i].name);
-    list = silc_realloc(list, len + 1);
+  newalg = silc_calloc(1, sizeof(*newalg));
+  if (!newalg)
+    return FALSE;
 
-    memcpy(list + (len - strlen(silc_pkcs_list[i].name)), 
-	   silc_pkcs_list[i].name, strlen(silc_pkcs_list[i].name));
-    memcpy(list + len, ",", 1);
-    len++;
+  *newalg = *pkcs;
+  newalg->name = strdup(pkcs->name);
+  if (!newalg->name)
+    return FALSE;
+  if (pkcs->scheme) {
+    newalg->scheme = strdup(pkcs->scheme);
+    if (!newalg->scheme)
+      return FALSE;
   }
+  newalg->hash = strdup(pkcs->hash);
+  if (!newalg->hash)
+    return FALSE;
 
-  list[len - 1] = 0;
+  /* Add to list */
+  if (silc_pkcs_alg_list == NULL)
+    silc_pkcs_alg_list = silc_dlist_init();
+  silc_dlist_add(silc_pkcs_alg_list, newalg);
 
-  return list;
+#endif /* SILC_SYMBIAN */
+  return TRUE;
 }
 
-/* Returns the length of the key */
+/* Unregister algorithm */
 
-unsigned int silc_pkcs_get_key_len(SilcPKCS self)
+SilcBool silc_pkcs_algorithm_unregister(SilcPKCSAlgorithm *pkcs)
 {
-  return self->key_len;
-}
+#ifndef SILC_SYMBIAN
+  SilcPKCSAlgorithm*entry;
 
-/* Returns SILC style public key */
+  SILC_LOG_DEBUG(("Unregistering PKCS algorithm"));
 
-unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, unsigned int *len)
-{
-  return pkcs->pkcs->get_public_key(pkcs->context, len);
-}
+  if (!silc_pkcs_alg_list)
+    return FALSE;
 
-/* Returns SILC style private key */
+  silc_dlist_start(silc_pkcs_alg_list);
+  while ((entry = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+    if (pkcs == SILC_ALL_PKCS_ALG || entry == pkcs) {
+      silc_dlist_del(silc_pkcs_alg_list, entry);
+      silc_free(entry->name);
+      silc_free(entry->scheme);
+      silc_free(entry->hash);
+      silc_free(entry);
 
-unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, unsigned int *len)
-{
-  return pkcs->pkcs->get_private_key(pkcs->context, len);
-}
+      if (silc_dlist_count(silc_pkcs_alg_list) == 0) {
+	silc_dlist_uninit(silc_pkcs_alg_list);
+	silc_pkcs_alg_list = NULL;
+      }
 
-/* Sets public key from SilcPublicKey. */
+      return TRUE;
+    }
+  }
 
-int silc_pkcs_public_key_set(SilcPKCS pkcs, SilcPublicKey public_key)
-{
-  return pkcs->pkcs->set_public_key(pkcs->context, public_key->pk, 
-				    public_key->pk_len);
+#endif /* SILC_SYMBIAN */
+  return FALSE;
 }
 
-/* Sets public key from data. */
+/* Function that registers all the default PKCS and PKCS algorithms. */
 
-int silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
-				  unsigned int pk_len)
+SilcBool silc_pkcs_register_default(void)
 {
-  return pkcs->pkcs->set_public_key(pkcs->context, pk, pk_len);
+  /* We use builtin PKCS and algorithms */
+  return TRUE;
 }
 
-/* Sets private key from SilcPrivateKey. */
+/* Unregister all PKCS and algorithms */
 
-int silc_pkcs_private_key_set(SilcPKCS pkcs, SilcPrivateKey private_key)
+SilcBool silc_pkcs_unregister_all(void)
 {
-  return pkcs->pkcs->set_private_key(pkcs->context, private_key->prv, 
-				     private_key->prv_len);
-}
+#ifndef SILC_SYMBIAN
+  SilcPKCSObject *entry;
+  SilcPKCSAlgorithm *alg;
+
+  if (silc_pkcs_list) {
+    silc_dlist_start(silc_pkcs_list);
+    while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
+      silc_pkcs_unregister(entry);
+      if (!silc_pkcs_list)
+	break;
+    }
+  }
 
-/* Sets private key from data. */
+  if (silc_pkcs_alg_list) {
+    silc_dlist_start(silc_pkcs_alg_list);
+    while ((alg = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+      silc_pkcs_algorithm_unregister(alg);
+      if (!silc_pkcs_alg_list)
+	break;
+    }
+  }
 
-int silc_pkcs_private_key_data_set(SilcPKCS pkcs, unsigned char *prv,
-				   unsigned int prv_len)
-{
-  return pkcs->pkcs->set_private_key(pkcs->context, prv, prv_len);
+#endif /* SILC_SYMBIAN */
+  return TRUE;
 }
 
-/* Encodes and returns SILC public key identifier. If some of the 
-   arguments is NULL those are not encoded into the identifier string.
-   Protocol says that at least username and host must be provided. */
+/* Returns comma separated list of supported PKCS algorithms */
 
-char *silc_pkcs_encode_identifier(char *username, char *host, char *realname,
-				  char *email, char *org, char *country)
+char *silc_pkcs_get_supported(void)
 {
-  SilcBuffer buf;
-  char *identifier;
-  unsigned int len, tlen = 0;
-
-  if (!username || !host)
-    return NULL;
+  SilcPKCSAlgorithm *entry, *entry2;
+  char *list = NULL;
+  int i, len = 0;
+
+#ifndef SILC_SYMBIAN
+  if (silc_pkcs_alg_list) {
+    silc_dlist_start(silc_pkcs_alg_list);
+    while ((entry = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+      len += strlen(entry->name);
+      list = silc_realloc(list, len + 1);
+      if (!list)
+	return NULL;
+
+      memcpy(list + (len - strlen(entry->name)),
+	     entry->name, strlen(entry->name));
+      memcpy(list + len, ",", 1);
+      len++;
+    }
+  }
+#endif /* SILC_SYMBIAN */
+
+  for (i = 0; silc_default_pkcs_alg[i].name; i++) {
+    entry = (SilcPKCSAlgorithm *)&(silc_default_pkcs_alg[i]);
+
+    if (silc_pkcs_alg_list) {
+      silc_dlist_start(silc_pkcs_alg_list);
+      while ((entry2 = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+	if (!strcmp(entry2->name, entry->name))
+	  break;
+      }
+      if (entry2)
+	continue;
+    }
 
-  len = (username ? strlen(username) : 0) +
-	(host     ? strlen(host)     : 0) +
-	(realname ? strlen(realname) : 0) +
-	(email    ? strlen(email)    : 0) +
-	(org      ? strlen(org)      : 0) +
-	(country  ? strlen(country)  : 0);
-  
-  if (len < 3)
-    return NULL;
+    len += strlen(entry->name);
+    list = silc_realloc(list, len + 1);
+    if (!list)
+      return NULL;
 
-  len += 3 + 5 + 5 + 4 + 4 + 4;
-  buf = silc_buffer_alloc(len);
-  silc_buffer_pull_tail(buf, len);
-
-  if (username) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING("UN="),
-		       SILC_STR_UI32_STRING(username),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 3 + strlen(username));
-    tlen = 3 + strlen(username); 
-  }
-    
-  if (host) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING(", "),
-		       SILC_STR_UI32_STRING("HN="),
-		       SILC_STR_UI32_STRING(host),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 5 + strlen(host));
-    tlen += 5 + strlen(host); 
+    memcpy(list + (len - strlen(entry->name)),
+	   entry->name, strlen(entry->name));
+    memcpy(list + len, ",", 1);
+    len++;
   }
 
-  if (realname) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING(", "),
-		       SILC_STR_UI32_STRING("RN="),
-		       SILC_STR_UI32_STRING(realname),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 5 + strlen(realname));
-    tlen += 5 + strlen(realname); 
-  }
+  list[len - 1] = 0;
 
-  if (email) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING(", "),
-		       SILC_STR_UI32_STRING("E="),
-		       SILC_STR_UI32_STRING(email),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 4 + strlen(email));
-    tlen += 4 + strlen(email); 
-  }
+  return list;
+}
 
-  if (org) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING(", "),
-		       SILC_STR_UI32_STRING("O="),
-		       SILC_STR_UI32_STRING(org),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 4 + strlen(org));
-    tlen += 4 + strlen(org); 
-  }
+/* Finds PKCS object */
 
-  if (country) {
-    silc_buffer_format(buf,
-		       SILC_STR_UI32_STRING(", "),
-		       SILC_STR_UI32_STRING("C="),
-		       SILC_STR_UI32_STRING(country),
-		       SILC_STR_END);
-    silc_buffer_pull(buf, 4 + strlen(country));
-    tlen += 4 + strlen(country); 
+const SilcPKCSObject *silc_pkcs_find_pkcs(SilcPKCSType type)
+{
+  SilcPKCSObject *entry;
+  int i;
+
+#ifndef SILC_SYMBIAN
+  if (silc_pkcs_list) {
+    silc_dlist_start(silc_pkcs_list);
+    while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
+      if (entry->type == type)
+	return (const SilcPKCSObject *)entry;
+    }
   }
+#endif /* SILC_SYMBIAN */
 
-  silc_buffer_push(buf, buf->data - buf->head);
-  identifier = silc_calloc(tlen + 1, sizeof(*identifier));
-  memcpy(identifier, buf->data, tlen);
-  silc_buffer_free(buf);
+  for (i = 0; silc_default_pkcs[i].type; i++) {
+    entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+    if (entry->type == type)
+      return (const SilcPKCSObject *)entry;
+  }
 
-  return identifier;
+  return NULL;
 }
 
-/* Allocates SILC style public key formed from sent arguments. All data
-   is duplicated. */
+/* Finds PKCS algorithms object */
 
-SilcPublicKey silc_pkcs_public_key_alloc(char *name, char *identifier,
-					 unsigned char *pk, 
-					 unsigned int pk_len)
+const SilcPKCSAlgorithm *silc_pkcs_find_algorithm(const char *algorithm,
+						  const char *scheme)
 {
-  SilcPublicKey public_key;
+  SilcPKCSAlgorithm *entry;
+  int i;
 
-  public_key = silc_calloc(1, sizeof(*public_key));
-  public_key->len = 4 + 2 + strlen(name) + 2 + strlen(identifier) + pk_len;
-  public_key->name = strdup(name);
-  public_key->identifier = strdup(identifier);
-  public_key->pk_len = pk_len;
-  public_key->pk = silc_calloc(pk_len, sizeof(*public_key->pk));
-  memcpy(public_key->pk, pk, pk_len);
+#ifndef SILC_SYMBIAN
+  if (silc_pkcs_alg_list) {
+    silc_dlist_start(silc_pkcs_alg_list);
+    while ((entry = silc_dlist_get(silc_pkcs_alg_list)) != SILC_LIST_END) {
+      if (!strcmp(entry->name, algorithm) &&
+	  (!scheme || !entry->scheme || !strcmp(entry->scheme, scheme)))
+	return (const SilcPKCSAlgorithm *)entry;
+    }
+  }
+#endif /* SILC_SYMBIAN */
+
+  for (i = 0; silc_default_pkcs_alg[i].name; i++) {
+    entry = (SilcPKCSAlgorithm *)&(silc_default_pkcs_alg[i]);
+    if (!strcmp(entry->name, algorithm) &&
+	(!scheme || !entry->scheme || !strcmp(entry->scheme, scheme)))
+      return (const SilcPKCSAlgorithm *)entry;
+  }
 
-  return public_key;
+  return NULL;
 }
 
-/* Free's public key */
+/* Returns PKCS context */
 
-void silc_pkcs_public_key_free(SilcPublicKey public_key)
+const SilcPKCSObject *silc_pkcs_get_pkcs(void *key)
 {
-  if (public_key) {
-    silc_free(public_key->name);
-    silc_free(public_key->identifier);
-    silc_free(public_key->pk);
-    silc_free(public_key);
-  }
+  SilcPublicKey public_key = key;
+  return public_key->pkcs;
 }
 
-/* Allocates SILC private key formed from sent arguments. All data is
-   duplicated. */
+/* Returns PKCS algorithm context */
 
-SilcPrivateKey silc_pkcs_private_key_alloc(char *name, unsigned char *prv,
-					   unsigned int prv_len)
+const SilcPKCSAlgorithm *silc_pkcs_get_algorithm(void *key)
 {
-  SilcPrivateKey private_key;
+  SilcPublicKey public_key = key;
+  return public_key->alg;
+}
 
-  private_key = silc_calloc(1, sizeof(*private_key));
-  private_key->name = strdup(name);
-  private_key->prv_len = prv_len;
-  private_key->prv = silc_calloc(prv_len, sizeof(*private_key->prv));
-  memcpy(private_key->prv, prv, prv_len);
+/* Return algorithm name */
 
-  return private_key;
+const char *silc_pkcs_get_name(void *key)
+{
+  const SilcPKCSAlgorithm *pkcs = silc_pkcs_get_algorithm(key);
+  return pkcs->name;
 }
 
-/* Free's private key */
+/* Returns PKCS type */
 
-void silc_pkcs_private_key_free(SilcPrivateKey private_key)
+SilcPKCSType silc_pkcs_get_type(void *key)
 {
-  if (private_key) {
-    silc_free(private_key->name);
-    silc_free(private_key->prv);
-    silc_free(private_key);
-  }
+  SilcPublicKey public_key = key;
+  return public_key->pkcs->type;
 }
 
-/* Encodes SILC style public key from SilcPublicKey. Returns the encoded
-   data. */
+/* Allocates new public key from the key data */
 
-unsigned char *
-silc_pkcs_public_key_encode(SilcPublicKey public_key, unsigned int *len)
+SilcBool silc_pkcs_public_key_alloc(SilcPKCSType type,
+				    unsigned char *key,
+				    SilcUInt32 key_len,
+				    SilcPublicKey *ret_public_key)
 {
-  SilcBuffer buf;
-  unsigned char *ret;
+  const SilcPKCSObject *pkcs;
+  SilcPublicKey public_key;
+
+  if (!ret_public_key)
+    return FALSE;
+
+  /* Allocate public key context */
+  public_key = silc_calloc(1, sizeof(*public_key));
+  if (!public_key)
+    return FALSE;
+
+  pkcs = silc_pkcs_find_pkcs(type);
+  public_key->pkcs = (SilcPKCSObject *)pkcs;
+  if (!public_key->pkcs) {
+    silc_free(public_key);
+    return FALSE;
+  }
+
+  /* Import the PKCS public key */
+  if (!pkcs->import_public_key(pkcs, NULL, key, key_len,
+			       &public_key->public_key,
+			       &public_key->alg)) {
+    silc_free(public_key);
+    return FALSE;
+  }
+
+  *ret_public_key = public_key;
+
+  return TRUE;
+}
 
-  buf = silc_buffer_alloc(public_key->len);
-  silc_buffer_pull_tail(buf, public_key->len);
+/* Frees the public key */
 
-  silc_buffer_format(buf,
-		     SILC_STR_UI_INT(public_key->len),
-		     SILC_STR_UI_SHORT(strlen(public_key->name)),
-		     SILC_STR_UI32_STRING(public_key->name),
-		     SILC_STR_UI_SHORT(strlen(public_key->identifier)),
-		     SILC_STR_UI32_STRING(public_key->identifier),
-		     SILC_STR_UI_XNSTRING(public_key->pk, 
-					  public_key->pk_len),
-		     SILC_STR_END);
-  if (len)
-    *len = public_key->len;
+void silc_pkcs_public_key_free(SilcPublicKey public_key)
+{
+  public_key->pkcs->public_key_free(public_key->pkcs, public_key->public_key);
+  silc_free(public_key);
+}
 
-  ret = silc_calloc(buf->len, sizeof(*ret));
-  memcpy(ret, buf->data, buf->len);
-  silc_buffer_free(buf);
+/* Exports public key */
 
-  return ret;
+unsigned char *silc_pkcs_public_key_encode(SilcStack stack,
+					   SilcPublicKey public_key,
+					   SilcUInt32 *ret_len)
+{
+  return public_key->pkcs->export_public_key(public_key->pkcs, stack,
+					     public_key->public_key, ret_len);
 }
 
-/* Encodes SILC style public key. Returns the encoded data. */
+/* Return key length */
 
-unsigned char *
-silc_pkcs_public_key_data_encode(unsigned char *pk, unsigned int pk_len,
-				 char *pkcs, char *identifier, 
-				 unsigned int *len)
+SilcUInt32 silc_pkcs_public_key_get_len(SilcPublicKey public_key)
 {
-  SilcBuffer buf;
-  unsigned char *ret;
-  unsigned int totlen;
+  return public_key->pkcs->public_key_bitlen(public_key->pkcs,
+					     public_key->public_key);
+}
 
-  totlen = 4 + 2 + strlen(pkcs) + 2 + strlen(identifier) + pk_len;
-  buf = silc_buffer_alloc(totlen);
-  silc_buffer_pull_tail(buf, totlen);
+/* Returns internal PKCS public key context */
 
-  silc_buffer_format(buf,
-		     SILC_STR_UI_INT(totlen),
-		     SILC_STR_UI_SHORT(strlen(pkcs)),
-		     SILC_STR_UI32_STRING(pkcs),
-		     SILC_STR_UI_SHORT(strlen(identifier)),
-		     SILC_STR_UI32_STRING(identifier),
-		     SILC_STR_UI_XNSTRING(pk, pk_len),
-		     SILC_STR_END);
-  if (len)
-    *len = totlen;
+void *silc_pkcs_public_key_get_pkcs(SilcPKCSType type,
+				    SilcPublicKey public_key)
+{
+  if (public_key->pkcs->type != type)
+    return NULL;
+  return public_key->public_key;
+}
 
-  ret = silc_calloc(buf->len, sizeof(*ret));
-  memcpy(ret, buf->data, buf->len);
-  silc_buffer_free(buf);
+/* Returns internal PKCS private key context */
 
-  return ret;
+void *silc_pkcs_private_key_get_pkcs(SilcPKCSType type,
+				     SilcPrivateKey private_key)
+{
+  if (private_key->pkcs->type != type)
+    return NULL;
+  return private_key->private_key;
 }
 
-/* Decodes SILC style public key. Returns TRUE if the decoding was
-   successful. Allocates new public key as well. */
+/* Allocates new private key from key data */
 
-int silc_pkcs_public_key_decode(unsigned char *data, unsigned int data_len,
-				SilcPublicKey *public_key)
+SilcBool silc_pkcs_private_key_alloc(SilcPKCSType type,
+				     unsigned char *key,
+				     SilcUInt32 key_len,
+				     SilcPrivateKey *ret_private_key)
 {
-  SilcBuffer buf;
-  SilcPKCS alg;
-  unsigned short pkcs_len, identifier_len;
-  unsigned int totlen, key_len;
-  unsigned char *pkcs_name = NULL, *ident = NULL, *key_data = NULL;
+  const SilcPKCSObject *pkcs;
+  SilcPrivateKey private_key;
 
-  buf = silc_buffer_alloc(data_len);
-  silc_buffer_pull_tail(buf, data_len);
-  silc_buffer_put(buf, data, data_len);
+  if (!ret_private_key)
+    return FALSE;
 
-  /* Get length */
-  silc_buffer_unformat(buf,
-		       SILC_STR_UI_INT(&totlen),
-		       SILC_STR_END);
+  /* Allocate private key context */
+  private_key = silc_calloc(1, sizeof(*private_key));
+  if (!private_key)
+    return FALSE;
 
-  if (totlen != data_len) {
-    silc_buffer_free(buf);
+  pkcs = silc_pkcs_find_pkcs(type);
+  private_key->pkcs = (SilcPKCSObject *)pkcs;
+  if (!private_key->pkcs) {
+    silc_free(private_key);
     return FALSE;
   }
 
-  /* Get algorithm name and identifier */
-  silc_buffer_pull(buf, 4);
-  silc_buffer_unformat(buf,
-		       SILC_STR_UI16_NSTRING_ALLOC(&pkcs_name, &pkcs_len),
-		       SILC_STR_UI16_NSTRING_ALLOC(&ident, &identifier_len),
-		       SILC_STR_END);
-
-  if (pkcs_len < 1 || identifier_len < 3 || 
-      pkcs_len + identifier_len > totlen)
-    goto err;
-
-  /* See if we support this algorithm */
-  if (!silc_pkcs_is_supported(pkcs_name))
-    goto err;
-
-  /* Protocol says that at least UN and HN must be provided as identifier,
-     check for these. */
-  if (!strstr(ident, "UN=") && !strstr(ident, "HN="))
-    goto err;
-
-  /* Get key data. We assume that rest of the buffer is key data. */
-  silc_buffer_pull(buf, 2 + pkcs_len + 2 + identifier_len);
-  key_len = buf->len;
-  silc_buffer_unformat(buf,
-		       SILC_STR_UI_XNSTRING_ALLOC(&key_data, key_len),
-		       SILC_STR_END);
-
-  /* Try to set the key. If this fails the key must be malformed. This
-     code assumes that the PKCS routine checks the format of the key. */
-  silc_pkcs_alloc(pkcs_name, &alg);
-  if (!alg->pkcs->set_public_key(alg->context, key_data, key_len))
-    goto err;
-  silc_pkcs_free(alg);
-  
-  if (public_key) {
-    *public_key = silc_calloc(1, sizeof(**public_key));
-    (*public_key)->len = totlen;
-    (*public_key)->name = pkcs_name;
-    (*public_key)->identifier = ident;
-    (*public_key)->pk = key_data;
-    (*public_key)->pk_len = key_len;
+  /* Import the PKCS private key */
+  if (!pkcs->import_private_key(pkcs, NULL, key, key_len,
+				&private_key->private_key,
+				&private_key->alg)) {
+    silc_free(private_key);
+    return FALSE;
   }
 
-  silc_buffer_free(buf);
-  return TRUE;
+  *ret_private_key = private_key;
 
- err:
-  if (pkcs_name)
-    silc_free(pkcs_name);
-  if (ident)
-    silc_free(ident);
-  if (key_data)
-    silc_free(key_data);
-  silc_buffer_free(buf);
-  return FALSE;
+  return TRUE;
 }
 
-/* Encodes SILC private key from SilcPrivateKey. Returns the encoded data. */
+/* Return key length */
 
-unsigned char *
-silc_pkcs_private_key_encode(SilcPrivateKey private_key, unsigned int *len)
+SilcUInt32 silc_pkcs_private_key_get_len(SilcPrivateKey private_key)
 {
-  SilcBuffer buf;
-  unsigned char *ret;
-  unsigned int totlen;
-
-  totlen = 2 + strlen(private_key->name) + private_key->prv_len;
-  buf = silc_buffer_alloc(totlen);
-  silc_buffer_pull_tail(buf, totlen);
-
-  silc_buffer_format(buf,
-		     SILC_STR_UI_SHORT(strlen(private_key->name)),
-		     SILC_STR_UI32_STRING(private_key->name),
-		     SILC_STR_UI_XNSTRING(private_key->prv, 
-					  private_key->prv_len),
-		     SILC_STR_END);
-  if (len)
-    *len = totlen;
+  return private_key->pkcs->private_key_bitlen(private_key->pkcs,
+					       private_key->private_key);
+}
 
-  ret = silc_calloc(buf->len, sizeof(*ret));
-  memcpy(ret, buf->data, buf->len);
-  silc_buffer_free(buf);
+/* Frees the private key */
 
-  return ret;
+void silc_pkcs_private_key_free(SilcPrivateKey private_key)
+{
+  private_key->pkcs->private_key_free(private_key->pkcs,
+				      private_key->private_key);
+  silc_free(private_key);
 }
 
-/* Encodes SILC private key. Returns the encoded data. */
+/* Encrypts */
 
-unsigned char *
-silc_pkcs_private_key_data_encode(unsigned char *prv, unsigned int prv_len,
-				  char *pkcs, unsigned int *len)
+SilcAsyncOperation silc_pkcs_encrypt(SilcPublicKey public_key,
+				     unsigned char *src, SilcUInt32 src_len,
+				     SilcRng rng,
+				     SilcPKCSEncryptCb encrypt_cb,
+				     void *context)
 {
-  SilcBuffer buf;
-  unsigned char *ret;
-  unsigned int totlen;
+  return public_key->pkcs->encrypt(public_key->pkcs,
+				   public_key->public_key, src, src_len,
+				   rng, encrypt_cb, context);
+}
 
-  totlen = 2 + strlen(pkcs) + prv_len;
-  buf = silc_buffer_alloc(totlen);
-  silc_buffer_pull_tail(buf, totlen);
+/* Decrypts */
 
-  silc_buffer_format(buf,
-		     SILC_STR_UI_SHORT(strlen(pkcs)),
-		     SILC_STR_UI32_STRING(pkcs),
-		     SILC_STR_UI_XNSTRING(prv, prv_len),
-		     SILC_STR_END);
-  if (len)
-    *len = totlen;
+SilcAsyncOperation silc_pkcs_decrypt(SilcPrivateKey private_key,
+				     unsigned char *src, SilcUInt32 src_len,
+				     SilcPKCSDecryptCb decrypt_cb,
+				     void *context)
+{
+  return private_key->pkcs->decrypt(private_key->pkcs,
+				    private_key->private_key, src, src_len,
+				    decrypt_cb, context);
+}
 
-  ret = silc_calloc(buf->len, sizeof(*ret));
-  memcpy(ret, buf->data, buf->len);
-  silc_buffer_free(buf);
+/* Generates signature */
 
-  return ret;
+SilcAsyncOperation silc_pkcs_sign(SilcPrivateKey private_key,
+				  unsigned char *src,
+				  SilcUInt32 src_len,
+				  SilcBool compute_hash,
+				  SilcHash hash,
+				  SilcRng rng,
+				  SilcPKCSSignCb sign_cb,
+				  void *context)
+{
+  return private_key->pkcs->sign(private_key->pkcs,
+				 private_key->private_key, src, src_len,
+				 compute_hash, hash, rng, sign_cb, context);
 }
 
-/* Decodes SILC style public key. Returns TRUE if the decoding was
-   successful. Allocates new private key as well. */
+/* Verifies signature */
 
-int silc_pkcs_private_key_decode(unsigned char *data, unsigned int data_len,
-				 SilcPrivateKey *private_key)
+SilcAsyncOperation silc_pkcs_verify(SilcPublicKey public_key,
+				    unsigned char *signature,
+				    SilcUInt32 signature_len,
+				    unsigned char *data,
+				    SilcUInt32 data_len,
+				    SilcHash hash,
+				    SilcPKCSVerifyCb verify_cb,
+				    void *context)
 {
-  SilcBuffer buf;
-  SilcPKCS alg;
-  unsigned short pkcs_len;
-  unsigned int key_len;
-  unsigned char *pkcs_name = NULL, *key_data = NULL;
+  return public_key->pkcs->verify(public_key->pkcs,
+				  public_key->public_key, signature,
+				  signature_len, data, data_len, hash, NULL,
+				  verify_cb, context);
+}
 
-  buf = silc_buffer_alloc(data_len);
-  silc_buffer_pull_tail(buf, data_len);
-  silc_buffer_put(buf, data, data_len);
+/* Compares two public keys and returns TRUE if they are same key, and
+   FALSE if they are not same. */
 
-  /* Get algorithm name and identifier */
-  silc_buffer_unformat(buf,
-		       SILC_STR_UI16_NSTRING_ALLOC(&pkcs_name, &pkcs_len),
-		       SILC_STR_END);
+SilcBool silc_pkcs_public_key_compare(SilcPublicKey key1, SilcPublicKey key2)
+{
+  if (key1->pkcs->type != key2->pkcs->type)
+    return FALSE;
 
-  if (pkcs_len < 1 || pkcs_len > buf->truelen)
-    goto err;
+  return key1->pkcs->public_key_compare(key1->pkcs,
+					key1->public_key, key2->public_key);
+}
 
-  /* See if we support this algorithm */
-  if (!silc_pkcs_is_supported(pkcs_name))
-    goto err;
+/* Copies the public key indicated by `public_key' and returns new allocated
+   public key which is indentical to the `public_key'. */
 
-  /* Get key data. We assume that rest of the buffer is key data. */
-  silc_buffer_pull(buf, 2 + pkcs_len);
-  key_len = buf->len;
-  silc_buffer_unformat(buf,
-		       SILC_STR_UI_XNSTRING_ALLOC(&key_data, key_len),
-		       SILC_STR_END);
+SilcPublicKey silc_pkcs_public_key_copy(SilcPublicKey public_key)
+{
+  SilcPublicKey key = silc_calloc(1, sizeof(*key));
+  if (!key)
+    return NULL;
 
-  /* Try to set the key. If this fails the key must be malformed. This
-     code assumes that the PKCS routine checks the format of the key. */
-  silc_pkcs_alloc(pkcs_name, &alg);
-  if (!alg->pkcs->set_private_key(alg->context, key_data, key_len))
-    goto err;
-  silc_pkcs_free(alg);
-  
-  if (private_key) {
-    *private_key = silc_calloc(1, sizeof(**private_key));
-    (*private_key)->name = pkcs_name;
-    (*private_key)->prv = key_data;
-    (*private_key)->prv_len = key_len;
+  key->pkcs = public_key->pkcs;
+  key->public_key = public_key->pkcs->public_key_copy(public_key->pkcs,
+						      public_key->public_key);
+  if (!key->public_key) {
+    silc_free(key);
+    return NULL;
   }
 
-  silc_buffer_free(buf);
-  return TRUE;
-
- err:
-  if (pkcs_name)
-    silc_free(pkcs_name);
-  if (key_data)
-    silc_free(key_data);
-  silc_buffer_free(buf);
-  return FALSE;
+  return key;
 }
 
-/* Internal routine to save public key */
+/* Loads any kind of public key */
 
-static int silc_pkcs_save_public_key_internal(char *filename,
-					      unsigned char *data,
-					      unsigned int data_len,
-					      unsigned int encoding)
+SilcBool silc_pkcs_load_public_key(const char *filename,
+				   SilcPKCSType type,
+				   SilcPublicKey *ret_public_key)
 {
-  SilcBuffer buf;
-  unsigned int len;
-
-  switch(encoding) {
-  case SILC_PKCS_FILE_BIN:
-    break;
-  case SILC_PKCS_FILE_PEM:
-    data = silc_encode_pem_file(data, data_len);
-    data_len = strlen(data);
-    break;
-  }
+  unsigned char *data;
+  SilcUInt32 data_len;
+  SilcPublicKey public_key;
 
-  len = data_len + (strlen(SILC_PKCS_PUBLIC_KEYFILE_BEGIN) +
-		    strlen(SILC_PKCS_PUBLIC_KEYFILE_END));
-  buf = silc_buffer_alloc(len);
-  silc_buffer_pull_tail(buf, len);
+  SILC_LOG_DEBUG(("Loading public key file '%s'", filename));
 
-  silc_buffer_format(buf,
-		     SILC_STR_UI32_STRING(SILC_PKCS_PUBLIC_KEYFILE_BEGIN),
-		     SILC_STR_UI_XNSTRING(data, data_len),
-		     SILC_STR_UI32_STRING(SILC_PKCS_PUBLIC_KEYFILE_END),
-		     SILC_STR_END);
+  if (!ret_public_key)
+    return FALSE;
 
-  /* Save into file */
-  if (silc_file_write(filename, buf->data, buf->len)) {
-    silc_buffer_free(buf);
+  data = silc_file_readfile(filename, &data_len, NULL);
+  if (!data) {
+    SILC_LOG_ERROR(("No such file: %s", filename));
     return FALSE;
   }
 
-  silc_buffer_free(buf);
-  return TRUE;
-}
-
-/* Saves public key into file */
+  /* Allocate public key context */
+  *ret_public_key = public_key = silc_calloc(1, sizeof(*public_key));
+  if (!public_key) {
+    silc_free(data);
+    return FALSE;
+  }
 
-int silc_pkcs_save_public_key(char *filename, SilcPublicKey public_key,
-			      unsigned int encoding)
-{
-  unsigned char *data;
-  unsigned int data_len;
+  if (type == SILC_PKCS_ANY) {
+    /* Try loading all types until one succeeds. */
+    for (type = SILC_PKCS_SILC; type <= SILC_PKCS_SPKI; type++) {
+      public_key->pkcs = (SilcPKCSObject *)silc_pkcs_find_pkcs(type);
+      if (!public_key->pkcs)
+	continue;
+
+      if (public_key->pkcs->import_public_key_file(public_key->pkcs,
+						   data, data_len,
+						   SILC_PKCS_FILE_BASE64,
+						   &public_key->public_key,
+						   &public_key->alg)) {
+	silc_free(data);
+	return TRUE;
+      }
+
+      if (public_key->pkcs->import_public_key_file(public_key->pkcs,
+						   data, data_len,
+						   SILC_PKCS_FILE_BIN,
+						   &public_key->public_key,
+						   &public_key->alg)) {
+	silc_free(data);
+	return TRUE;
+      }
+    }
+  } else {
+    /* Load specific type */
+    public_key->pkcs = (SilcPKCSObject *)silc_pkcs_find_pkcs(type);
+    if (!public_key->pkcs) {
+      silc_free(data);
+      silc_free(public_key);
+      *ret_public_key = NULL;
+      SILC_LOG_ERROR(("Unsupported public key type"));
+      return FALSE;
+    }
 
-  data = silc_pkcs_public_key_encode(public_key, &data_len);
-  return silc_pkcs_save_public_key_internal(filename, data, data_len,
-					    encoding);
-}
+    if (public_key->pkcs->import_public_key_file(public_key->pkcs,
+						 data, data_len,
+						 SILC_PKCS_FILE_BASE64,
+						 &public_key->public_key,
+						 &public_key->alg)) {
+      silc_free(data);
+      return TRUE;
+    }
 
-/* Saves public key into file */
+    if (public_key->pkcs->import_public_key_file(public_key->pkcs,
+						 data, data_len,
+						 SILC_PKCS_FILE_BIN,
+						 &public_key->public_key,
+						 &public_key->alg)) {
+      silc_free(data);
+      return TRUE;
+    }
+  }
 
-int silc_pkcs_save_public_key_data(char *filename, unsigned char *data,
-				   unsigned int data_len,
-				   unsigned int encoding)
-{
-  return silc_pkcs_save_public_key_internal(filename, data, data_len,
-					    encoding);
+  silc_free(data);
+  silc_free(public_key);
+  *ret_public_key = NULL;
+  SILC_LOG_ERROR(("Unsupported public key type"));
+  return FALSE;
 }
 
-/* Internal routine to save private key. */
+/* Saves public key into a file */
 
-static int silc_pkcs_save_private_key_internal(char *filename,
-					       unsigned char *data,
-					       unsigned int data_len,
-					       unsigned int encoding)
+SilcBool silc_pkcs_save_public_key(const char *filename,
+				   SilcPublicKey public_key,
+				   SilcPKCSFileEncoding encoding)
 {
-  SilcBuffer buf;
-  unsigned int len;
-
-  switch(encoding) {
-  case SILC_PKCS_FILE_BIN:
-    break;
-  case SILC_PKCS_FILE_PEM:
-    data = silc_encode_pem_file(data, data_len);
-    data_len = strlen(data);
-    break;
+  unsigned char *data;
+  SilcUInt32 data_len;
+  SilcStack stack;
+
+  stack = silc_stack_alloc(2048, silc_crypto_stack());
+
+  /* Export the public key file */
+  data = public_key->pkcs->export_public_key_file(public_key->pkcs,
+						  stack,
+						  public_key->public_key,
+						  encoding, &data_len);
+  if (!data) {
+    silc_stack_free(stack);
+    return FALSE;
   }
 
-  len = data_len + (strlen(SILC_PKCS_PRIVATE_KEYFILE_BEGIN) +
-		    strlen(SILC_PKCS_PRIVATE_KEYFILE_END));
-  buf = silc_buffer_alloc(len);
-  silc_buffer_pull_tail(buf, len);
-
-  silc_buffer_format(buf,
-		     SILC_STR_UI32_STRING(SILC_PKCS_PRIVATE_KEYFILE_BEGIN),
-		     SILC_STR_UI_XNSTRING(data, data_len),
-		     SILC_STR_UI32_STRING(SILC_PKCS_PRIVATE_KEYFILE_END),
-		     SILC_STR_END);
-
-  /* Save into a file */
-  if (silc_file_write_mode(filename, buf->data, buf->len, 0600)) {
-    silc_buffer_free(buf);
+  /* Write to file */
+  if (silc_file_writefile(filename, data, data_len)) {
+    silc_sfree(stack, data);
+    silc_stack_free(stack);
     return FALSE;
   }
 
-  silc_buffer_free(buf);
+  silc_sfree(stack, data);
+  silc_stack_free(stack);
   return TRUE;
 }
 
-/* Saves private key into file. */
-/* XXX The buffer should be encrypted if passphrase is provided. */
+/* Loads any kind of private key */
 
-int silc_pkcs_save_private_key(char *filename, SilcPrivateKey private_key, 
-			       unsigned char *passphrase,
-			       unsigned int encoding)
+SilcBool silc_pkcs_load_private_key(const char *filename,
+				    const unsigned char *passphrase,
+				    SilcUInt32 passphrase_len,
+				    SilcPKCSType type,
+				    SilcPrivateKey *ret_private_key)
 {
   unsigned char *data;
-  unsigned int data_len;
-
-  data = silc_pkcs_private_key_encode(private_key, &data_len);
-  return silc_pkcs_save_private_key_internal(filename, data, data_len,
-					     encoding);
-}
+  SilcUInt32 data_len;
+  SilcPrivateKey private_key;
 
-/* Saves private key into file. */
-/* XXX The buffer should be encrypted if passphrase is provided. */
+  SILC_LOG_DEBUG(("Loading private key file '%s'", filename));
 
-int silc_pkcs_save_private_key_data(char *filename, unsigned char *data, 
-				    unsigned int data_len,
-				    unsigned char *passphrase,
-				    unsigned int encoding)
-{
-  return silc_pkcs_save_private_key_internal(filename, data, data_len,
-					     encoding);
-}
-
-/* Loads public key from file and allocates new public key. Returns TRUE
-   is loading was successful. */
+  if (!ret_private_key)
+    return FALSE;
 
-int silc_pkcs_load_public_key(char *filename, SilcPublicKey *public_key,
-			      unsigned int encoding)
-{
-  unsigned char *cp, *old, *data, byte;
-  unsigned int i, data_len, len;
+  data = silc_file_readfile(filename, &data_len, NULL);
+  if (!data) {
+    SILC_LOG_ERROR(("No such file: %s", filename));
+    return FALSE;
+  }
 
-  old = data = silc_file_read(filename, &data_len);
-  if (!data)
+  /* Allocate private key context */
+  *ret_private_key = private_key = silc_calloc(1, sizeof(*private_key));
+  if (!private_key) {
+    silc_free(data);
     return FALSE;
+  }
 
-  /* Check start of file and remove header from the data. */
-  len = strlen(SILC_PKCS_PUBLIC_KEYFILE_BEGIN);
-  cp = data;
-  for (i = 0; i < len; i++) {
-    byte = cp[0];
-    cp++;
-    if (byte != SILC_PKCS_PUBLIC_KEYFILE_BEGIN[i]) {
-      memset(old, 0, data_len);
-      silc_free(old);
+  if (type == SILC_PKCS_ANY) {
+    /* Try loading all types until one succeeds. */
+    for (type = SILC_PKCS_SILC; type <= SILC_PKCS_SPKI; type++) {
+      private_key->pkcs = (SilcPKCSObject *)silc_pkcs_find_pkcs(type);
+      if (!private_key->pkcs)
+	continue;
+
+      if (private_key->pkcs->import_private_key_file(
+					      private_key->pkcs,
+					      data, data_len,
+					      passphrase,
+					      passphrase_len,
+					      SILC_PKCS_FILE_BIN,
+					      &private_key->private_key,
+					      &private_key->alg)) {
+	silc_free(data);
+	return TRUE;
+      }
+
+      if (private_key->pkcs->import_private_key_file(
+					      private_key->pkcs,
+					      data, data_len,
+					      passphrase,
+					      passphrase_len,
+					      SILC_PKCS_FILE_BASE64,
+					      &private_key->private_key,
+					      &private_key->alg)) {
+	silc_free(data);
+	return TRUE;
+      }
     }
-  }
-  data = cp;
-
-  /* Decode public key */
-  if (public_key) {
-    len = data_len - (strlen(SILC_PKCS_PUBLIC_KEYFILE_BEGIN) +
-		      strlen(SILC_PKCS_PUBLIC_KEYFILE_END));
-
-    switch(encoding) {
-    case SILC_PKCS_FILE_BIN:
-      break;
-    case SILC_PKCS_FILE_PEM:
-      data = silc_decode_pem(data, len, &len);
-      break;
+  } else {
+    /* Load specific type */
+    private_key->pkcs = (SilcPKCSObject *)silc_pkcs_find_pkcs(type);
+    if (!private_key->pkcs) {
+      silc_free(data);
+      silc_free(private_key);
+      *ret_private_key = NULL;
+      SILC_LOG_ERROR(("Unsupported private key type"));
+      return FALSE;
     }
 
-    if (!data || !silc_pkcs_public_key_decode(data, len, public_key)) {
-      memset(old, 0, data_len);
-      silc_free(old);
-      return FALSE;
+    if (private_key->pkcs->import_private_key_file(
+					      private_key->pkcs,
+					      data, data_len,
+					      passphrase,
+					      passphrase_len,
+					      SILC_PKCS_FILE_BIN,
+					      &private_key->private_key,
+					      &private_key->alg)) {
+      silc_free(data);
+      return TRUE;
+    }
+
+    if (private_key->pkcs->import_private_key_file(
+					      private_key->pkcs,
+					      data, data_len,
+					      passphrase,
+					      passphrase_len,
+					      SILC_PKCS_FILE_BASE64,
+					      &private_key->private_key,
+					      &private_key->alg)) {
+      silc_free(data);
+      return TRUE;
     }
   }
 
-  memset(old, 0, data_len);
-  silc_free(old);
-  return TRUE;
+  silc_free(data);
+  silc_free(private_key);
+  *ret_private_key = NULL;
+  return FALSE;
 }
 
-/* Load private key from file and allocates new private key. Returns TRUE
-   if loading was successful. */
-/* XXX Should support encrypted private key files */
+/* Saves private key into a file */
 
-int silc_pkcs_load_private_key(char *filename, SilcPrivateKey *private_key,
-			       unsigned int encoding)
+SilcBool silc_pkcs_save_private_key(const char *filename,
+				    SilcPrivateKey private_key,
+				    const unsigned char *passphrase,
+				    SilcUInt32 passphrase_len,
+				    SilcPKCSFileEncoding encoding,
+				    SilcRng rng)
 {
-  unsigned char *cp, *old, *data, byte;
-  unsigned int i, data_len, len;
-
-  old = data = silc_file_read(filename, &data_len);
-  if (!data)
+  unsigned char *data;
+  SilcUInt32 data_len;
+  SilcStack stack;
+
+  stack = silc_stack_alloc(2048, silc_crypto_stack());
+
+  /* Export the private key file */
+  data = private_key->pkcs->export_private_key_file(private_key->pkcs, stack,
+						    private_key->private_key,
+						    passphrase,
+						    passphrase_len,
+						    encoding, rng, &data_len);
+  if (!data) {
+    silc_stack_free(stack);
     return FALSE;
-
-  /* Check start of file and remove header from the data. */
-  len = strlen(SILC_PKCS_PRIVATE_KEYFILE_BEGIN);
-  cp = data;
-  for (i = 0; i < len; i++) {
-    byte = cp[0];
-    cp++;
-    if (byte != SILC_PKCS_PRIVATE_KEYFILE_BEGIN[i]) {
-      memset(old, 0, data_len);
-      silc_free(old);
-    }
   }
-  data = cp;
-
-  /* Decode private key */
-  if (private_key) {
-    len = data_len - (strlen(SILC_PKCS_PRIVATE_KEYFILE_BEGIN) +
-		      strlen(SILC_PKCS_PRIVATE_KEYFILE_END));
-
-    switch(encoding) {
-    case SILC_PKCS_FILE_BIN:
-      break;
-    case SILC_PKCS_FILE_PEM:
-      data = silc_decode_pem(data, len, &len);
-      break;
-    }
 
-    if (!data || !silc_pkcs_private_key_decode(data, len, private_key)) {
-      memset(old, 0, data_len);
-      silc_free(old);
-      return FALSE;
-    }
+  /* Write to file */
+  if (silc_file_writefile(filename, data, data_len)) {
+    silc_sfree(stack, data);
+    silc_stack_free(stack);
+    return FALSE;
   }
 
-  memset(old, 0, data_len);
-  silc_free(old);
+  silc_sfree(stack, data);
+  silc_stack_free(stack);
   return TRUE;
 }
+
+/* Hash public key of any type. */
+
+SilcUInt32 silc_hash_public_key(void *key, void *user_context)
+{
+  SilcPublicKey public_key = key;
+  unsigned char *pk;
+  SilcUInt32 pk_len;
+  SilcUInt32 hash = 0;
+  SilcStack stack = NULL;
+
+  if (silc_crypto_stack())
+    stack = silc_stack_alloc(2048, silc_crypto_stack());
+
+  pk = silc_pkcs_public_key_encode(stack, public_key, &pk_len);
+  if (!pk) {
+    silc_stack_free(stack);
+    return hash;
+  }
+
+  hash = silc_hash_data(pk, SILC_32_TO_PTR(pk_len));
+
+  silc_sfree(stack, pk);
+  silc_stack_free(stack);
+
+  return hash;
+}
+
+/* Compares two SILC Public keys. It may be used as SilcHashTable
+   comparison function. */
+
+SilcBool silc_hash_public_key_compare(void *key1, void *key2,
+				      void *user_context)
+{
+  return silc_pkcs_public_key_compare(key1, key2);
+}