tid/example/tids_main.c

   1 /*
   2  * Copyright (c) 2012, 2015, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include <talloc.h>
  39 #include <sqlite3.h>
  40 #include <argp.h>
  41 #include <poll.h>
  42
  43 #include <tr_debug.h>
  44 #include <tr_util.h>
  45 #include <tid_internal.h>
  46 #include <trust_router/tr_constraint.h>
  47 #include <trust_router/tr_dh.h>
  48 #include <openssl/rand.h>
  49
  50 static sqlite3 *db = NULL;
  51 static sqlite3_stmt *insert_stmt = NULL;
  52 static sqlite3_stmt *authorization_insert = NULL;
  53
  54 static int  create_key_id(char *out_id, size_t len)
  55 {
  56   unsigned char rand_buf[32];
  57   size_t bin_len;
  58   if (len <8)
  59     return -1;
  60   strncpy(out_id, "key-", len);
  61   len -= 4;
  62   out_id += 4;
  63   if (sizeof(rand_buf)*2+1 < len)
  64     len = sizeof(rand_buf)*2 + 1;
  65   bin_len = (len-1)/2;
  66   if (-1 == RAND_pseudo_bytes(rand_buf, bin_len))
  67       return -1;
  68   tr_bin_to_hex(rand_buf, bin_len, out_id, len);
  69   out_id[bin_len*2] = '\0';
  70   return 0;
  71 }
  72
  73 static int sqlify_wc(
  74                      TID_REQ *req,
  75                      const char **wc,
  76                      size_t len,
  77                      char **error)
  78 {
  79   size_t lc;
  80   *error = NULL;
  81   for (lc = 0; lc < len; lc++) {
  82     if (strchr(wc[lc], '%')) {
  83       *error = talloc_asprintf( req, "Constraint match `%s' is not appropriate for SQL",
  84                                   wc[lc]);
  85       return -1;
  86     }
  87     if ('*' ==wc[lc][0]) {
  88       char *s;
  89       s = talloc_strdup(req, wc[lc]);
  90       s[0] = '%';
  91       wc[lc] = s;
  92     }
  93   }
  94   return 0;
  95 }
  96
  97
  98
  99 static int handle_authorizations(TID_REQ *req, const unsigned char *dh_hash,
 100                                  size_t hash_len)
 101 {
 102   TR_CONSTRAINT_SET *intersected = NULL;
 103   const char **domain_wc, **realm_wc;
 104   size_t domain_len, realm_len;
 105   size_t domain_index, realm_index;
 106   char *error;
 107   int sqlite3_result;
 108
 109   if (!req->cons) {
 110     tr_debug("Request has no constraints, so no authorizations.");
 111     return 0;
 112   }
 113   intersected = tr_constraint_set_intersect(req, req->cons);
 114   if (!intersected)
 115     return -1;
 116   if (0 != tr_constraint_set_get_match_strings(req,
 117                                                intersected, "domain",
 118                                                &domain_wc, &domain_len))
 119     return -1;
 120   if (0 != tr_constraint_set_get_match_strings(req,
 121                                                intersected, "realm",
 122                                                &realm_wc, &realm_len))
 123     return -1;
 124   tr_debug(" %u domain constraint matches and %u realm constraint matches",
 125            (unsigned) domain_len, (unsigned) realm_len);
 126   if (0 != sqlify_wc(req, domain_wc, domain_len, &error)) {
 127     tr_debug("Processing domain constraints: %s", error);
 128     return -1;
 129   }else if (0 != sqlify_wc(req, realm_wc, realm_len, &error)) {
 130     tr_debug("Processing realm constraints: %s", error);
 131     return -1;
 132   }
 133   if (!authorization_insert) {
 134     tr_debug( " No database, no authorizations inserted");
 135     return 0;
 136   }
 137   for (domain_index = 0; domain_index < domain_len; domain_index++)
 138     for (realm_index = 0; realm_index < realm_len; realm_index++) {
 139       TR_NAME *community = req->orig_coi;
 140       if (!community)
 141         community = req->comm;
 142       sqlite3_bind_blob(authorization_insert, 1, dh_hash, hash_len, SQLITE_TRANSIENT);
 143       sqlite3_bind_text(authorization_insert, 2, community->buf, community->len, SQLITE_TRANSIENT);
 144       sqlite3_bind_text(authorization_insert, 3, realm_wc[realm_index], -1, SQLITE_TRANSIENT);
 145       sqlite3_bind_text(authorization_insert, 4, domain_wc[domain_index], -1, SQLITE_TRANSIENT);
 146       sqlite3_bind_text(authorization_insert, 5, req->comm->buf, req->comm->len, SQLITE_TRANSIENT);
 147       sqlite3_result = sqlite3_step(authorization_insert);
 148       if (SQLITE_DONE != sqlite3_result)
 149         tr_crit("sqlite3: failed to write to database");
 150       sqlite3_reset(authorization_insert);
 151       sqlite3_clear_bindings(authorization_insert);
 152     }
 153   return 0;
 154 }
 155
 156
 157 static int tids_req_handler (TIDS_INSTANCE *tids,
 158                       TID_REQ *req,
 159                       TID_RESP *resp,
 160                       void *cookie)
 161 {
 162   unsigned char *s_keybuf = NULL;
 163   int s_keylen = 0;
 164   char key_id[12];
 165   unsigned char *pub_digest=NULL;
 166   size_t pub_digest_len;
 167
 168
 169   tr_debug("tids_req_handler: Request received! target_realm = %s, community = %s", req->realm->buf, req->comm->buf);
 170   if (!(resp) || !resp) {
 171     tr_debug("tids_req_handler: No response structure.");
 172     return -1;
 173   }
 174
 175
 176   /* Allocate a new server block */
 177   tid_srvr_blk_add(resp->servers, tid_srvr_blk_new(resp));
 178   if (NULL==resp->servers) {
 179     tr_crit("tids_req_handler(): unable to allocate server block.");
 180     return -1;
 181   }
 182
 183   /* TBD -- Set up the server IP Address */
 184
 185   if (!(req) || !(req->tidc_dh)) {
 186     tr_debug("tids_req_handler(): No client DH info.");
 187     return -1;
 188   }
 189
 190   if ((!req->tidc_dh->p) || (!req->tidc_dh->g)) {
 191     tr_debug("tids_req_handler: NULL dh values.");
 192     return -1;
 193   }
 194
 195   /* Generate the server DH block based on the client DH block */
 196   // fprintf(stderr, "Generating the server DH block.\n");
 197   // fprintf(stderr, "...from client DH block, dh_g = %s, dh_p = %s.\n", BN_bn2hex(req->tidc_dh->g), BN_bn2hex(req->tidc_dh->p));
 198
 199   if (NULL == (resp->servers->aaa_server_dh = tr_create_matching_dh(NULL, 0, req->tidc_dh))) {
 200     tr_debug("tids_req_handler: Can't create server DH params.");
 201     return -1;
 202   }
 203
 204   resp->servers->aaa_server_addr=talloc_strdup(resp->servers, tids->ipaddr);
 205
 206   /* Set the key name */
 207   if (-1 == create_key_id(key_id, sizeof(key_id)))
 208     return -1;
 209   resp->servers->key_name = tr_new_name(key_id);
 210
 211   /* Generate the server key */
 212   // fprintf(stderr, "Generating the server key.\n");
 213
 214   if (0 > (s_keylen = tr_compute_dh_key(&s_keybuf,
 215                                         req->tidc_dh->pub_key,
 216                                         resp->servers->aaa_server_dh))) {
 217     tr_debug("tids_req_handler: Key computation failed.");
 218     return -1;
 219   }
 220   if (0 != tr_dh_pub_hash(req,
 221                           &pub_digest, &pub_digest_len)) {
 222     tr_debug("tids_req_handler: Unable to digest client public key");
 223     return -1;
 224   }
 225   if (0 != handle_authorizations(req, pub_digest, pub_digest_len))
 226     return -1;
 227   tid_srvr_blk_set_path(resp->servers, (TID_PATH *)(req->path));
 228
 229   if (req->expiration_interval < 1)
 230     req->expiration_interval = 1;
 231   g_get_current_time(&resp->servers->key_expiration);
 232   resp->servers->key_expiration.tv_sec += req->expiration_interval * 60 /*in minutes*/;
 233
 234   if (NULL != insert_stmt) {
 235     int sqlite3_result;
 236     gchar *expiration_str = g_time_val_to_iso8601(&resp->servers->key_expiration);
 237     sqlite3_bind_text(insert_stmt, 1, key_id, -1, SQLITE_TRANSIENT);
 238     sqlite3_bind_blob(insert_stmt, 2, s_keybuf, s_keylen, SQLITE_TRANSIENT);
 239     sqlite3_bind_blob(insert_stmt, 3, pub_digest, pub_digest_len, SQLITE_TRANSIENT);
 240     sqlite3_bind_text(insert_stmt, 4, expiration_str, -1, SQLITE_TRANSIENT);
 241     g_free(expiration_str); /* bind_text already made its own copy */
 242     sqlite3_result = sqlite3_step(insert_stmt);
 243     if (SQLITE_DONE != sqlite3_result)
 244       tr_crit("sqlite3: failed to write to database");
 245     sqlite3_reset(insert_stmt);
 246     sqlite3_clear_bindings(insert_stmt);
 247   }
 248
 249   /* Print out the key. */
 250   // fprintf(stderr, "tids_req_handler(): Server Key Generated (len = %d):\n", s_keylen);
 251   // for (i = 0; i < s_keylen; i++) {
 252   // fprintf(stderr, "%x", s_keybuf[i]);
 253   // }
 254   // fprintf(stderr, "\n");
 255
 256   if (s_keybuf!=NULL)
 257     free(s_keybuf);
 258
 259   if (pub_digest!=NULL)
 260     talloc_free(pub_digest);
 261
 262   return s_keylen;
 263 }
 264
 265 static int auth_handler(gss_name_t gss_name, TR_NAME *client,
 266                         void *expected_client)
 267 {
 268   TR_NAME *expected_client_trname = (TR_NAME*) expected_client;
 269   int result=tr_name_cmp(client, expected_client_trname);
 270   if (result != 0) {
 271     tr_notice("Auth denied for incorrect gss-name ('%.*s' requested, expected '%.*s').",
 272               client->len, client->buf,
 273               expected_client_trname->len, expected_client_trname->buf);
 274   }
 275   return result;
 276 }
 277
 278 static void print_version_info(void)
 279 {
 280   printf("Moonshot TID Server %s\n\n", PACKAGE_VERSION);
 281 }
 282
 283 /* command-line option setup */
 284
 285 /* argp global parameters */
 286 const char *argp_program_bug_address=PACKAGE_BUGREPORT; /* bug reporting address */
 287
 288 /* doc strings */
 289 static const char doc[]=PACKAGE_NAME " - Moonshot TID Server " PACKAGE_VERSION;
 290 static const char arg_doc[]="<ip-address> <gss-name> <hostname> <database-name>"; /* string describing arguments, if any */
 291
 292 /* define the options here. Fields are:
 293  * { long-name, short-name, variable name, options, help description } */
 294 static const struct argp_option cmdline_options[] = {
 295   { "version", 'v', NULL, 0, "Print version information and exit"},
 296   { NULL }
 297 };
 298
 299 /* structure for communicating with option parser */
 300 struct cmdline_args {
 301   char *ip_address;
 302   char *gss_name;
 303   char *hostname;
 304   char *database_name;
 305 };
 306
 307 /* parser for individual options - fills in a struct cmdline_args */
 308 static error_t parse_option(int key, char *arg, struct argp_state *state)
 309 {
 310   /* get a shorthand to the command line argument structure, part of state */
 311   struct cmdline_args *arguments=state->input;
 312
 313   switch (key) {
 314   case ARGP_KEY_ARG: /* handle argument (not option) */
 315     switch (state->arg_num) {
 316     case 0:
 317       arguments->ip_address=arg;
 318       break;
 319
 320     case 1:
 321       arguments->gss_name=arg;
 322       break;
 323
 324     case 2:
 325       arguments->hostname=arg;
 326       break;
 327
 328     case 3:
 329       arguments->database_name=arg;
 330       break;
 331
 332     default:
 333       /* too many arguments */
 334       argp_usage(state);
 335     }
 336     break;
 337
 338   case ARGP_KEY_END: /* no more arguments */
 339     if (state->arg_num < 4) {
 340       /* not enough arguments encountered */
 341       argp_usage(state);
 342     }
 343     break;
 344
 345   case 'v':
 346     print_version_info();
 347     exit(0);
 348
 349   default:
 350     return ARGP_ERR_UNKNOWN;
 351   }
 352
 353   return 0; /* success */
 354 }
 355
 356 /* assemble the argp parser */
 357 static struct argp argp = {cmdline_options, parse_option, arg_doc, doc};
 358
 359 int main (int argc,
 360           char *argv[])
 361 {
 362   TIDS_INSTANCE *tids;
 363   TR_NAME *gssname = NULL;
 364   struct cmdline_args opts={0};
 365
 366   /* parse the command line*/
 367   argp_parse(&argp, argc, argv, 0, 0, &opts);
 368
 369   print_version_info();
 370
 371   talloc_set_log_stderr();
 372
 373   /* Use standalone logging */
 374   tr_log_open();
 375
 376   /* set logging levels */
 377   tr_log_threshold(LOG_CRIT);
 378   tr_console_threshold(LOG_DEBUG);
 379
 380   gssname = tr_new_name(opts.gss_name);
 381   if (SQLITE_OK != sqlite3_open(opts.database_name, &db)) {
 382     tr_crit("Error opening database %s", opts.database_name);
 383     exit(1);
 384   }
 385   sqlite3_busy_timeout( db, 1000);
 386   sqlite3_prepare_v2(db, "insert into psk_keys_tab (keyid, key, client_dh_pub, key_expiration) values(?, ?, ?, ?)",
 387                      -1, &insert_stmt, NULL);
 388   sqlite3_prepare_v2(db, "insert into authorizations (client_dh_pub, coi, acceptor_realm, hostname, apc) values(?, ?, ?, ?, ?)",
 389                      -1, &authorization_insert, NULL);
 390
 391   /* Create a TID server instance */
 392   if (NULL == (tids = tids_create())) {
 393     tr_crit("Unable to create TIDS instance, exiting.");
 394     return 1;
 395   }
 396
 397   tids->ipaddr = opts.ip_address;
 398   (void) tids_start(tids, &tids_req_handler, auth_handler, opts.hostname, TID_PORT, gssname);
 399
 400   /* Clean-up the TID server instance */
 401   tids_destroy(tids);
 402
 403   return 1;
 404 }
 405