git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/authenticate.c

   1 /*
   2  * Authenticate Director who is attempting to connect.
   3  *
   4  *   Kern Sibbald, October 2000
   5  *
   6  *   Version $Id$
   7  *
   8  */
   9 /*
  10    Copyright (C) 2000-2005 Kern Sibbald
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License
  14    version 2 as amended with additional clauses defined in the
  15    file LICENSE in the main source directory.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20    the file LICENSE for additional details.
  21
  22  */
  23
  24 #include "bacula.h"
  25 #include "filed.h"
  26
  27 static char OK_hello[]  = "2000 OK Hello\n";
  28 static char Dir_sorry[] = "2999 No go\n";
  29 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  30
  31 /*********************************************************************
  32  *
  33  */
  34 static int authenticate(int rcode, BSOCK *bs, JCR* jcr)
  35 {
  36    POOLMEM *dirname = get_pool_memory(PM_MESSAGE);
  37    DIRRES *director = NULL;
  38    int tls_local_need = BNET_TLS_NONE;
  39    int tls_remote_need = BNET_TLS_NONE;
  40    bool auth_success = false;
  41    alist *verify_list = NULL;
  42    btimer_t *tid = NULL;
  43
  44    if (rcode != R_DIRECTOR) {
  45       Dmsg1(50, "I only authenticate directors, not %d\n", rcode);
  46       Emsg1(M_FATAL, 0, _("I only authenticate directors, not %d\n"), rcode);
  47       goto auth_fatal;
  48    }
  49    if (bs->msglen < 25 || bs->msglen > 200) {
  50       Dmsg2(50, "Bad Hello command from Director at %s. Len=%d.\n",
  51             bs->who, bs->msglen);
  52       char addr[64];
  53       char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who : addr;
  54       Emsg2(M_FATAL, 0, _("Bad Hello command from Director at %s. Len=%d.\n"),
  55              who, bs->msglen);
  56       goto auth_fatal;
  57    }
  58    dirname = check_pool_memory_size(dirname, bs->msglen);
  59
  60    if (sscanf(bs->msg, "Hello Director %s calling\n", dirname) != 1) {
  61        char addr[64];
  62        char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who : addr;
  63       bs->msg[100] = 0;
  64       Dmsg2(50, "Bad Hello command from Director at %s: %s\n",
  65             bs->who, bs->msg);
  66       Emsg2(M_FATAL, 0, _("Bad Hello command from Director at %s: %s\n"),
  67             who, bs->msg);
  68       goto auth_fatal;
  69    }
  70    unbash_spaces(dirname);
  71    LockRes();
  72    foreach_res(director, R_DIRECTOR) {
  73       if (strcmp(director->hdr.name, dirname) == 0)
  74          break;
  75    }
  76    UnlockRes();
  77    if (!director) {
  78        char addr[64];
  79        char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who : addr;
  80       Emsg2(M_FATAL, 0, _("Connection from unknown Director %s at %s rejected.\n"),
  81             dirname, who);
  82       goto auth_fatal;
  83    }
  84
  85    if (have_tls) {
  86       /* TLS Requirement */
  87       if (director->tls_enable) {
  88          if (director->tls_require) {
  89             tls_local_need = BNET_TLS_REQUIRED;
  90          } else {
  91             tls_local_need = BNET_TLS_OK;
  92          }
  93       }
  94
  95       if (director->tls_verify_peer) {
  96          verify_list = director->tls_allowed_cns;
  97       }
  98    }
  99
 100    tid = start_bsock_timer(bs, AUTH_TIMEOUT);
 101    auth_success = cram_md5_auth(bs, director->password, tls_local_need);
 102    if (auth_success) {
 103       auth_success = cram_md5_get_auth(bs, director->password, &tls_remote_need);
 104       if (!auth_success) {
 105           char addr[64];
 106           char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who : addr;
 107           Dmsg1(50, "cram_get_auth failed for %s\n", who);
 108       }
 109    } else {
 110        char addr[64];
 111        char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who : addr;
 112        Dmsg1(50, "cram_auth failed for %s\n", who);
 113    }
 114    if (!auth_success) {
 115        Emsg1(M_FATAL, 0, _("Incorrect password given by Director at %s.\n"),
 116              bs->who);
 117        goto auth_fatal;
 118    }
 119
 120    /* Verify that the remote host is willing to meet our TLS requirements */
 121    if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 122       Emsg0(M_FATAL, 0, _("Authorization problem: Remote server did not"
 123            " advertize required TLS support.\n"));
 124       auth_success = false;
 125       goto auth_fatal;
 126    }
 127
 128    /* Verify that we are willing to meet the remote host's requirements */
 129    if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 130       Emsg0(M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
 131       auth_success = false;
 132       goto auth_fatal;
 133    }
 134
 135    if (have_tls) {
 136       if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
 137          /* Engage TLS! Full Speed Ahead! */
 138          if (!bnet_tls_server(director->tls_ctx, bs, verify_list)) {
 139             Emsg0(M_FATAL, 0, _("TLS negotiation failed.\n"));
 140             auth_success = false;
 141             goto auth_fatal;
 142          }
 143       }
 144    }
 145
 146 auth_fatal:
 147    if (tid) {
 148       stop_bsock_timer(tid);
 149       tid = NULL;
 150    }
 151    free_pool_memory(dirname);
 152    jcr->director = director;
 153    /* Single thread all failures to avoid DOS */
 154    if (auth_success) {
 155       P(mutex);
 156       bmicrosleep(6, 0);
 157       V(mutex);
 158    }
 159    return (director != NULL);
 160 }
 161
 162 /*
 163  * Inititiate the communications with the Director.
 164  * He has made a connection to our server.
 165  *
 166  * Basic tasks done here:
 167  *   We read Director's initial message and authorize him.
 168  *
 169  */
 170 int authenticate_director(JCR *jcr)
 171 {
 172    BSOCK *dir = jcr->dir_bsock;
 173
 174    if (!authenticate(R_DIRECTOR, dir, jcr)) {
 175       /* Single thread all failures to avoid DOS */
 176       P(mutex);
 177       bmicrosleep(6, 0);
 178       V(mutex);
 179       bnet_fsend(dir, "%s", Dir_sorry);
 180       Emsg0(M_FATAL, 0, _("Unable to authenticate Director\n"));
 181       return 0;
 182    }
 183    return bnet_fsend(dir, "%s", OK_hello);
 184 }
 185
 186 /*
 187  * First prove our identity to the Storage daemon, then
 188  * make him prove his identity.
 189  */
 190 int authenticate_storagedaemon(JCR *jcr)
 191 {
 192    BSOCK *sd = jcr->store_bsock;
 193    int tls_local_need = BNET_TLS_NONE;
 194    int tls_remote_need = BNET_TLS_NONE;
 195    bool auth_success = false;
 196
 197    btimer_t *tid = start_bsock_timer(sd, AUTH_TIMEOUT);
 198
 199    /* TLS Requirement */
 200    if (have_tls && me->tls_enable) {
 201       if (me->tls_require) {
 202          tls_local_need = BNET_TLS_REQUIRED;
 203       } else {
 204          tls_local_need = BNET_TLS_OK;
 205       }
 206    }
 207
 208    auth_success = cram_md5_get_auth(sd, jcr->sd_auth_key, &tls_remote_need);
 209    if (!auth_success) {
 210       Dmsg1(50, "cram_get_auth failed for %s\n", sd->who);
 211    } else {
 212       auth_success = cram_md5_auth(sd, jcr->sd_auth_key, tls_local_need);
 213       if (!auth_success) {
 214          Dmsg1(50, "cram_auth failed for %s\n", sd->who);
 215       }
 216    }
 217
 218    /* Destroy session key */
 219    memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
 220
 221    if (!auth_success) {
 222       Jmsg(jcr, M_FATAL, 0, _("Authorization key rejected by Storage daemon.\n"
 223        "Please see http://www.bacula.org/rel-manual/faq.html#AuthorizationErrors for help.\n"));
 224       goto auth_fatal;
 225    }
 226
 227    /* Verify that the remote host is willing to meet our TLS requirements */
 228    if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 229       Jmsg(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not"
 230            " advertise required TLS support.\n"));
 231       auth_success = false;
 232       goto auth_fatal;
 233    }
 234
 235    /* Verify that we are willing to meet the remote host's requirements */
 236    if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 237       Jmsg(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
 238       auth_success = false;
 239       goto auth_fatal;
 240    }
 241
 242    if (have_tls && tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
 243       /* Engage TLS! Full Speed Ahead! */
 244       if (!bnet_tls_client(me->tls_ctx, sd)) {
 245          Jmsg(jcr, M_FATAL, 0, _("TLS negotiation failed.\n"));
 246          auth_success = false;
 247          goto auth_fatal;
 248       }
 249    }
 250
 251 auth_fatal:
 252    stop_bsock_timer(tid);
 253    /* Single thread all failures to avoid DOS */
 254    if (!auth_success) {
 255       P(mutex);
 256       bmicrosleep(6, 0);
 257       V(mutex);
 258    }
 259    return auth_success;
 260 }