#include "rsa.h"
#include "pkcs1.h"
+#ifndef SILC_EPOC
/* Dynamically registered list of PKCS. */
SilcDList silc_pkcs_list = NULL;
+#define SILC_PKCS_LIST silc_pkcs_list
+#else
+#define SILC_PKCS_LIST TRUE
+#endif /* SILC_EPOC */
/* Static list of PKCS for silc_pkcs_register_default(). */
-SilcPKCSObject silc_default_pkcs[] =
+const SilcPKCSObject silc_default_pkcs[] =
{
/* RSA with PKCS #1 (Uses directly routines from Raw RSA operations) */
{ "rsa",
/* Register a new PKCS into SILC. This is used at the initialization of
the SILC. */
-bool silc_pkcs_register(SilcPKCSObject *pkcs)
+bool silc_pkcs_register(const SilcPKCSObject *pkcs)
{
+#ifndef SILC_EPOC
SilcPKCSObject *new;
SILC_LOG_DEBUG(("Registering new PKCS `%s'", pkcs->name));
silc_pkcs_list = silc_dlist_init();
silc_dlist_add(silc_pkcs_list, new);
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_pkcs_unregister(SilcPKCSObject *pkcs)
{
+#ifndef SILC_EPOC
SilcPKCSObject *entry;
SILC_LOG_DEBUG(("Unregistering PKCS"));
}
}
+#endif /* SILC_EPOC */
return FALSE;
}
bool silc_pkcs_register_default(void)
{
+#ifndef SILC_EPOC
int i;
for (i = 0; silc_default_pkcs[i].name; i++)
silc_pkcs_register(&(silc_default_pkcs[i]));
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs)
{
- SilcPKCSObject *entry;
+ SilcPKCSObject *entry = NULL;
SILC_LOG_DEBUG(("Allocating new PKCS object"));
+#ifndef SILC_EPOC
if (silc_pkcs_list) {
silc_dlist_start(silc_pkcs_list);
while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
- if (!strcmp(entry->name, name)) {
- *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
- (*new_pkcs)->pkcs = entry;
- (*new_pkcs)->context = silc_calloc(1, entry->context_len());
- (*new_pkcs)->get_key_len = silc_pkcs_get_key_len;
- return TRUE;
+ if (!strcmp(entry->name, name))
+ break;
+ }
+ }
+#else
+ {
+ /* On EPOC which don't have globals we check our constant hash list. */
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++) {
+ if (!strcmp(silc_default_pkcs[i].name, name)) {
+ entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+ break;
}
}
}
+#endif /* SILC_EPOC */
+
+ if (entry) {
+ *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
+ (*new_pkcs)->pkcs = entry;
+ (*new_pkcs)->context = silc_calloc(1, entry->context_len());
+ (*new_pkcs)->get_key_len = silc_pkcs_get_key_len;
+ return TRUE;
+ }
return FALSE;
}
int silc_pkcs_is_supported(const unsigned char *name)
{
+#ifndef SILC_EPOC
SilcPKCSObject *entry;
if (silc_pkcs_list) {
return TRUE;
}
}
-
+#else
+ {
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++)
+ if (!strcmp(silc_default_pkcs[i].name, name))
+ return TRUE;
+ }
+#endif /* SILC_EPOC */
return FALSE;
}
{
SilcPKCSObject *entry;
char *list = NULL;
- int len;
+ int len = 0;
- len = 0;
+#ifndef SILC_EPOC
if (silc_pkcs_list) {
silc_dlist_start(silc_pkcs_list);
while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
memcpy(list + len, ",", 1);
len++;
}
- list[len - 1] = 0;
}
+#else
+ {
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++) {
+ entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+ len += strlen(entry->name);
+ list = silc_realloc(list, len + 1);
+
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
+ memcpy(list + len, ",", 1);
+ len++;
+ }
+ }
+#endif /* SILC_EPOC */
+
+ list[len - 1] = 0;
return list;
}
+/* Generate new key pair into the `pkcs' context. */
+
+int silc_pkcs_generate_key(SilcPKCS pkcs, SilcUInt32 bits_key_len,
+ SilcRng rng)
+{
+ return pkcs->pkcs->init(pkcs->context, bits_key_len, rng);
+}
+
/* Returns the length of the key */
-uint32 silc_pkcs_get_key_len(SilcPKCS pkcs)
+SilcUInt32 silc_pkcs_get_key_len(SilcPKCS pkcs)
{
return pkcs->key_len;
}
/* Returns SILC style public key */
-unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, uint32 *len)
+unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, SilcUInt32 *len)
{
return pkcs->pkcs->get_public_key(pkcs->context, len);
}
/* Returns SILC style private key */
-unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, uint32 *len)
+unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, SilcUInt32 *len)
{
return pkcs->pkcs->get_private_key(pkcs->context, len);
}
/* Sets public key from SilcPublicKey. */
-uint32 silc_pkcs_public_key_set(SilcPKCS pkcs, SilcPublicKey public_key)
+SilcUInt32 silc_pkcs_public_key_set(SilcPKCS pkcs, SilcPublicKey public_key)
{
pkcs->key_len = pkcs->pkcs->set_public_key(pkcs->context, public_key->pk,
public_key->pk_len);
/* Sets public key from data. */
-uint32 silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
- uint32 pk_len)
+SilcUInt32 silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
+ SilcUInt32 pk_len)
{
pkcs->key_len = pkcs->pkcs->set_public_key(pkcs->context, pk, pk_len);
return pkcs->key_len;
/* Sets private key from data. */
int silc_pkcs_private_key_data_set(SilcPKCS pkcs, unsigned char *prv,
- uint32 prv_len)
+ SilcUInt32 prv_len)
{
return pkcs->pkcs->set_private_key(pkcs->context, prv, prv_len);
}
/* Encrypts */
-int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
- unsigned char *dst, uint32 *dst_len)
+int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, SilcUInt32 src_len,
+ unsigned char *dst, SilcUInt32 *dst_len)
{
return pkcs->pkcs->encrypt(pkcs->context, src, src_len, dst, dst_len);
}
/* Decrypts */
-int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
- unsigned char *dst, uint32 *dst_len)
+int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, SilcUInt32 src_len,
+ unsigned char *dst, SilcUInt32 *dst_len)
{
return pkcs->pkcs->decrypt(pkcs->context, src, src_len, dst, dst_len);
}
/* Generates signature */
-int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
- unsigned char *dst, uint32 *dst_len)
+int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, SilcUInt32 src_len,
+ unsigned char *dst, SilcUInt32 *dst_len)
{
return pkcs->pkcs->sign(pkcs->context, src, src_len, dst, dst_len);
}
/* Verifies signature */
int silc_pkcs_verify(SilcPKCS pkcs, unsigned char *signature,
- uint32 signature_len, unsigned char *data,
- uint32 data_len)
+ SilcUInt32 signature_len, unsigned char *data,
+ SilcUInt32 data_len)
{
return pkcs->pkcs->verify(pkcs->context, signature, signature_len,
data, data_len);
/* Generates signature with hash. The hash is signed. */
int silc_pkcs_sign_with_hash(SilcPKCS pkcs, SilcHash hash,
- unsigned char *src, uint32 src_len,
- unsigned char *dst, uint32 *dst_len)
+ unsigned char *src, SilcUInt32 src_len,
+ unsigned char *dst, SilcUInt32 *dst_len)
{
unsigned char hashr[32];
- uint32 hash_len;
+ SilcUInt32 hash_len;
int ret;
silc_hash_make(hash, src, src_len, hashr);
int silc_pkcs_verify_with_hash(SilcPKCS pkcs, SilcHash hash,
unsigned char *signature,
- uint32 signature_len,
+ SilcUInt32 signature_len,
unsigned char *data,
- uint32 data_len)
+ SilcUInt32 data_len)
{
unsigned char hashr[32];
- uint32 hash_len;
+ SilcUInt32 hash_len;
int ret;
silc_hash_make(hash, data, data_len, hashr);
{
SilcBuffer buf;
char *identifier;
- uint32 len, tlen = 0;
+ SilcUInt32 len, tlen = 0;
if (!username || !host)
return NULL;
SilcPublicKey silc_pkcs_public_key_alloc(char *name, char *identifier,
unsigned char *pk,
- uint32 pk_len)
+ SilcUInt32 pk_len)
{
SilcPublicKey public_key;
duplicated. */
SilcPrivateKey silc_pkcs_private_key_alloc(char *name, unsigned char *prv,
- uint32 prv_len)
+ SilcUInt32 prv_len)
{
SilcPrivateKey private_key;
data. */
unsigned char *
-silc_pkcs_public_key_encode(SilcPublicKey public_key, uint32 *len)
+silc_pkcs_public_key_encode(SilcPublicKey public_key, SilcUInt32 *len)
{
SilcBuffer buf;
unsigned char *ret;
/* Encodes SILC style public key. Returns the encoded data. */
unsigned char *
-silc_pkcs_public_key_data_encode(unsigned char *pk, uint32 pk_len,
+silc_pkcs_public_key_data_encode(unsigned char *pk, SilcUInt32 pk_len,
char *pkcs, char *identifier,
- uint32 *len)
+ SilcUInt32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- uint32 totlen;
+ SilcUInt32 totlen;
totlen = 4 + 2 + strlen(pkcs) + 2 + strlen(identifier) + pk_len;
buf = silc_buffer_alloc(totlen);
/* Decodes SILC style public key. Returns TRUE if the decoding was
successful. Allocates new public key as well. */
-int silc_pkcs_public_key_decode(unsigned char *data, uint32 data_len,
+int silc_pkcs_public_key_decode(unsigned char *data, SilcUInt32 data_len,
SilcPublicKey *public_key)
{
SilcBuffer buf;
SilcPKCS alg;
- uint16 pkcs_len, identifier_len;
- uint32 totlen, key_len;
+ SilcUInt16 pkcs_len, identifier_len;
+ SilcUInt32 totlen, key_len;
unsigned char *pkcs_name = NULL, *ident = NULL, *key_data = NULL;
int ret;
goto err;
/* See if we support this algorithm (check only if PKCS are registered) */
- if (silc_pkcs_list && !silc_pkcs_is_supported(pkcs_name)) {
+ if (SILC_PKCS_LIST && !silc_pkcs_is_supported(pkcs_name)) {
SILC_LOG_DEBUG(("Unknown PKCS %s", pkcs_name));
goto err;
}
/* 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.
(check only if PKCS are registered) */
- if (silc_pkcs_list) {
+ if (SILC_PKCS_LIST) {
silc_pkcs_alloc(pkcs_name, &alg);
if (!alg->pkcs->set_public_key(alg->context, key_data, key_len))
goto err;
/* Encodes SILC private key from SilcPrivateKey. Returns the encoded data. */
unsigned char *
-silc_pkcs_private_key_encode(SilcPrivateKey private_key, uint32 *len)
+silc_pkcs_private_key_encode(SilcPrivateKey private_key, SilcUInt32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- uint32 totlen;
+ SilcUInt32 totlen;
totlen = 2 + strlen(private_key->name) + private_key->prv_len;
buf = silc_buffer_alloc(totlen);
/* Encodes SILC private key. Returns the encoded data. */
unsigned char *
-silc_pkcs_private_key_data_encode(unsigned char *prv, uint32 prv_len,
- char *pkcs, uint32 *len)
+silc_pkcs_private_key_data_encode(unsigned char *prv, SilcUInt32 prv_len,
+ char *pkcs, SilcUInt32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- uint32 totlen;
+ SilcUInt32 totlen;
totlen = 2 + strlen(pkcs) + prv_len;
buf = silc_buffer_alloc(totlen);
/* Decodes SILC style public key. Returns TRUE if the decoding was
successful. Allocates new private key as well. */
-int silc_pkcs_private_key_decode(unsigned char *data, uint32 data_len,
+int silc_pkcs_private_key_decode(unsigned char *data, SilcUInt32 data_len,
SilcPrivateKey *private_key)
{
SilcBuffer buf;
SilcPKCS alg;
- uint16 pkcs_len;
- uint32 key_len;
+ SilcUInt16 pkcs_len;
+ SilcUInt32 key_len;
unsigned char *pkcs_name = NULL, *key_data = NULL;
int ret;
goto err;
/* See if we support this algorithm (check only if PKCS are registered). */
- if (silc_pkcs_list && !silc_pkcs_is_supported(pkcs_name)) {
+ if (SILC_PKCS_LIST && !silc_pkcs_is_supported(pkcs_name)) {
SILC_LOG_DEBUG(("Unknown PKCS `%s'", pkcs_name));
goto err;
}
/* 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.
(check only if PKCS are registered) */
- if (silc_pkcs_list) {
+ if (SILC_PKCS_LIST) {
silc_pkcs_alloc(pkcs_name, &alg);
if (!alg->pkcs->set_private_key(alg->context, key_data, key_len))
goto err;
static int silc_pkcs_save_public_key_internal(char *filename,
unsigned char *data,
- uint32 data_len,
- uint32 encoding)
+ SilcUInt32 data_len,
+ SilcUInt32 encoding)
{
SilcBuffer buf;
- uint32 len;
+ SilcUInt32 len;
switch(encoding) {
case SILC_PKCS_FILE_BIN:
/* Saves public key into file */
int silc_pkcs_save_public_key(char *filename, SilcPublicKey public_key,
- uint32 encoding)
+ SilcUInt32 encoding)
{
unsigned char *data;
- uint32 data_len;
+ SilcUInt32 data_len;
data = silc_pkcs_public_key_encode(public_key, &data_len);
return silc_pkcs_save_public_key_internal(filename, data, data_len,
/* Saves public key into file */
int silc_pkcs_save_public_key_data(char *filename, unsigned char *data,
- uint32 data_len,
- uint32 encoding)
+ SilcUInt32 data_len,
+ SilcUInt32 encoding)
{
return silc_pkcs_save_public_key_internal(filename, data, data_len,
encoding);
static int silc_pkcs_save_private_key_internal(char *filename,
unsigned char *data,
- uint32 data_len,
- uint32 encoding)
+ SilcUInt32 data_len,
+ SilcUInt32 encoding)
{
SilcBuffer buf;
- uint32 len;
+ SilcUInt32 len;
switch(encoding) {
case SILC_PKCS_FILE_BIN:
int silc_pkcs_save_private_key(char *filename, SilcPrivateKey private_key,
unsigned char *passphrase,
- uint32 encoding)
+ SilcUInt32 encoding)
{
unsigned char *data;
- uint32 data_len;
+ SilcUInt32 data_len;
data = silc_pkcs_private_key_encode(private_key, &data_len);
return silc_pkcs_save_private_key_internal(filename, data, data_len,
/* XXX The buffer should be encrypted if passphrase is provided. */
int silc_pkcs_save_private_key_data(char *filename, unsigned char *data,
- uint32 data_len,
+ SilcUInt32 data_len,
unsigned char *passphrase,
- uint32 encoding)
+ SilcUInt32 encoding)
{
return silc_pkcs_save_private_key_internal(filename, data, data_len,
encoding);
is loading was successful. */
int silc_pkcs_load_public_key(char *filename, SilcPublicKey *public_key,
- uint32 encoding)
+ SilcUInt32 encoding)
{
unsigned char *cp, *old, *data, byte;
- uint32 i, data_len, len;
+ SilcUInt32 i, data_len, len;
old = data = silc_file_readfile(filename, &data_len);
if (!data)
/* XXX Should support encrypted private key files */
int silc_pkcs_load_private_key(char *filename, SilcPrivateKey *private_key,
- uint32 encoding)
+ SilcUInt32 encoding)
{
unsigned char *cp, *old, *data, byte;
- uint32 i, data_len, len;
+ SilcUInt32 i, data_len, len;
old = data = silc_file_readfile(filename, &data_len);
if (!data)
projects / silc.git / blobdiff