usr.sbin/iscsid/chap.c

   1 /*-
   2  * Copyright (c) 2014 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Edward Tomasz Napierala under sponsorship
   6  * from the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <assert.h>
  35 #include <string.h>
  36 #include <netinet/in.h>
  37 #include <resolv.h>
  38 #include <openssl/err.h>
  39 #include <openssl/md5.h>
  40 #include <openssl/rand.h>
  41
  42 #include "iscsid.h"
  43
  44 static void
  45 chap_compute_md5(const char id, const char *secret,
  46     const void *challenge, size_t challenge_len, void *response,
  47     size_t response_len)
  48 {
  49         MD5_CTX ctx;
  50         int rv;
  51
  52         assert(response_len == MD5_DIGEST_LENGTH);
  53
  54         MD5_Init(&ctx);
  55         MD5_Update(&ctx, &id, sizeof(id));
  56         MD5_Update(&ctx, secret, strlen(secret));
  57         MD5_Update(&ctx, challenge, challenge_len);
  58         rv = MD5_Final(response, &ctx);
  59         if (rv != 1)
  60                 log_errx(1, "MD5_Final");
  61 }
  62
  63 static int
  64 chap_hex2int(const char hex)
  65 {
  66         switch (hex) {
  67         case '0':
  68                 return (0x00);
  69         case '1':
  70                 return (0x01);
  71         case '2':
  72                 return (0x02);
  73         case '3':
  74                 return (0x03);
  75         case '4':
  76                 return (0x04);
  77         case '5':
  78                 return (0x05);
  79         case '6':
  80                 return (0x06);
  81         case '7':
  82                 return (0x07);
  83         case '8':
  84                 return (0x08);
  85         case '9':
  86                 return (0x09);
  87         case 'a':
  88         case 'A':
  89                 return (0x0a);
  90         case 'b':
  91         case 'B':
  92                 return (0x0b);
  93         case 'c':
  94         case 'C':
  95                 return (0x0c);
  96         case 'd':
  97         case 'D':
  98                 return (0x0d);
  99         case 'e':
 100         case 'E':
 101                 return (0x0e);
 102         case 'f':
 103         case 'F':
 104                 return (0x0f);
 105         default:
 106                 return (-1);
 107         }
 108 }
 109
 110 static int
 111 chap_b642bin(const char *b64, void **binp, size_t *bin_lenp)
 112 {
 113         char *bin;
 114         int b64_len, bin_len;
 115
 116         b64_len = strlen(b64);
 117         bin_len = (b64_len + 3) / 4 * 3;
 118         bin = calloc(bin_len, 1);
 119         if (bin == NULL)
 120                 log_err(1, "calloc");
 121
 122         bin_len = b64_pton(b64, bin, bin_len);
 123         if (bin_len < 0) {
 124                 log_warnx("malformed base64 variable");
 125                 free(bin);
 126                 return (-1);
 127         }
 128         *binp = bin;
 129         *bin_lenp = bin_len;
 130         return (0);
 131 }
 132
 133 /*
 134  * XXX: Review this _carefully_.
 135  */
 136 static int
 137 chap_hex2bin(const char *hex, void **binp, size_t *bin_lenp)
 138 {
 139         int i, hex_len, nibble;
 140         bool lo = true; /* As opposed to 'hi'. */
 141         char *bin;
 142         size_t bin_off, bin_len;
 143
 144         if (strncasecmp(hex, "0b", strlen("0b")) == 0)
 145                 return (chap_b642bin(hex + 2, binp, bin_lenp));
 146
 147         if (strncasecmp(hex, "0x", strlen("0x")) != 0) {
 148                 log_warnx("malformed variable, should start with \"0x\""
 149                     " or \"0b\"");
 150                 return (-1);
 151         }
 152
 153         hex += strlen("0x");
 154         hex_len = strlen(hex);
 155         if (hex_len < 1) {
 156                 log_warnx("malformed variable; doesn't contain anything "
 157                     "but \"0x\"");
 158                 return (-1);
 159         }
 160
 161         bin_len = hex_len / 2 + hex_len % 2;
 162         bin = calloc(bin_len, 1);
 163         if (bin == NULL)
 164                 log_err(1, "calloc");
 165
 166         bin_off = bin_len - 1;
 167         for (i = hex_len - 1; i >= 0; i--) {
 168                 nibble = chap_hex2int(hex[i]);
 169                 if (nibble < 0) {
 170                         log_warnx("malformed variable, invalid char \"%c\"",
 171                             hex[i]);
 172                         free(bin);
 173                         return (-1);
 174                 }
 175
 176                 assert(bin_off < bin_len);
 177                 if (lo) {
 178                         bin[bin_off] = nibble;
 179                         lo = false;
 180                 } else {
 181                         bin[bin_off] |= nibble << 4;
 182                         bin_off--;
 183                         lo = true;
 184                 }
 185         }
 186
 187         *binp = bin;
 188         *bin_lenp = bin_len;
 189         return (0);
 190 }
 191
 192 #ifdef USE_BASE64
 193 static char *
 194 chap_bin2hex(const char *bin, size_t bin_len)
 195 {
 196         unsigned char *b64, *tmp;
 197         size_t b64_len;
 198
 199         b64_len = (bin_len + 2) / 3 * 4 + 3; /* +2 for "0b", +1 for '\0'. */
 200         b64 = malloc(b64_len);
 201         if (b64 == NULL)
 202                 log_err(1, "malloc");
 203
 204         tmp = b64;
 205         tmp += sprintf(tmp, "0b");
 206         b64_ntop(bin, bin_len, tmp, b64_len - 2);
 207
 208         return (b64);
 209 }
 210 #else
 211 static char *
 212 chap_bin2hex(const char *bin, size_t bin_len)
 213 {
 214         unsigned char *hex, *tmp, ch;
 215         size_t hex_len;
 216         size_t i;
 217
 218         hex_len = bin_len * 2 + 3; /* +2 for "0x", +1 for '\0'. */
 219         hex = malloc(hex_len);
 220         if (hex == NULL)
 221                 log_err(1, "malloc");
 222
 223         tmp = hex;
 224         tmp += sprintf(tmp, "0x");
 225         for (i = 0; i < bin_len; i++) {
 226                 ch = bin[i];
 227                 tmp += sprintf(tmp, "%02x", ch);
 228         }
 229
 230         return (hex);
 231 }
 232 #endif /* !USE_BASE64 */
 233
 234 struct chap *
 235 chap_new(void)
 236 {
 237         struct chap *chap;
 238         int rv;
 239
 240         chap = calloc(sizeof(*chap), 1);
 241         if (chap == NULL)
 242                 log_err(1, "calloc");
 243
 244         /*
 245          * Generate the challenge.
 246          */
 247         rv = RAND_bytes(chap->chap_challenge, sizeof(chap->chap_challenge));
 248         if (rv != 1) {
 249                 log_errx(1, "RAND_bytes failed: %s",
 250                     ERR_error_string(ERR_get_error(), NULL));
 251         }
 252         rv = RAND_bytes(&chap->chap_id, sizeof(chap->chap_id));
 253         if (rv != 1) {
 254                 log_errx(1, "RAND_bytes failed: %s",
 255                     ERR_error_string(ERR_get_error(), NULL));
 256         }
 257
 258         return (chap);
 259 }
 260
 261 char *
 262 chap_get_id(const struct chap *chap)
 263 {
 264         char *chap_i;
 265         int ret;
 266
 267         ret = asprintf(&chap_i, "%d", chap->chap_id);
 268         if (ret < 0)
 269                 log_err(1, "asprintf");
 270
 271         return (chap_i);
 272 }
 273
 274 char *
 275 chap_get_challenge(const struct chap *chap)
 276 {
 277         char *chap_c;
 278
 279         chap_c = chap_bin2hex(chap->chap_challenge,
 280             sizeof(chap->chap_challenge));
 281
 282         return (chap_c);
 283 }
 284
 285 static int
 286 chap_receive_bin(struct chap *chap, void *response, size_t response_len)
 287 {
 288
 289         if (response_len != sizeof(chap->chap_response)) {
 290                 log_debugx("got CHAP response with invalid length; "
 291                     "got %zd, should be %zd",
 292                     response_len, sizeof(chap->chap_response));
 293                 return (1);
 294         }
 295
 296         memcpy(chap->chap_response, response, response_len);
 297         return (0);
 298 }
 299
 300 int
 301 chap_receive(struct chap *chap, const char *response)
 302 {
 303         void *response_bin;
 304         size_t response_bin_len;
 305         int error;
 306
 307         error = chap_hex2bin(response, &response_bin, &response_bin_len);
 308         if (error != 0) {
 309                 log_debugx("got incorrectly encoded CHAP response \"%s\"",
 310                     response);
 311                 return (1);
 312         }
 313
 314         error = chap_receive_bin(chap, response_bin, response_bin_len);
 315         free(response_bin);
 316
 317         return (error);
 318 }
 319
 320 int
 321 chap_authenticate(struct chap *chap, const char *secret)
 322 {
 323         char expected_response[MD5_DIGEST_LENGTH];
 324
 325         chap_compute_md5(chap->chap_id, secret,
 326             chap->chap_challenge, sizeof(chap->chap_challenge),
 327             expected_response, sizeof(expected_response));
 328
 329         if (memcmp(chap->chap_response,
 330             expected_response, sizeof(expected_response)) != 0) {
 331                 return (-1);
 332         }
 333
 334         return (0);
 335 }
 336
 337 void
 338 chap_delete(struct chap *chap)
 339 {
 340
 341         free(chap);
 342 }
 343
 344 struct rchap *
 345 rchap_new(const char *secret)
 346 {
 347         struct rchap *rchap;
 348
 349         rchap = calloc(sizeof(*rchap), 1);
 350         if (rchap == NULL)
 351                 log_err(1, "calloc");
 352
 353         rchap->rchap_secret = checked_strdup(secret);
 354
 355         return (rchap);
 356 }
 357
 358 static void
 359 rchap_receive_bin(struct rchap *rchap, const unsigned char id,
 360     const void *challenge, size_t challenge_len)
 361 {
 362
 363         rchap->rchap_id = id;
 364         rchap->rchap_challenge = calloc(challenge_len, 1);
 365         if (rchap->rchap_challenge == NULL)
 366                 log_err(1, "calloc");
 367         memcpy(rchap->rchap_challenge, challenge, challenge_len);
 368         rchap->rchap_challenge_len = challenge_len;
 369 }
 370
 371 int
 372 rchap_receive(struct rchap *rchap, const char *id, const char *challenge)
 373 {
 374         unsigned char id_bin;
 375         void *challenge_bin;
 376         size_t challenge_bin_len;
 377
 378         int error;
 379
 380         id_bin = strtoul(id, NULL, 10);
 381
 382         error = chap_hex2bin(challenge, &challenge_bin, &challenge_bin_len);
 383         if (error != 0) {
 384                 log_debugx("got incorrectly encoded CHAP challenge \"%s\"",
 385                     challenge);
 386                 return (1);
 387         }
 388
 389         rchap_receive_bin(rchap, id_bin, challenge_bin, challenge_bin_len);
 390         free(challenge_bin);
 391
 392         return (0);
 393 }
 394
 395 static void
 396 rchap_get_response_bin(struct rchap *rchap,
 397     void **responsep, size_t *response_lenp)
 398 {
 399         void *response_bin;
 400         size_t response_bin_len = MD5_DIGEST_LENGTH;
 401
 402         response_bin = calloc(response_bin_len, 1);
 403         if (response_bin == NULL)
 404                 log_err(1, "calloc");
 405
 406         chap_compute_md5(rchap->rchap_id, rchap->rchap_secret,
 407             rchap->rchap_challenge, rchap->rchap_challenge_len,
 408             response_bin, response_bin_len);
 409
 410         *responsep = response_bin;
 411         *response_lenp = response_bin_len;
 412 }
 413
 414 char *
 415 rchap_get_response(struct rchap *rchap)
 416 {
 417         void *response;
 418         size_t response_len;
 419         char *chap_r;
 420
 421         rchap_get_response_bin(rchap, &response, &response_len);
 422         chap_r = chap_bin2hex(response, response_len);
 423         free(response);
 424
 425         return (chap_r);
 426 }
 427
 428 void
 429 rchap_delete(struct rchap *rchap)
 430 {
 431
 432         free(rchap->rchap_secret);
 433         free(rchap->rchap_challenge);
 434         free(rchap);
 435 }