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
GNU General Public License for more details.
*/
+/* $Id$ */
-#include "silcincludes.h"
+#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 */
-#include "rsa.h"
+#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 */
-/* 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[] =
+/* 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 },
+ /* 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 */
- { NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL }
+ {
+ 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.
+/* Builtin PKCS algorithms */
+const SilcPKCSAlgorithm silc_default_pkcs_alg[] =
+{
+ /* 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
+ },
-*/
-int silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs)
+ /* 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
+ }
+};
+
+/* Register a new PKCS */
+
+SilcBool silc_pkcs_register(const SilcPKCSObject *pkcs)
{
- int i;
+#ifndef SILC_SYMBIAN
+ SilcPKCSObject *newpkcs;
- SILC_LOG_DEBUG(("Allocating new PKCS object"));
+ SILC_LOG_DEBUG(("Registering new PKCS"));
- for (i = 0; silc_pkcs_list[i].name; i++) {
- if (!strcmp(silc_pkcs_list[i].name, name))
- break;
+ /* 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;
+
+ /* Add to list */
+ if (silc_pkcs_list == NULL)
+ silc_pkcs_list = silc_dlist_init();
+ silc_dlist_add(silc_pkcs_list, newpkcs);
- *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
- if (*new_pkcs == NULL) {
- SILC_LOG_ERROR(("Could not allocate new PKCS object"));
+#endif /* SILC_SYMBIAN */
+ return TRUE;
+}
+
+/* Unregister a PKCS */
+
+SilcBool silc_pkcs_unregister(SilcPKCSObject *pkcs)
+{
+#ifndef SILC_SYMBIAN
+ SilcPKCSObject *entry;
+
+ SILC_LOG_DEBUG(("Unregistering PKCS"));
+
+ if (!silc_pkcs_list)
return FALSE;
- }
- /* 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;
+ 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);
- return TRUE;
+ if (silc_dlist_count(silc_pkcs_list) == 0) {
+ silc_dlist_uninit(silc_pkcs_list);
+ silc_pkcs_list = NULL;
+ }
+
+ return TRUE;
+ }
+ }
+
+#endif /* SILC_SYMBIAN */
+ return FALSE;
}
-/* Free's the PKCS object */
+/* Register algorithm */
-void silc_pkcs_free(SilcPKCS pkcs)
+SilcBool silc_pkcs_algorithm_register(const SilcPKCSAlgorithm *pkcs)
{
- if (pkcs)
- silc_free(pkcs->context);
+#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;
+ }
+ }
+
+ newalg = silc_calloc(1, sizeof(*newalg));
+ if (!newalg)
+ return FALSE;
+
+ *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;
+
+ /* Add to list */
+ if (silc_pkcs_alg_list == NULL)
+ silc_pkcs_alg_list = silc_dlist_init();
+ silc_dlist_add(silc_pkcs_alg_list, newalg);
+
+#endif /* SILC_SYMBIAN */
+ return TRUE;
}
-/* Return TRUE if PKCS algorithm `name' is supported. */
+/* Unregister algorithm */
-int silc_pkcs_is_supported(const unsigned char *name)
+SilcBool silc_pkcs_algorithm_unregister(SilcPKCSAlgorithm *pkcs)
{
- int i;
+#ifndef SILC_SYMBIAN
+ SilcPKCSAlgorithm*entry;
+
+ SILC_LOG_DEBUG(("Unregistering PKCS algorithm"));
+
+ if (!silc_pkcs_alg_list)
+ return FALSE;
+
+ 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);
+
+ if (silc_dlist_count(silc_pkcs_alg_list) == 0) {
+ silc_dlist_uninit(silc_pkcs_alg_list);
+ silc_pkcs_alg_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;
}
+/* Function that registers all the default PKCS and PKCS algorithms. */
+
+SilcBool silc_pkcs_register_default(void)
+{
+ /* We use builtin PKCS and algorithms */
+ return TRUE;
+}
+
+/* Unregister all PKCS and algorithms */
+
+SilcBool silc_pkcs_unregister_all(void)
+{
+#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;
+ }
+ }
+
+ 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;
+ }
+ }
+
+#endif /* SILC_SYMBIAN */
+ return TRUE;
+}
+
/* Returns comma separated list of supported PKCS algorithms */
-char *silc_pkcs_get_supported()
+char *silc_pkcs_get_supported(void)
{
+ SilcPKCSAlgorithm *entry, *entry2;
char *list = NULL;
- int i, len;
+ 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]);
- len = 0;
- for (i = 0; silc_pkcs_list[i].name; i++) {
- len += strlen(silc_pkcs_list[i].name);
+ 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 += strlen(entry->name);
list = silc_realloc(list, len + 1);
+ if (!list)
+ return NULL;
- memcpy(list + (len - strlen(silc_pkcs_list[i].name)),
- silc_pkcs_list[i].name, strlen(silc_pkcs_list[i].name));
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
memcpy(list + len, ",", 1);
len++;
}
return list;
}
-/* Returns the length of the key */
+/* Finds PKCS object */
-unsigned int silc_pkcs_get_key_len(SilcPKCS self)
+const SilcPKCSObject *silc_pkcs_find_pkcs(SilcPKCSType type)
{
- return self->key_len;
+ 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 */
+
+ for (i = 0; silc_default_pkcs[i].type; i++) {
+ entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+ if (entry->type == type)
+ return (const SilcPKCSObject *)entry;
+ }
+
+ return NULL;
}
-/* Returns SILC style public key */
+/* Finds PKCS algorithms object */
-unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, unsigned int *len)
+const SilcPKCSAlgorithm *silc_pkcs_find_algorithm(const char *algorithm,
+ const char *scheme)
{
- return pkcs->pkcs->get_public_key(pkcs->context, len);
+ SilcPKCSAlgorithm *entry;
+ int i;
+
+#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 NULL;
}
-/* Returns SILC style private key */
+/* Returns PKCS context */
-unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, unsigned int *len)
+const SilcPKCSObject *silc_pkcs_get_pkcs(void *key)
{
- return pkcs->pkcs->get_private_key(pkcs->context, len);
+ SilcPublicKey public_key = key;
+ return public_key->pkcs;
}
-/* Sets public key */
-/* XXX rewrite */
+/* Returns PKCS algorithm context */
-int silc_pkcs_set_public_key(SilcPKCS pkcs, unsigned char *pk,
- unsigned int pk_len)
+const SilcPKCSAlgorithm *silc_pkcs_get_algorithm(void *key)
{
- return pkcs->pkcs->set_public_key(pkcs->context, pk, pk_len);
+ SilcPublicKey public_key = key;
+ return public_key->alg;
}
-/* Sets private key */
+/* Return algorithm name */
-int silc_pkcs_set_private_key(SilcPKCS pkcs, unsigned char *prv,
- unsigned int prv_len)
+const char *silc_pkcs_get_name(void *key)
{
- return pkcs->pkcs->set_private_key(pkcs->context, prv, prv_len);
+ const SilcPKCSAlgorithm *pkcs = silc_pkcs_get_algorithm(key);
+ return pkcs->name;
}
-/* Saves public key into file */
+/* Returns PKCS type */
-int silc_pkcs_save_public_key(SilcPKCS pkcs, char *filename,
- unsigned char *pk, unsigned int pk_len)
+SilcPKCSType silc_pkcs_get_type(void *key)
{
- SilcBuffer buf;
- int ret = TRUE;
+ SilcPublicKey public_key = key;
+ return public_key->pkcs->type;
+}
- buf = silc_buffer_alloc(strlen(pkcs->pkcs->name) + 2 + pk_len
- + strlen(SILC_PKCS_PUBLIC_KEYFILE_BEGIN)
- + strlen(SILC_PKCS_PUBLIC_KEYFILE_END));
+/* Allocates new public key from the key data */
- silc_buffer_pull_tail(buf, SILC_BUFFER_END(buf));
+SilcBool silc_pkcs_public_key_alloc(SilcPKCSType type,
+ unsigned char *key,
+ SilcUInt32 key_len,
+ SilcPublicKey *ret_public_key)
+{
+ const SilcPKCSObject *pkcs;
+ SilcPublicKey public_key;
+
+ if (!ret_public_key)
+ return FALSE;
- silc_buffer_format(buf,
- SILC_STR_UI32_STRING(SILC_PKCS_PUBLIC_KEYFILE_BEGIN),
- SILC_STR_UI32_STRING(pkcs->pkcs->name),
- SILC_STR_UI_SHORT(pk_len),
- SILC_STR_UI_XNSTRING(pk, pk_len),
- SILC_STR_UI32_STRING(SILC_PKCS_PUBLIC_KEYFILE_END),
- SILC_STR_END);
+ /* Allocate public key context */
+ public_key = silc_calloc(1, sizeof(*public_key));
+ if (!public_key)
+ return FALSE;
- /* Save into a file */
- if (silc_file_write(filename, buf->data, buf->len)) {
- ret = FALSE;
- goto out;
+ pkcs = silc_pkcs_find_pkcs(type);
+ public_key->pkcs = (SilcPKCSObject *)pkcs;
+ if (!public_key->pkcs) {
+ silc_free(public_key);
+ return FALSE;
}
- out:
- silc_buffer_free(buf);
- return ret;
+ /* 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;
+}
+
+/* Frees the public key */
+
+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);
+}
+
+/* Exports public key */
+
+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);
+}
+
+/* Return key length */
+
+SilcUInt32 silc_pkcs_public_key_get_len(SilcPublicKey public_key)
+{
+ return public_key->pkcs->public_key_bitlen(public_key->pkcs,
+ public_key->public_key);
+}
+
+/* Returns internal PKCS public key context */
+
+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;
+}
+
+/* Returns internal PKCS private key context */
+
+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;
}
-/* XXX The buffer should be encrypted */
-/* XXX rewrite */
+/* Allocates new private key from key data */
-int silc_pkcs_save_private_key(SilcPKCS pkcs, char *filename,
- unsigned char *prv, unsigned int prv_len,
- char *passphrase)
+SilcBool silc_pkcs_private_key_alloc(SilcPKCSType type,
+ unsigned char *key,
+ SilcUInt32 key_len,
+ SilcPrivateKey *ret_private_key)
{
- SilcBuffer buf;
- int ret = TRUE;
+ const SilcPKCSObject *pkcs;
+ SilcPrivateKey private_key;
- buf = silc_buffer_alloc(strlen(pkcs->pkcs->name) + 2 + prv_len
- + strlen(SILC_PKCS_PRIVATE_KEYFILE_BEGIN)
- + strlen(SILC_PKCS_PRIVATE_KEYFILE_END));
- silc_buffer_pull_tail(buf, SILC_BUFFER_END(buf));
+ if (!ret_private_key)
+ return FALSE;
- silc_buffer_format(buf,
- SILC_STR_UI32_STRING(SILC_PKCS_PRIVATE_KEYFILE_BEGIN),
- SILC_STR_UI32_STRING(pkcs->pkcs->name),
- SILC_STR_UI_SHORT(prv_len),
- SILC_STR_UI_XNSTRING(prv, prv_len),
- SILC_STR_UI32_STRING(SILC_PKCS_PRIVATE_KEYFILE_END),
- SILC_STR_END);
+ /* Allocate private key context */
+ private_key = silc_calloc(1, sizeof(*private_key));
+ if (!private_key)
+ return FALSE;
- /* Save into a file */
- if (silc_file_write(filename, buf->data, buf->len)) {
- ret = FALSE;
- goto out;
+ pkcs = silc_pkcs_find_pkcs(type);
+ private_key->pkcs = (SilcPKCSObject *)pkcs;
+ if (!private_key->pkcs) {
+ silc_free(private_key);
+ return FALSE;
}
- out:
- silc_buffer_free(buf);
- return ret;
+ /* 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;
+ }
+
+ *ret_private_key = private_key;
+
+ return TRUE;
+}
+
+/* Return key length */
+
+SilcUInt32 silc_pkcs_private_key_get_len(SilcPrivateKey private_key)
+{
+ return private_key->pkcs->private_key_bitlen(private_key->pkcs,
+ private_key->private_key);
+}
+
+/* Frees the private key */
+
+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);
+}
+
+/* Encrypts */
+
+SilcAsyncOperation silc_pkcs_encrypt(SilcPublicKey public_key,
+ unsigned char *src, SilcUInt32 src_len,
+ SilcRng rng,
+ SilcPKCSEncryptCb encrypt_cb,
+ void *context)
+{
+ return public_key->pkcs->encrypt(public_key->pkcs,
+ public_key->public_key, src, src_len,
+ rng, encrypt_cb, context);
+}
+
+/* Decrypts */
+
+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);
+}
+
+/* Generates signature */
+
+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);
+}
+
+/* Verifies signature */
+
+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)
+{
+ return public_key->pkcs->verify(public_key->pkcs,
+ public_key->public_key, signature,
+ signature_len, data, data_len, hash, NULL,
+ verify_cb, context);
+}
+
+/* Compares two public keys and returns TRUE if they are same key, and
+ FALSE if they are not same. */
+
+SilcBool silc_pkcs_public_key_compare(SilcPublicKey key1, SilcPublicKey key2)
+{
+ if (key1->pkcs->type != key2->pkcs->type)
+ return FALSE;
+
+ return key1->pkcs->public_key_compare(key1->pkcs,
+ key1->public_key, key2->public_key);
+}
+
+/* Copies the public key indicated by `public_key' and returns new allocated
+ public key which is indentical to the `public_key'. */
+
+SilcPublicKey silc_pkcs_public_key_copy(SilcPublicKey public_key)
+{
+ SilcPublicKey key = silc_calloc(1, sizeof(*key));
+ if (!key)
+ return NULL;
+
+ 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;
+ }
+
+ return key;
+}
+
+/* Loads any kind of public key */
+
+SilcBool silc_pkcs_load_public_key(const char *filename,
+ SilcPKCSType type,
+ SilcPublicKey *ret_public_key)
+{
+ unsigned char *data;
+ SilcUInt32 data_len;
+ SilcPublicKey public_key;
+
+ SILC_LOG_DEBUG(("Loading public key file '%s'", filename));
+
+ if (!ret_public_key)
+ return FALSE;
+
+ data = silc_file_readfile(filename, &data_len, NULL);
+ if (!data) {
+ SILC_LOG_ERROR(("No such file: %s", filename));
+ return FALSE;
+ }
+
+ /* Allocate public key context */
+ *ret_public_key = public_key = silc_calloc(1, sizeof(*public_key));
+ if (!public_key) {
+ silc_free(data);
+ return FALSE;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+ }
+
+ silc_free(data);
+ silc_free(public_key);
+ *ret_public_key = NULL;
+ SILC_LOG_ERROR(("Unsupported public key type"));
+ return FALSE;
}
-/* Loads public key from file and allocates new PKCS object and
- sets the loaded key into it. */
+/* Saves public key into a file */
-int silc_pkcs_load_public_key(char *filename, SilcPKCS *ret_pkcs)
+SilcBool silc_pkcs_save_public_key(const char *filename,
+ SilcPublicKey public_key,
+ SilcPKCSFileEncoding encoding)
{
+ 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;
+ }
+
+ /* Write to file */
+ if (silc_file_writefile(filename, data, data_len)) {
+ silc_sfree(stack, data);
+ silc_stack_free(stack);
+ return FALSE;
+ }
+
+ silc_sfree(stack, data);
+ silc_stack_free(stack);
return TRUE;
}
-/* Loads private key from file and allocates new PKCS object and
- sets the loaded key into it. */
+/* Loads any kind of private key */
-int silc_pkcs_load_private_key(char *filename, SilcPKCS *ret_pkcs)
+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;
+ SilcUInt32 data_len;
+ SilcPrivateKey private_key;
+
+ SILC_LOG_DEBUG(("Loading private key file '%s'", filename));
+ if (!ret_private_key)
+ return FALSE;
+
+ data = silc_file_readfile(filename, &data_len, NULL);
+ if (!data) {
+ SILC_LOG_ERROR(("No such file: %s", filename));
+ return FALSE;
+ }
+
+ /* Allocate private key context */
+ *ret_private_key = private_key = silc_calloc(1, sizeof(*private_key));
+ if (!private_key) {
+ silc_free(data);
+ return FALSE;
+ }
+
+ 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;
+ }
+ }
+ } 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 (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;
+ }
+ }
+
+ silc_free(data);
+ silc_free(private_key);
+ *ret_private_key = NULL;
+ return FALSE;
+}
+
+/* Saves private key into a file */
+
+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 *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;
+ }
+
+ /* Write to file */
+ if (silc_file_writefile(filename, data, data_len)) {
+ silc_sfree(stack, data);
+ silc_stack_free(stack);
+ return FALSE;
+ }
+
+ 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);
+}
projects / silc.git / blobdiff