apps/silcd/silcd.c

   1 /*
   2
   3   silcd.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Created: Wed Mar 19 00:17:12 1997
  22  *
  23  * This is the main program for the SILC daemon. This parses command
  24  * line arguments and creates the server object.
  25  */
  26 /* $Id$ */
  27
  28 #include "serverincludes.h"
  29 #include "server_internal.h"
  30 #include "version.h"
  31
  32 static void silc_usage();
  33 static char *silc_server_create_identifier();
  34 static int
  35 silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
  36                             char *identifier,
  37                             SilcPublicKey *ret_pub_key,
  38                             SilcPrivateKey *ret_prv_key);
  39
  40 /* Long command line options */
  41 static struct option long_opts[] =
  42 {
  43   { "config-file", 1, NULL, 'f' },
  44   { "debug", 1, NULL, 'd' },
  45   { "help", 0, NULL, 'h' },
  46   { "version", 0, NULL,'V' },
  47
  48   /* Key management options */
  49   { "create-key-pair", 1, NULL, 'C' },
  50   { "pkcs", 1, NULL, 10 },
  51   { "bits", 1, NULL, 11 },
  52   { "identifier", 1, NULL, 12 },
  53
  54   { NULL, 0, NULL, 0 }
  55 };
  56
  57 /* Command line option variables */
  58 static bool opt_create_keypair = FALSE;
  59 static char *opt_keypath = NULL;
  60 static char *opt_pkcs = "rsa";
  61 static char *opt_identifier = NULL;
  62 static int opt_bits = 1024;
  63
  64 /* Prints out the usage of silc client */
  65
  66 static void silc_usage()
  67 {
  68   printf("\
  69 Usage: silcd [options]\n\
  70 \n\
  71   Generic Options:\n\
  72   -f  --config-file=FILE        Alternate configuration file\n\
  73   -d  --debug=string            Enable debugging (no daemon)\n\
  74   -h  --help                    Display this message\n\
  75   -V  --version                 Display version\n\
  76 \n\
  77   Key Management Options:\n\
  78   -C, --create-key-pair=PATH    Create new public key pair\n\
  79       --pkcs=PKCS               Set the PKCS of the public key pair\n\
  80       --bits=VALUE              Set length of the public key pair\n\
  81       --identifier=IDENTIFIER   Public key identifier\n\
  82 \n\
  83       The public key identifier may be of the following format:\n\
  84 \n\
  85       UN=<username>, HN=<hostname or IP>, RN=<real name>, E=<email>,\n\
  86       O=<organization>, C=<country>\n\
  87 \n\
  88       The UN and HN must be provided, the others are optional.  If the\n\
  89       --identifier option is not used an identifier will be created for\n\
  90       the public key automatically.\n\
  91 \n\
  92       Example identifier: \"UN=foobar, HN=foo.bar.com, RN=Foo T. Bar, \n\
  93                            E=foo@bar.com, C=FI\"\n\
  94 \n");
  95   exit(0);
  96 }
  97
  98 int main(int argc, char **argv)
  99 {
 100   int ret;
 101   int opt, option_index;
 102   char *config_file = NULL;
 103   SilcServer silcd;
 104   struct sigaction sa;
 105   char pid[10];
 106
 107   silc_debug = FALSE;
 108
 109   /* Parse command line arguments */
 110   if (argc > 1) {
 111     while ((opt = getopt_long(argc, argv, "cf:d:hVC:",
 112                               long_opts, &option_index)) != EOF) {
 113       switch(opt)
 114         {
 115         case 'h':
 116           silc_usage();
 117           break;
 118         case 'V':
 119           printf("SILCd Secure Internet Live Conferencing daemon, "
 120                  "version %s (base: SILC Toolkit %s)\n",
 121                  silc_dist_version, silc_version);
 122           printf("(c) 1997 - 2001 Pekka Riikonen "
 123                  "<priikone@silcnet.org>\n");
 124           exit(0);
 125           break;
 126         case 'd':
 127           silc_debug = TRUE;
 128           silc_debug_hexdump = TRUE;
 129           silc_log_set_debug_string(optarg);
 130 #ifndef SILC_DEBUG
 131           fprintf(stdout,
 132                   "Run-time debugging is not enabled. To enable it recompile\n"
 133                   "the server with --enable-debug configuration option.\n");
 134 #endif
 135           break;
 136         case 'f':
 137           config_file = strdup(optarg);
 138           break;
 139
 140           /*
 141            * Key management options
 142            */
 143         case 'C':
 144           opt_create_keypair = TRUE;
 145           if (optarg)
 146             opt_keypath = strdup(optarg);
 147           break;
 148         case 10:
 149           if (optarg)
 150             opt_pkcs = strdup(optarg);
 151           break;
 152         case 11:
 153           if (optarg)
 154             opt_bits = atoi(optarg);
 155           break;
 156         case 12:
 157           if (optarg)
 158             opt_identifier = strdup(optarg);
 159           break;
 160
 161         default:
 162           silc_usage();
 163           break;
 164         }
 165     }
 166   }
 167
 168   if (opt_create_keypair == TRUE) {
 169     /* Create new key pair and exit */
 170     silc_cipher_register_default();
 171     silc_pkcs_register_default();
 172     silc_hash_register_default();
 173     silc_hmac_register_default();
 174     silc_server_create_key_pair(opt_pkcs, opt_bits, opt_keypath,
 175                                 opt_identifier, NULL, NULL);
 176     exit(0);
 177   }
 178
 179   /* Default configuration file */
 180   if (!config_file)
 181     config_file = strdup(SILC_SERVER_CONFIG_FILE);
 182
 183   /* Create SILC Server object */
 184   ret = silc_server_alloc(&silcd);
 185   if (ret == FALSE)
 186     goto fail;
 187
 188   /* Read configuration files */
 189   silcd->config = silc_server_config_alloc(config_file);
 190   if (silcd->config == NULL)
 191     goto fail;
 192
 193   /* Initialize the server */
 194   ret = silc_server_init(silcd);
 195   if (ret == FALSE)
 196     goto fail;
 197
 198   /* Ignore SIGPIPE */
 199   sa.sa_handler = SIG_IGN;
 200   sa.sa_flags = 0;
 201   sigemptyset(&sa.sa_mask);
 202   sigaction(SIGPIPE, &sa, NULL);
 203
 204   if (silc_debug == FALSE)
 205     /* Before running the server, fork to background and set
 206        both user and group no non-root */
 207     silc_server_daemonise(silcd);
 208
 209   /* Set /var/run/silcd.pid */
 210   unlink(SILC_SERVER_PID_FILE);
 211   memset(pid, 0, sizeof(pid));
 212   snprintf(pid, sizeof(pid) - 1, "%d\n", getpid());
 213   silc_file_writefile(SILC_SERVER_PID_FILE, pid, strlen(pid));
 214
 215   /* Run the server. When this returns the server has been stopped
 216      and we will exit. */
 217   silc_server_run(silcd);
 218
 219   /* Stop the server. This probably has been done already but it
 220      doesn't hurt to do it here again. */
 221   silc_server_stop(silcd);
 222   silc_server_free(silcd);
 223
 224   exit(0);
 225  fail:
 226   exit(1);
 227 }
 228
 229 /* Returns identifier string for public key generation. */
 230
 231 static char *silc_server_create_identifier()
 232 {
 233   char *username = NULL, *realname = NULL;
 234   char hostname[256], email[256];
 235
 236   /* Get realname */
 237   realname = silc_get_real_name();
 238
 239   /* Get hostname */
 240   memset(hostname, 0, sizeof(hostname));
 241   gethostname(hostname, sizeof(hostname));
 242
 243   /* Get username (mandatory) */
 244   username = silc_get_username();
 245   if (!username)
 246     return NULL;
 247
 248   /* Create default email address, whether it is right or not */
 249   snprintf(email, sizeof(email), "%s@%s", username, hostname);
 250
 251   return silc_pkcs_encode_identifier(username, hostname, realname, email,
 252                                      NULL, NULL);
 253 }
 254
 255 /* Creates new public key and private key pair. This is used only
 256    when user wants to create new key pair from command line. */
 257
 258 static int
 259 silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
 260                             char *identifier,
 261                             SilcPublicKey *ret_pub_key,
 262                             SilcPrivateKey *ret_prv_key)
 263 {
 264   SilcPKCS pkcs;
 265   SilcPublicKey pub_key;
 266   SilcPrivateKey prv_key;
 267   SilcRng rng;
 268   unsigned char *key;
 269   uint32 key_len;
 270   char pkfile[256], prvfile[256];
 271
 272   if (!pkcs_name || !path)
 273     return FALSE;
 274
 275   if (!silc_pkcs_is_supported(pkcs_name)) {
 276     fprintf(stderr, "Unsupported PKCS `%s'", pkcs_name);
 277     return FALSE;
 278   }
 279
 280   if (!bits)
 281     bits = 1024;
 282
 283   if (!identifier)
 284     identifier = silc_server_create_identifier();
 285
 286   rng = silc_rng_alloc();
 287   silc_rng_init(rng);
 288   silc_rng_global_init(rng);
 289
 290   snprintf(pkfile, sizeof(pkfile) - 1, "%s%s", path,
 291            SILC_SERVER_PUBLIC_KEY_NAME);
 292   snprintf(prvfile, sizeof(prvfile) - 1, "%s%s", path,
 293            SILC_SERVER_PRIVATE_KEY_NAME);
 294
 295   /* Generate keys */
 296   silc_pkcs_alloc(pkcs_name, &pkcs);
 297   pkcs->pkcs->init(pkcs->context, bits, rng);
 298
 299   /* Save public key into file */
 300   key = silc_pkcs_get_public_key(pkcs, &key_len);
 301   pub_key = silc_pkcs_public_key_alloc(pkcs->pkcs->name, identifier,
 302                                        key, key_len);
 303   silc_pkcs_save_public_key(pkfile, pub_key, SILC_PKCS_FILE_PEM);
 304   if (ret_pub_key)
 305     *ret_pub_key = pub_key;
 306   else
 307     silc_pkcs_public_key_free(pub_key);
 308
 309   memset(key, 0, sizeof(key_len));
 310   silc_free(key);
 311
 312   /* Save private key into file */
 313   key = silc_pkcs_get_private_key(pkcs, &key_len);
 314   prv_key = silc_pkcs_private_key_alloc(pkcs->pkcs->name, key, key_len);
 315   silc_pkcs_save_private_key(prvfile, prv_key, NULL, SILC_PKCS_FILE_BIN);
 316   if (ret_prv_key)
 317     *ret_prv_key = prv_key;
 318   else
 319     silc_pkcs_private_key_free(prv_key);
 320
 321   printf("Public key has been saved into `%s'\n", pkfile);
 322   printf("Private key has been saved into `%s'\n", prvfile);
 323
 324   memset(key, 0, sizeof(key_len));
 325   silc_free(key);
 326
 327   silc_rng_free(rng);
 328   silc_pkcs_free(pkcs);
 329
 330   return TRUE;
 331 }