Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2002 - 2006 Pekka Riikonen
+ Copyright (C) 2002 - 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
/* Get hostname */
hostname = silc_net_localhost();
- if (!hostname)
+ if (!hostname) {
+ fprintf(stderr, "Could not resolve local hostname/IP address");
return NULL;
+ }
/* Get username (mandatory) */
username = silc_get_username();
- if (!username)
+ if (!username) {
+ fprintf(stderr, "Could not determine username");
return NULL;
+ }
/* Create default email address, whether it is right or not */
- snprintf(email, sizeof(email), "%s@%s", username, hostname);
+ silc_snprintf(email, sizeof(email), "%s@%s", username, hostname);
- ident = silc_pkcs_silc_encode_identifier(username, hostname, realname,
- email, NULL, NULL);
+ ident = silc_pkcs_silc_encode_identifier(NULL, username, hostname, realname,
+ email, NULL, NULL, NULL);
if (realname)
silc_free(realname);
silc_free(hostname);
char *alg = pkcs_name ? strdup(pkcs_name) : NULL;
char *identifier = pub_identifier ? strdup(pub_identifier) : NULL;
char *pass = passphrase ? strdup(passphrase) : NULL;
+ SilcPublicKey public_key;
+ SilcPrivateKey private_key;
if (interactive && (!alg || !pub_filename || !prv_filename))
printf("\
if (interactive) {
memset(line, 0, sizeof(line));
if (def)
- snprintf(line, sizeof(line), "Identifier [%s]: ", def);
+ silc_snprintf(line, sizeof(line), "Identifier [%s]: ", def);
else
- snprintf(line, sizeof(line),
+ silc_snprintf(line, sizeof(line),
"Identifier (eg. UN=jon, HN=jon.dummy.com, "
"RN=Jon Johnson, E=jon@dummy.com): ");
}
} else {
if (!def) {
- fprintf(stderr, "Could not create public key identifier: %s\n",
- strerror(errno));
+ fprintf(stderr, "Could not create public key identifier\n");
return FALSE;
}
identifier = strdup(def);
silc_free(def);
}
+ if (!strstr(identifier, "UN=") || !strstr(identifier, "HN=")) {
+ fprintf(stderr, "Invalid public key identifier. You must specify both "
+ "UN and HN\n");
+ return FALSE;
+ }
+
rng = silc_rng_alloc();
silc_rng_init(rng);
silc_rng_global_init(rng);
if (!pkfile) {
if (interactive) {
memset(line, 0, sizeof(line));
- snprintf(line, sizeof(line), "Public key filename [public_key.pub]: ");
+ silc_snprintf(line, sizeof(line), "Public key filename [public_key.pub]: ");
pkfile = silc_get_input(line, FALSE);
}
if (!pkfile)
if (!prvfile) {
if (interactive) {
memset(line, 0, sizeof(line));
- snprintf(line, sizeof(line), "Private key filename [private_key.prv]: ");
+ silc_snprintf(line, sizeof(line), "Private key filename [private_key.prv]: ");
prvfile = silc_get_input(line, FALSE);
}
if (!prvfile)
}
}
+ if (interactive)
+ printf("\nGenerating the key pair...\n");
+
/* Generate keys */
- if (!silc_pkcs_silc_generate_key(alg, "pkcs1-no-oid", key_len_bits,
- identifier, rng, return_public_key,
- return_private_key))
+ if (!silc_pkcs_silc_generate_key(alg, key_len_bits,
+ identifier, rng, &public_key,
+ &private_key))
return FALSE;
/* Save public key into file */
- silc_pkcs_save_public_key(pkfile, *return_public_key, SILC_PKCS_FILE_BASE64);
+ if (!silc_pkcs_save_public_key(pkfile, public_key, SILC_PKCS_FILE_BASE64))
+ return FALSE;
/* Save private key into file */
- silc_pkcs_save_private_key(prvfile, *return_private_key,
- (const unsigned char *)pass, strlen(pass),
- SILC_PKCS_FILE_BIN, rng);
+ if (!silc_pkcs_save_private_key(prvfile, private_key,
+ (const unsigned char *)pass, strlen(pass),
+ SILC_PKCS_FILE_BIN, rng))
+ return FALSE;
+
+ if (return_public_key)
+ *return_public_key = public_key;
+ else
+ silc_pkcs_public_key_free(public_key);
+
+ if (return_private_key)
+ *return_private_key = private_key;
+ else
+ silc_pkcs_private_key_free(private_key);
printf("Public key has been saved into `%s'.\n", pkfile);
printf("Private key has been saved into `%s'.\n", prvfile);
SILC_LOG_DEBUG(("Loading public and private keys"));
- if (!silc_pkcs_load_public_key(pub_filename, return_public_key)) {
+ if (!silc_pkcs_load_public_key(pub_filename,
+ SILC_PKCS_ANY, return_public_key)) {
if (pass)
memset(pass, 0, strlen(pass));
silc_free(pass);
if (!silc_pkcs_load_private_key(prv_filename,
(const unsigned char *)pass, strlen(pass),
+ SILC_PKCS_ANY,
return_private_key)) {
+ silc_pkcs_public_key_free(*return_public_key);
+ *return_public_key = NULL;
memset(pass, 0, strlen(pass));
silc_free(pass);
return FALSE;
/* Dump public key into stdout */
-SilcBool silc_show_public_key(const char *pub_filename)
+SilcBool silc_show_public_key(SilcPublicKey public_key)
{
- SilcPublicKey public_key;
SilcSILCPublicKey silc_pubkey;
SilcPublicKeyIdentifier ident;
char *fingerprint, *babbleprint;
SilcUInt32 pk_len;
SilcUInt32 key_len = 0;
- if (!silc_pkcs_load_public_key((char *)pub_filename, &public_key)) {
- fprintf(stderr, "Could not load public key file `%s'\n", pub_filename);
+ silc_pubkey = silc_pkcs_public_key_get_pkcs(SILC_PKCS_SILC, public_key);
+ if (!silc_pubkey)
return FALSE;
- }
-
- silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC, public_key);
- if (!silc_pubkey) {
- silc_pkcs_public_key_free(public_key);
- return FALSE;
- }
ident = &silc_pubkey->identifier;
key_len = silc_pkcs_public_key_get_len(public_key);
- pk = silc_pkcs_public_key_encode(public_key, &pk_len);
- if (!pk) {
- silc_pkcs_public_key_free(public_key);
+ pk = silc_pkcs_public_key_encode(NULL, public_key, &pk_len);
+ if (!pk)
return FALSE;
- }
fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
babbleprint = silc_hash_babbleprint(NULL, pk, pk_len);
- printf("Public key file : %s\n", pub_filename);
printf("Algorithm : %s\n", silc_pkcs_get_name(public_key));
if (key_len)
printf("Key length (bits) : %d\n", (unsigned int)key_len);
+ if (ident->version)
+ printf("Version : %s\n", ident->version);
if (ident->realname)
printf("Real name : %s\n", ident->realname);
if (ident->username)
silc_free(fingerprint);
silc_free(babbleprint);
silc_free(pk);
- silc_pkcs_public_key_free(public_key);
return TRUE;
}
+/* Dump public key into stdout */
+
+SilcBool silc_show_public_key_file(const char *pub_filename)
+{
+ SilcPublicKey public_key;
+ SilcBool ret;
+
+ if (!silc_pkcs_load_public_key((char *)pub_filename,
+ SILC_PKCS_ANY, &public_key)) {
+ fprintf(stderr, "Could not load public key file `%s'\n", pub_filename);
+ return FALSE;
+ }
+
+ printf("Public key file : %s\n", pub_filename);
+ ret = silc_show_public_key(public_key);
+ silc_pkcs_public_key_free(public_key);
+
+ return ret;
+}
+
/* Change private key passphrase */
SilcBool silc_change_private_key_passphrase(const char *prv_filename,
if (!silc_pkcs_load_private_key(prv_filename,
(const unsigned char *)pass, strlen(pass),
+ SILC_PKCS_ANY,
&private_key)) {
memset(pass, 0, strlen(pass));
silc_free(pass);
{ STAT(OPERATION_ALLOWED), "Operation is not allowed" },
{ STAT(BAD_SERVER), "Bad server name" },
{ STAT(BAD_USERNAME), "Bad user name" },
+ { STAT(NO_SUCH_PUBLIC_KEY), "Unknown public key" },
{ 0, NULL }
};
return FALSE;
cp = (char *)version + 5;
- if (!cp)
+ if (!cp || !(*cp))
return FALSE;
/* Take protocol version */
min = atoi(cp);
memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+ silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
if (protocol_version)
*protocol_version = atoi(buf);
memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
+ silc_snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
if (protocol_version_string)
*protocol_version_string = strdup(buf);
}
memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+ silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
if (software_version)
*software_version = atoi(buf);
memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
+ silc_snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
if (software_version_string)
*software_version_string = strdup(buf);
cp = strchr(cp, '.') + 1;
if (cp && *cp && vendor_version)
*vendor_version = strdup(cp);
+ } else if (strchr(cp, ' ')) {
+ cp = strchr(cp, ' ') + 1;
+ if (cp && *cp && vendor_version)
+ *vendor_version = strdup(cp);
}
return TRUE;
min = atoi(cp + 1);
memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+ silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
return (SilcUInt32)atoi(buf);
}
{
char tmp[100];
unsigned char tmps[2];
- char *cp;
memset(rid, 0, sizeof(rid));
switch(id_type) {
case SILC_ID_SERVER:
{
SilcServerID *server_id = (SilcServerID *)id;
- if (server_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, server_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, server_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
+
+ if (!silc_net_bin2addr(server_id->ip.data, server_id->ip.data_len,
+ tmp, sizeof(tmp)))
+ return NULL;
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(server_id->port));
+ silc_snprintf(tmp, sizeof(tmp) - 1, ",%d,", silc_ntohs(server_id->port));
_PUT_STRING(rid, tmp);
SILC_PUT16_MSB(server_id->rnd, tmps);
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
_PUT_STRING(rid, tmp);
}
break;
case SILC_ID_CLIENT:
{
SilcClientID *client_id = (SilcClientID *)id;
- if (client_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, client_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, client_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
+
+ if (!silc_net_bin2addr(client_id->ip.data, client_id->ip.data_len,
+ tmp, sizeof(tmp)))
+ return NULL;
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%02x,", client_id->rnd);
+ silc_snprintf(tmp, sizeof(tmp) - 1, ",%02x,", client_id->rnd);
_PUT_STRING(rid, tmp);
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x %02x %02x...]",
+ silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x %02x %02x...]",
client_id->hash[0], client_id->hash[1],
client_id->hash[2], client_id->hash[3]);
_PUT_STRING(rid, tmp);
case SILC_ID_CHANNEL:
{
SilcChannelID *channel_id = (SilcChannelID *)id;
- if (channel_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, channel_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, channel_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
+
+ if (!silc_net_bin2addr(channel_id->ip.data, channel_id->ip.data_len,
+ tmp, sizeof(tmp)))
+ return NULL;
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(channel_id->port));
+ silc_snprintf(tmp, sizeof(tmp) - 1, ",%d,",
+ silc_ntohs(channel_id->port));
_PUT_STRING(rid, tmp);
SILC_PUT16_MSB(channel_id->rnd, tmps);
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
_PUT_STRING(rid, tmp);
}
break;
projects / silc.git / blobdiff