lustre/utils/gss/sk_utils.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (C) 2015, Trustees of Indiana University
  24  *
  25  * Copyright (c) 2016, 2017, Intel Corporation.
  26  *
  27  * Author: Jeremy Filizetti <jfilizet@iu.edu>
  28  */
  29
  30 #include <fcntl.h>
  31 #include <limits.h>
  32 #include <math.h>
  33 #include <string.h>
  34 #include <stdbool.h>
  35 #include <unistd.h>
  36 #include <openssl/dh.h>
  37 #include <openssl/engine.h>
  38 #include <openssl/err.h>
  39 #include <openssl/hmac.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42
  43 #include "sk_utils.h"
  44 #include "write_bytes.h"
  45
  46 #define SK_PBKDF2_ITERATIONS 10000
  47
  48 #ifdef _NEW_BUILD_
  49 # include "lgss_utils.h"
  50 #else
  51 # include "gss_util.h"
  52 # include "gss_oids.h"
  53 # include "err_util.h"
  54 #endif
  55
  56 #ifdef _ERR_UTIL_H_
  57 /**
  58  * Initializes logging
  59  * \param[in]   program         Program name to output
  60  * \param[in]   verbose         Verbose flag
  61  * \param[in]   fg              Whether or not to run in foreground
  62  *
  63  */
  64 void sk_init_logging(char *program, int verbose, int fg)
  65 {
  66         initerr(program, verbose, fg);
  67 }
  68 #endif
  69
  70 /**
  71  * Loads the key from \a filename and returns the struct sk_keyfile_config.
  72  * It should be freed by the caller.
  73  *
  74  * \param[in]   filename                Disk or key payload data
  75  *
  76  * \return      sk_keyfile_config       sucess
  77  * \return      NULL                    failure
  78  */
  79 struct sk_keyfile_config *sk_read_file(char *filename)
  80 {
  81         struct sk_keyfile_config *config;
  82         char *ptr;
  83         size_t rc;
  84         size_t remain;
  85         int fd;
  86
  87         config = malloc(sizeof(*config));
  88         if (!config) {
  89                 printerr(0, "Failed to allocate memory for config\n");
  90                 return NULL;
  91         }
  92
  93         /* allow standard input override */
  94         if (strcmp(filename, "-") == 0)
  95                 fd = STDIN_FILENO;
  96         else
  97                 fd = open(filename, O_RDONLY);
  98
  99         if (fd == -1) {
 100                 printerr(0, "Error opening key file '%s': %s\n", filename,
 101                          strerror(errno));
 102                 goto out_free;
 103         } else if (fd != STDIN_FILENO) {
 104                 struct stat st;
 105
 106                 rc = fstat(fd, &st);
 107                 if (rc == 0 && (st.st_mode & ~(S_IFREG | 0600)))
 108                         fprintf(stderr, "warning: "
 109                                 "secret key '%s' has insecure file mode %#o\n",
 110                                 filename, st.st_mode);
 111         }
 112
 113         ptr = (char *)config;
 114         remain = sizeof(*config);
 115         while (remain > 0) {
 116                 rc = read(fd, ptr, remain);
 117                 if (rc == -1) {
 118                         if (errno == EINTR)
 119                                 continue;
 120                         printerr(0, "read() failed on %s: %s\n", filename,
 121                                  strerror(errno));
 122                         goto out_close;
 123                 } else if (rc == 0) {
 124                         printerr(0, "File %s does not have a complete key\n",
 125                                  filename);
 126                         goto out_close;
 127                 }
 128                 ptr += rc;
 129                 remain -= rc;
 130         }
 131
 132         if (fd != STDIN_FILENO)
 133                 close(fd);
 134         sk_config_disk_to_cpu(config);
 135         return config;
 136
 137 out_close:
 138         close(fd);
 139 out_free:
 140         free(config);
 141         return NULL;
 142 }
 143
 144 /**
 145  * Checks if a key matching \a description is found in the keyring for
 146  * logging purposes and then attempts to load \a payload of \a psize into a key
 147  * with \a description.
 148  *
 149  * \param[in]   payload         Key payload
 150  * \param[in]   psize           Payload size
 151  * \param[in]   description     Description used for key in keyring
 152  *
 153  * \return      0       sucess
 154  * \return      -1      failure
 155  */
 156 static key_serial_t sk_load_key(const struct sk_keyfile_config *skc,
 157                                 const char *description)
 158 {
 159         struct sk_keyfile_config payload;
 160         key_serial_t key;
 161
 162         memcpy(&payload, skc, sizeof(*skc));
 163
 164         /* In the keyring use the disk layout so keyctl pipe can be used */
 165         sk_config_cpu_to_disk(&payload);
 166
 167         /* Check to see if a key is already loaded matching description */
 168         key = keyctl_search(KEY_SPEC_USER_KEYRING, "user", description, 0);
 169         if (key != -1)
 170                 printerr(2, "Key %d found in session keyring, replacing\n",
 171                          key);
 172
 173         key = add_key("user", description, &payload, sizeof(payload),
 174                       KEY_SPEC_USER_KEYRING);
 175         if (key != -1)
 176                 printerr(2, "Added key %d with description %s\n", key,
 177                          description);
 178         else
 179                 printerr(0, "Failed to add key with %s\n", description);
 180
 181         return key;
 182 }
 183
 184 /**
 185  * Reads the key from \a path, verifies it and loads into the session keyring
 186  * using a description determined by the the \a type.  Existing keys with the
 187  * same description are replaced.
 188  *
 189  * \param[in]   path    Path to key file
 190  * \param[in]   type    Type of key to load which determines the description
 191  *
 192  * \return      0       sucess
 193  * \return      -1      failure
 194  */
 195 int sk_load_keyfile(char *path)
 196 {
 197         struct sk_keyfile_config *config;
 198         char description[SK_DESCRIPTION_SIZE + 1];
 199         struct stat buf;
 200         int i;
 201         int rc;
 202         int rc2 = -1;
 203
 204         rc = stat(path, &buf);
 205         if (rc == -1) {
 206                 printerr(0, "stat() failed for file %s: %s\n", path,
 207                          strerror(errno));
 208                 return rc2;
 209         }
 210
 211         config = sk_read_file(path);
 212         if (!config)
 213                 return rc2;
 214
 215         /* Similar to ssh, require adequate care of key files */
 216         if (buf.st_mode & (S_IRGRP | S_IWGRP | S_IWOTH | S_IXOTH)) {
 217                 printerr(0, "Shared key files must be read/writeable only by "
 218                          "owner\n");
 219                 return -1;
 220         }
 221
 222         if (sk_validate_config(config))
 223                 goto out;
 224
 225         /* The server side can have multiple key files per file system so
 226          * the nodemap name is appended to the key description to uniquely
 227          * identify it */
 228         if (config->skc_type & SK_TYPE_MGS) {
 229                 /* Any key can be an MGS key as long as we are told to use it */
 230                 rc = snprintf(description, SK_DESCRIPTION_SIZE, "lustre:MGS:%s",
 231                               config->skc_nodemap);
 232                 if (rc >= SK_DESCRIPTION_SIZE)
 233                         goto out;
 234                 if (sk_load_key(config, description) == -1)
 235                         goto out;
 236         }
 237         if (config->skc_type & SK_TYPE_SERVER) {
 238                 /* Server keys need to have the file system name in the key */
 239                 if (!config->skc_fsname) {
 240                         printerr(0, "Key configuration has no file system "
 241                                  "attribute.  Can't load as server type\n");
 242                         goto out;
 243                 }
 244                 rc = snprintf(description, SK_DESCRIPTION_SIZE, "lustre:%s:%s",
 245                               config->skc_fsname, config->skc_nodemap);
 246                 if (rc >= SK_DESCRIPTION_SIZE)
 247                         goto out;
 248                 if (sk_load_key(config, description) == -1)
 249                         goto out;
 250         }
 251         if (config->skc_type & SK_TYPE_CLIENT) {
 252                 /* Load client file system key */
 253                 if (config->skc_fsname) {
 254                         rc = snprintf(description, SK_DESCRIPTION_SIZE,
 255                                       "lustre:%s", config->skc_fsname);
 256                         if (rc >= SK_DESCRIPTION_SIZE)
 257                                 goto out;
 258                         if (sk_load_key(config, description) == -1)
 259                                 goto out;
 260                 }
 261
 262                 /* Load client MGC keys */
 263                 for (i = 0; i < MAX_MGSNIDS; i++) {
 264                         if (config->skc_mgsnids[i] == LNET_NID_ANY)
 265                                 continue;
 266                         rc = snprintf(description, SK_DESCRIPTION_SIZE,
 267                                       "lustre:MGC%s",
 268                                       libcfs_nid2str(config->skc_mgsnids[i]));
 269                         if (rc >= SK_DESCRIPTION_SIZE)
 270                                 goto out;
 271                         if (sk_load_key(config, description) == -1)
 272                                 goto out;
 273                 }
 274         }
 275
 276         rc2 = 0;
 277
 278 out:
 279         free(config);
 280         return rc2;
 281 }
 282
 283 /**
 284  * Byte swaps config from cpu format to disk
 285  *
 286  * \param[in,out]       config          sk_keyfile_config to swap
 287  */
 288 void sk_config_cpu_to_disk(struct sk_keyfile_config *config)
 289 {
 290         int i;
 291
 292         if (!config)
 293                 return;
 294
 295         config->skc_version = htobe32(config->skc_version);
 296         config->skc_hmac_alg = htobe16(config->skc_hmac_alg);
 297         config->skc_crypt_alg = htobe16(config->skc_crypt_alg);
 298         config->skc_expire = htobe32(config->skc_expire);
 299         config->skc_shared_keylen = htobe32(config->skc_shared_keylen);
 300         config->skc_prime_bits = htobe32(config->skc_prime_bits);
 301
 302         for (i = 0; i < MAX_MGSNIDS; i++)
 303                 config->skc_mgsnids[i] = htobe64(config->skc_mgsnids[i]);
 304 }
 305
 306 /**
 307  * Byte swaps config from disk format to cpu
 308  *
 309  * \param[in,out]       config          sk_keyfile_config to swap
 310  */
 311 void sk_config_disk_to_cpu(struct sk_keyfile_config *config)
 312 {
 313         int i;
 314
 315         if (!config)
 316                 return;
 317
 318         config->skc_version = be32toh(config->skc_version);
 319         config->skc_hmac_alg = be16toh(config->skc_hmac_alg);
 320         config->skc_crypt_alg = be16toh(config->skc_crypt_alg);
 321         config->skc_expire = be32toh(config->skc_expire);
 322         config->skc_shared_keylen = be32toh(config->skc_shared_keylen);
 323         config->skc_prime_bits = be32toh(config->skc_prime_bits);
 324
 325         for (i = 0; i < MAX_MGSNIDS; i++)
 326                 config->skc_mgsnids[i] = be64toh(config->skc_mgsnids[i]);
 327 }
 328
 329 /**
 330  * Verifies the on key payload format is valid
 331  *
 332  * \param[in]   config          sk_keyfile_config
 333  *
 334  * \return      -1      failure
 335  * \return      0       success
 336  */
 337 int sk_validate_config(const struct sk_keyfile_config *config)
 338 {
 339         int i;
 340
 341         if (!config) {
 342                 printerr(0, "Null configuration passed\n");
 343                 return -1;
 344         }
 345
 346         if (config->skc_version != SK_CONF_VERSION) {
 347                 printerr(0, "Invalid version\n");
 348                 return -1;
 349         }
 350
 351         if (config->skc_hmac_alg == SK_HMAC_INVALID) {
 352                 printerr(0, "Invalid HMAC algorithm\n");
 353                 return -1;
 354         }
 355
 356         if (config->skc_crypt_alg == SK_CRYPT_INVALID) {
 357                 printerr(0, "Invalid crypt algorithm\n");
 358                 return -1;
 359         }
 360
 361         if (config->skc_expire < 60 || config->skc_expire > INT_MAX) {
 362                 /* Try to limit key expiration to some reasonable minimum and
 363                  * also prevent values over INT_MAX because there appears
 364                  * to be a type conversion issue */
 365                 printerr(0, "Invalid expiration time should be between %d "
 366                          "and %d\n", 60, INT_MAX);
 367                 return -1;
 368         }
 369         if (config->skc_prime_bits % 8 != 0 ||
 370             config->skc_prime_bits > SK_MAX_P_BYTES * 8) {
 371                 printerr(0, "Invalid session key length must be a multiple of 8"
 372                          " and less then %d bits\n",
 373                          SK_MAX_P_BYTES * 8);
 374                 return -1;
 375         }
 376         if (config->skc_shared_keylen % 8 != 0 ||
 377             config->skc_shared_keylen > SK_MAX_KEYLEN_BYTES * 8){
 378                 printerr(0, "Invalid shared key max length must be a multiple "
 379                          "of 8 and less then %d bits\n",
 380                          SK_MAX_KEYLEN_BYTES * 8);
 381                 return -1;
 382         }
 383
 384         /* Check for terminating nulls on strings */
 385         for (i = 0; i < sizeof(config->skc_fsname) &&
 386              config->skc_fsname[i] != '\0';  i++)
 387                 ; /* empty loop */
 388         if (i == sizeof(config->skc_fsname)) {
 389                 printerr(0, "File system name not null terminated\n");
 390                 return -1;
 391         }
 392
 393         for (i = 0; i < sizeof(config->skc_nodemap) &&
 394              config->skc_nodemap[i] != '\0';  i++)
 395                 ; /* empty loop */
 396         if (i == sizeof(config->skc_nodemap)) {
 397                 printerr(0, "Nodemap name not null terminated\n");
 398                 return -1;
 399         }
 400
 401         if (config->skc_type == SK_TYPE_INVALID) {
 402                 printerr(0, "Invalid key type\n");
 403                 return -1;
 404         }
 405
 406         return 0;
 407 }
 408
 409 /**
 410  * Hashes \a string and places the hash in \a hash
 411  * at \a hash
 412  *
 413  * \param[in]           string          Null terminated string to hash
 414  * \param[in]           hash_alg        OpenSSL EVP_MD to use for hash
 415  * \param[in,out]       hash            gss_buffer_desc to hold the result
 416  *
 417  * \return      -1      failure
 418  * \return      0       success
 419  */
 420 static int sk_hash_string(const char *string, const EVP_MD *hash_alg,
 421                           gss_buffer_desc *hash)
 422 {
 423         EVP_MD_CTX *ctx = EVP_MD_CTX_create();
 424         size_t len = strlen(string);
 425         unsigned int hashlen;
 426
 427         if (!hash->value || hash->length < EVP_MD_size(hash_alg))
 428                 goto out_err;
 429         if (!EVP_DigestInit_ex(ctx, hash_alg, NULL))
 430                 goto out_err;
 431         if (!EVP_DigestUpdate(ctx, string, len))
 432                 goto out_err;
 433         if (!EVP_DigestFinal_ex(ctx, hash->value, &hashlen))
 434                 goto out_err;
 435
 436         EVP_MD_CTX_destroy(ctx);
 437         hash->length = hashlen;
 438         return 0;
 439
 440 out_err:
 441         EVP_MD_CTX_destroy(ctx);
 442         return -1;
 443 }
 444
 445 /**
 446  * Hashes \a string and verifies the resulting hash matches the value
 447  * in \a current_hash
 448  *
 449  * \param[in]           string          Null terminated string to hash
 450  * \param[in]           hash_alg        OpenSSL EVP_MD to use for hash
 451  * \param[in,out]       current_hash    gss_buffer_desc to compare to
 452  *
 453  * \return      gss error       failure
 454  * \return      GSS_S_COMPLETE  success
 455  */
 456 uint32_t sk_verify_hash(const char *string, const EVP_MD *hash_alg,
 457                         const gss_buffer_desc *current_hash)
 458 {
 459         gss_buffer_desc hash;
 460         unsigned char hashbuf[EVP_MAX_MD_SIZE];
 461
 462         hash.value = hashbuf;
 463         hash.length = sizeof(hashbuf);
 464
 465         if (sk_hash_string(string, hash_alg, &hash))
 466                 return GSS_S_FAILURE;
 467         if (current_hash->length != hash.length)
 468                 return GSS_S_DEFECTIVE_TOKEN;
 469         if (memcmp(current_hash->value, hash.value, hash.length))
 470                 return GSS_S_BAD_SIG;
 471
 472         return GSS_S_COMPLETE;
 473 }
 474
 475 static inline int sk_config_has_mgsnid(struct sk_keyfile_config *config,
 476                                        const char *mgsnid)
 477 {
 478         lnet_nid_t nid;
 479         int i;
 480
 481         nid = libcfs_str2nid(mgsnid);
 482         if (nid == LNET_NID_ANY)
 483                 return 0;
 484
 485         for (i = 0; i < MAX_MGSNIDS; i++)
 486                 if  (config->skc_mgsnids[i] == nid)
 487                         return 1;
 488         return 0;
 489 }
 490
 491 /**
 492  * Create an sk_cred structure populated with initial configuration info and the
 493  * key.  \a tgt and \a nodemap are used in determining the expected key
 494  * description so the key can be found by searching the keyring.
 495  * This is done because there is no easy way to pass keys from the mount command
 496  * all the way to the request_key call.  In addition any keys can be dynamically
 497  * added to the keyrings and still found.  The keyring that needs to be used
 498  * must be the session keyring.
 499  *
 500  * \param[in]   tgt             Target file system
 501  * \param[in]   nodemap         Cluster name for the key.  This correlates to
 502  *                              the nodemap name and is used by the server side.
 503  *                              For the client this will be NULL.
 504  * \param[in]   flags           Flags for the credentials
 505  *
 506  * \return      sk_cred Allocated struct sk_cred on success
 507  * \return      NULL    failure
 508  */
 509 struct sk_cred *sk_create_cred(const char *tgt, const char *nodemap,
 510                                const uint32_t flags)
 511 {
 512         struct sk_keyfile_config *config;
 513         struct sk_kernel_ctx *kctx;
 514         struct sk_cred *skc = NULL;
 515         char description[SK_DESCRIPTION_SIZE + 1];
 516         char fsname[MTI_NAME_MAXLEN + 1];
 517         const char *mgsnid = NULL;
 518         char *ptr;
 519         long sk_key;
 520         int keylen;
 521         int len;
 522         int rc;
 523
 524         printerr(2, "Creating credentials for target: %s with nodemap: %s\n",
 525                  tgt, nodemap);
 526
 527         memset(description, 0, sizeof(description));
 528         memset(fsname, 0, sizeof(fsname));
 529
 530         /* extract the file system name from target */
 531         ptr = index(tgt, '-');
 532         if (!ptr) {
 533                 len = strlen(tgt);
 534
 535                 /* This must be an MGC target */
 536                 if (strncmp(tgt, "MGC", 3) || len <= 3) {
 537                         printerr(0, "Invalid target name\n");
 538                         return NULL;
 539                 }
 540                 mgsnid = tgt + 3;
 541         } else {
 542                 len = ptr - tgt;
 543         }
 544
 545         if (len > MTI_NAME_MAXLEN) {
 546                 printerr(0, "Invalid target name\n");
 547                 return NULL;
 548         }
 549         memcpy(fsname, tgt, len);
 550
 551         if (nodemap) {
 552                 if (mgsnid)
 553                         rc = snprintf(description, SK_DESCRIPTION_SIZE,
 554                                       "lustre:MGS:%s", nodemap);
 555                 else
 556                         rc = snprintf(description, SK_DESCRIPTION_SIZE,
 557                                       "lustre:%s:%s", fsname, nodemap);
 558         } else {
 559                 rc = snprintf(description, SK_DESCRIPTION_SIZE, "lustre:%s",
 560                               fsname);
 561         }
 562
 563         if (rc >= SK_DESCRIPTION_SIZE) {
 564                 printerr(0, "Invalid key description\n");
 565                 return NULL;
 566         }
 567
 568         /* It may be a good idea to move Lustre keys to the gss_keyring
 569          * (lgssc) type so that they expire when Lustre modules are removed.
 570          * Unfortunately it can't be done at mount time because the mount
 571          * syscall could trigger the Lustre modules to load and until that
 572          * point we don't have a lgssc key type.
 573          *
 574          * TODO: Query the community for a consensus here  */
 575         printerr(2, "Searching for key with description: %s\n", description);
 576         sk_key = keyctl_search(KEY_SPEC_USER_KEYRING, "user",
 577                                description, 0);
 578         if (sk_key == -1) {
 579                 printerr(1, "No key found for %s\n", description);
 580                 return NULL;
 581         }
 582
 583         keylen = keyctl_read_alloc(sk_key, (void **)&config);
 584         if (keylen == -1) {
 585                 printerr(0, "keyctl_read() failed for key %ld: %s\n", sk_key,
 586                          strerror(errno));
 587                 return NULL;
 588         } else if (keylen != sizeof(*config)) {
 589                 printerr(0, "Unexpected key size: %d returned for key %ld, "
 590                          "expected %zu bytes\n",
 591                          keylen, sk_key, sizeof(*config));
 592                 goto out_err;
 593         }
 594
 595         sk_config_disk_to_cpu(config);
 596
 597         if (sk_validate_config(config)) {
 598                 printerr(0, "Invalid key configuration for key: %ld\n", sk_key);
 599                 goto out_err;
 600         }
 601
 602         if (mgsnid && !sk_config_has_mgsnid(config, mgsnid)) {
 603                 printerr(0, "Target name does not match key's MGS NIDs\n");
 604                 goto out_err;
 605         }
 606
 607         if (!mgsnid && strcmp(fsname, config->skc_fsname)) {
 608                 printerr(0, "Target name does not match key's file system\n");
 609                 goto out_err;
 610         }
 611
 612         skc = malloc(sizeof(*skc));
 613         if (!skc) {
 614                 printerr(0, "Failed to allocate memory for sk_cred\n");
 615                 goto out_err;
 616         }
 617
 618         /* this initializes all gss_buffer_desc to empty as well */
 619         memset(skc, 0, sizeof(*skc));
 620
 621         skc->sc_flags = flags;
 622         skc->sc_tgt.length = strlen(tgt) + 1;
 623         skc->sc_tgt.value = malloc(skc->sc_tgt.length);
 624         if (!skc->sc_tgt.value) {
 625                 printerr(0, "Failed to allocate memory for target\n");
 626                 goto out_err;
 627         }
 628         memcpy(skc->sc_tgt.value, tgt, skc->sc_tgt.length);
 629
 630         skc->sc_nodemap_hash.length = EVP_MD_size(EVP_sha256());
 631         skc->sc_nodemap_hash.value = malloc(skc->sc_nodemap_hash.length);
 632         if (!skc->sc_nodemap_hash.value) {
 633                 printerr(0, "Failed to allocate memory for nodemap hash\n");
 634                 goto out_err;
 635         }
 636
 637         if (sk_hash_string(config->skc_nodemap, EVP_sha256(),
 638                            &skc->sc_nodemap_hash)) {
 639                 printerr(0, "Failed to generate hash for nodemap name\n");
 640                 goto out_err;
 641         }
 642
 643         kctx = &skc->sc_kctx;
 644         kctx->skc_version = config->skc_version;
 645         strcpy(kctx->skc_hmac_alg, sk_hmac2name(config->skc_hmac_alg));
 646         strcpy(kctx->skc_crypt_alg, sk_crypt2name(config->skc_crypt_alg));
 647         kctx->skc_expire = config->skc_expire;
 648
 649         /* key payload format is in bits, convert to bytes */
 650         kctx->skc_shared_key.length = config->skc_shared_keylen / 8;
 651         kctx->skc_shared_key.value = malloc(kctx->skc_shared_key.length);
 652         if (!kctx->skc_shared_key.value) {
 653                 printerr(0, "Failed to allocate memory for shared key\n");
 654                 goto out_err;
 655         }
 656         memcpy(kctx->skc_shared_key.value, config->skc_shared_key,
 657                kctx->skc_shared_key.length);
 658
 659         skc->sc_p.length = config->skc_prime_bits / 8;
 660         skc->sc_p.value = malloc(skc->sc_p.length);
 661         if (!skc->sc_p.value) {
 662                 printerr(0, "Failed to allocate p\n");
 663                 goto out_err;
 664         }
 665         memcpy(skc->sc_p.value, config->skc_p, skc->sc_p.length);
 666
 667         free(config);
 668
 669         return skc;
 670
 671 out_err:
 672         sk_free_cred(skc);
 673
 674         free(config);
 675         return NULL;
 676 }
 677
 678 /**
 679  * Populates the DH parameters for the DHKE
 680  *
 681  * \param[in,out]       skc             Shared key credentials structure to
 682  *                                      populate with DH parameters
 683  *
 684  * \retval      GSS_S_COMPLETE  success
 685  * \retval      GSS_S_FAILURE   failure
 686  */
 687 uint32_t sk_gen_params(struct sk_cred *skc)
 688 {
 689         uint32_t random;
 690         BIGNUM *p, *g;
 691         const BIGNUM *pub_key;
 692         int rc;
 693
 694         /* Random value used by both the request and response as part of the
 695          * key binding material.  This also should ensure we have unqiue
 696          * tokens that are sent to the remote server which is important because
 697          * the token is hashed for the sunrpc cache lookups and a failure there
 698          * would cause connection attempts to fail indefinitely due to the large
 699          * timeout value on the server side */
 700         if (RAND_bytes((unsigned char *)&random, sizeof(random)) != 1) {
 701                 printerr(0, "Failed to get data for random parameter: %s\n",
 702                          ERR_error_string(ERR_get_error(), NULL));
 703                 return GSS_S_FAILURE;
 704         }
 705
 706         /* The random value will always be used in byte range operations
 707          * so we keep it as big endian from this point on */
 708         skc->sc_kctx.skc_host_random = random;
 709
 710         /* Populate DH parameters */
 711         skc->sc_params = DH_new();
 712         if (!skc->sc_params) {
 713                 printerr(0, "Failed to allocate DH\n");
 714                 return GSS_S_FAILURE;
 715         }
 716
 717         p = BN_bin2bn(skc->sc_p.value, skc->sc_p.length, NULL);
 718         if (!p) {
 719                 printerr(0, "Failed to convert binary to BIGNUM\n");
 720                 return GSS_S_FAILURE;
 721         }
 722
 723         /* We use a static generator for shared key */
 724         g = BN_new();
 725         if (!g) {
 726                 printerr(0, "Failed to allocate new BIGNUM\n");
 727                 return GSS_S_FAILURE;
 728         }
 729         if (BN_set_word(g, SK_GENERATOR) != 1) {
 730                 printerr(0, "Failed to set g value for DH params\n");
 731                 return GSS_S_FAILURE;
 732         }
 733
 734         if (!DH_set0_pqg(skc->sc_params, p, NULL, g)) {
 735                 printerr(0, "Failed to set pqg\n");
 736                 return GSS_S_FAILURE;
 737         }
 738
 739         /* Verify that we have a safe prime and valid generator */
 740         if (DH_check(skc->sc_params, &rc) != 1) {
 741                 printerr(0, "DH_check() failed: %d\n", rc);
 742                 return GSS_S_FAILURE;
 743         } else if (rc) {
 744                 printerr(0, "DH_check() returned error codes: 0x%x\n", rc);
 745                 return GSS_S_FAILURE;
 746         }
 747
 748         if (DH_generate_key(skc->sc_params) != 1) {
 749                 printerr(0, "Failed to generate public DH key: %s\n",
 750                          ERR_error_string(ERR_get_error(), NULL));
 751                 return GSS_S_FAILURE;
 752         }
 753
 754         DH_get0_key(skc->sc_params, &pub_key, NULL);
 755         skc->sc_pub_key.length = BN_num_bytes(pub_key);
 756         skc->sc_pub_key.value = malloc(skc->sc_pub_key.length);
 757         if (!skc->sc_pub_key.value) {
 758                 printerr(0, "Failed to allocate memory for public key\n");
 759                 return GSS_S_FAILURE;
 760         }
 761
 762         BN_bn2bin(pub_key, skc->sc_pub_key.value);
 763
 764         return GSS_S_COMPLETE;
 765 }
 766
 767 /**
 768  * Convert SK hash algorithm into openssl message digest
 769  *
 770  * \param[in,out]       alg             SK hash algorithm
 771  *
 772  * \retval              EVP_MD
 773  */
 774 static inline const EVP_MD *sk_hash_to_evp_md(enum cfs_crypto_hash_alg alg)
 775 {
 776         switch (alg) {
 777         case CFS_HASH_ALG_SHA256:
 778                 return EVP_sha256();
 779         case CFS_HASH_ALG_SHA512:
 780                 return EVP_sha512();
 781         default:
 782                 return EVP_md_null();
 783         }
 784 }
 785
 786 /**
 787  * Signs (via HMAC) the parameters used only in the key initialization protocol.
 788  *
 789  * \param[in]           key             Key to use for HMAC
 790  * \param[in]           bufs            Array of gss_buffer_desc to generate
 791  *                                      HMAC for
 792  * \param[in]           numbufs         Number of buffers in array
 793  * \param[in]           hash_alg        OpenSSL EVP_MD to use for hash
 794  * \param[in,out]       hmac            HMAC of buffers is allocated and placed
 795  *                                      in this gss_buffer_desc.  Caller must
 796  *                                      free this.
 797  *
 798  * \retval      0       success
 799  * \retval      -1      failure
 800  */
 801 int sk_sign_bufs(gss_buffer_desc *key, gss_buffer_desc *bufs, const int numbufs,
 802                  const EVP_MD *hash_alg, gss_buffer_desc *hmac)
 803 {
 804         HMAC_CTX *hctx;
 805         unsigned int hashlen = EVP_MD_size(hash_alg);
 806         int i;
 807         int rc = -1;
 808
 809         if (hash_alg == EVP_md_null()) {
 810                 printerr(0, "Invalid hash algorithm\n");
 811                 return -1;
 812         }
 813
 814         hctx = HMAC_CTX_new();
 815
 816         hmac->length = hashlen;
 817         hmac->value = malloc(hashlen);
 818         if (!hmac->value) {
 819                 printerr(0, "Failed to allocate memory for HMAC\n");
 820                 goto out;
 821         }
 822
 823         if (HMAC_Init_ex(hctx, key->value, key->length, hash_alg, NULL) != 1) {
 824                 printerr(0, "Failed to init HMAC\n");
 825                 goto out;
 826         }
 827
 828         for (i = 0; i < numbufs; i++) {
 829                 if (HMAC_Update(hctx, bufs[i].value, bufs[i].length) != 1) {
 830                         printerr(0, "Failed to update HMAC\n");
 831                         goto out;
 832                 }
 833         }
 834
 835         /* The result gets populated in hmac */
 836         if (HMAC_Final(hctx, hmac->value, &hashlen) != 1) {
 837                 printerr(0, "Failed to finalize HMAC\n");
 838                 goto out;
 839         }
 840
 841         if (hmac->length != hashlen) {
 842                 printerr(0, "HMAC size does not match expected\n");
 843                 goto out;
 844         }
 845
 846         rc = 0;
 847 out:
 848         HMAC_CTX_free(hctx);
 849         return rc;
 850 }
 851
 852 /**
 853  * Generates an HMAC for gss_buffer_desc array in \a bufs of \a numbufs
 854  * and verifies against \a hmac.
 855  *
 856  * \param[in]   skc             Shared key credentials
 857  * \param[in]   bufs            Array of gss_buffer_desc to generate HMAC for
 858  * \param[in]   numbufs         Number of buffers in array
 859  * \param[in]   hash_alg        OpenSSL EVP_MD to use for hash
 860  * \param[in]   hmac            HMAC to verify against
 861  *
 862  * \retval      GSS_S_COMPLETE  success (match)
 863  * \retval      gss error       failure
 864  */
 865 uint32_t sk_verify_hmac(struct sk_cred *skc, gss_buffer_desc *bufs,
 866                         const int numbufs, const EVP_MD *hash_alg,
 867                         gss_buffer_desc *hmac)
 868 {
 869         gss_buffer_desc bufs_hmac;
 870         int rc;
 871
 872         if (sk_sign_bufs(&skc->sc_kctx.skc_shared_key, bufs, numbufs, hash_alg,
 873                          &bufs_hmac)) {
 874                 printerr(0, "Failed to sign buffers to verify HMAC\n");
 875                 if (bufs_hmac.value)
 876                         free(bufs_hmac.value);
 877                 return GSS_S_FAILURE;
 878         }
 879
 880         if (hmac->length != bufs_hmac.length) {
 881                 printerr(0, "Invalid HMAC size\n");
 882                 free(bufs_hmac.value);
 883                 return GSS_S_BAD_SIG;
 884         }
 885
 886         rc = memcmp(hmac->value, bufs_hmac.value, bufs_hmac.length);
 887         free(bufs_hmac.value);
 888
 889         if (rc)
 890                 return GSS_S_BAD_SIG;
 891
 892         return GSS_S_COMPLETE;
 893 }
 894
 895 /**
 896  * Cleanup an sk_cred freeing any resources
 897  *
 898  * \param[in,out]       skc     Shared key credentials to free
 899  */
 900 void sk_free_cred(struct sk_cred *skc)
 901 {
 902         if (!skc)
 903                 return;
 904
 905         if (skc->sc_p.value)
 906                 free(skc->sc_p.value);
 907         if (skc->sc_pub_key.value)
 908                 free(skc->sc_pub_key.value);
 909         if (skc->sc_tgt.value)
 910                 free(skc->sc_tgt.value);
 911         if (skc->sc_nodemap_hash.value)
 912                 free(skc->sc_nodemap_hash.value);
 913         if (skc->sc_hmac.value)
 914                 free(skc->sc_hmac.value);
 915
 916         /* Overwrite keys and IV before freeing */
 917         if (skc->sc_dh_shared_key.value) {
 918                 memset(skc->sc_dh_shared_key.value, 0,
 919                        skc->sc_dh_shared_key.length);
 920                 free(skc->sc_dh_shared_key.value);
 921         }
 922         if (skc->sc_kctx.skc_hmac_key.value) {
 923                 memset(skc->sc_kctx.skc_hmac_key.value, 0,
 924                        skc->sc_kctx.skc_hmac_key.length);
 925                 free(skc->sc_kctx.skc_hmac_key.value);
 926         }
 927         if (skc->sc_kctx.skc_encrypt_key.value) {
 928                 memset(skc->sc_kctx.skc_encrypt_key.value, 0,
 929                        skc->sc_kctx.skc_encrypt_key.length);
 930                 free(skc->sc_kctx.skc_encrypt_key.value);
 931         }
 932         if (skc->sc_kctx.skc_shared_key.value) {
 933                 memset(skc->sc_kctx.skc_shared_key.value, 0,
 934                        skc->sc_kctx.skc_shared_key.length);
 935                 free(skc->sc_kctx.skc_shared_key.value);
 936         }
 937         if (skc->sc_kctx.skc_session_key.value) {
 938                 memset(skc->sc_kctx.skc_session_key.value, 0,
 939                        skc->sc_kctx.skc_session_key.length);
 940                 free(skc->sc_kctx.skc_session_key.value);
 941         }
 942
 943         if (skc->sc_params)
 944                 DH_free(skc->sc_params);
 945
 946         free(skc);
 947         skc = NULL;
 948 }
 949
 950 /* This function handles key derivation using the hash algorithm specified in
 951  * \a hash_alg, buffers in \a key_binding_bufs, and original key in
 952  * \a origin_key to produce a \a derived_key.  The first element of the
 953  * key_binding_bufs array is reserved for the counter used in the KDF.  The
 954  * derived key in \a derived_key could differ in size from \a origin_key and
 955  * must be populated with the expected size and a valid buffer to hold the
 956  * contents.
 957  *
 958  * If the derived key size is greater than the HMAC algorithm size it will be
 959  * a done using several iterations of a counter and the key binding bufs.
 960  *
 961  * If the size is smaller it will take copy the first N bytes necessary to
 962  * fill the derived key. */
 963 int sk_kdf(gss_buffer_desc *derived_key , gss_buffer_desc *origin_key,
 964            gss_buffer_desc *key_binding_bufs, int numbufs,
 965            enum cfs_crypto_hash_alg hmac_alg)
 966 {
 967         size_t remain;
 968         size_t bytes;
 969         uint32_t counter;
 970         char *keydata;
 971         gss_buffer_desc tmp_hash;
 972         int i;
 973         int rc;
 974
 975         if (numbufs < 1)
 976                 return -EINVAL;
 977
 978         /* Use a counter as the first buffer followed by the key binding
 979          * buffers in the event we need more than one a single cycle to
 980          * produced a symmetric key large enough in size */
 981         key_binding_bufs[0].value = &counter;
 982         key_binding_bufs[0].length = sizeof(counter);
 983
 984         remain = derived_key->length;
 985         keydata = derived_key->value;
 986         i = 0;
 987         while (remain > 0) {
 988                 counter = htobe32(i++);
 989                 rc = sk_sign_bufs(origin_key, key_binding_bufs, numbufs,
 990                                   sk_hash_to_evp_md(hmac_alg), &tmp_hash);
 991                 if (rc) {
 992                         if (tmp_hash.value)
 993                                 free(tmp_hash.value);
 994                         return rc;
 995                 }
 996
 997                 if (cfs_crypto_hash_digestsize(hmac_alg) != tmp_hash.length) {
 998                         free(tmp_hash.value);
 999                         return -EINVAL;
1000                 }
1001
1002                 bytes = (remain < tmp_hash.length) ? remain : tmp_hash.length;
1003                 memcpy(keydata, tmp_hash.value, bytes);
1004                 free(tmp_hash.value);
1005                 remain -= bytes;
1006                 keydata += bytes;
1007         }
1008
1009         return 0;
1010 }
1011
1012 /* Populates the sk_cred's session_key using the a Key Derviation Function (KDF)
1013  * based on the recommendations in NIST Special Publication SP 800-56B Rev 1
1014  * (Sep 2014) Section 5.5.1
1015  *
1016  * \param[in,out]       skc             Shared key credentials structure with
1017  *
1018  * \return      -1              failure
1019  * \return      0               success
1020  */
1021 int sk_session_kdf(struct sk_cred *skc, lnet_nid_t client_nid,
1022                    gss_buffer_desc *client_token, gss_buffer_desc *server_token)
1023 {
1024         struct sk_kernel_ctx *kctx = &skc->sc_kctx;
1025         gss_buffer_desc *session_key = &kctx->skc_session_key;
1026         gss_buffer_desc bufs[5];
1027         enum cfs_crypto_crypt_alg crypt_alg;
1028         int rc = -1;
1029
1030         crypt_alg = cfs_crypto_crypt_alg(kctx->skc_crypt_alg);
1031         session_key->length = cfs_crypto_crypt_keysize(crypt_alg);
1032         session_key->value = malloc(session_key->length);
1033         if (!session_key->value) {
1034                 printerr(0, "Failed to allocate memory for session key\n");
1035                 return rc;
1036         }
1037
1038         /* Key binding info ordering
1039          * 1. Reserved for counter
1040          * 1. DH shared key
1041          * 2. Client's NIDs
1042          * 3. Client's token
1043          * 4. Server's token */
1044         bufs[0].value = NULL;
1045         bufs[0].length = 0;
1046         bufs[1] = skc->sc_dh_shared_key;
1047         bufs[2].value = &client_nid;
1048         bufs[2].length = sizeof(client_nid);
1049         bufs[3] = *client_token;
1050         bufs[4] = *server_token;
1051
1052         return sk_kdf(&kctx->skc_session_key, &kctx->skc_shared_key, bufs,
1053                       5, cfs_crypto_hash_alg(kctx->skc_hmac_alg));
1054 }
1055
1056 /* Uses the session key to create an HMAC key and encryption key.  In
1057  * integrity mode the session key used to generate the HMAC key uses
1058  * session information which is available on the wire but by creating
1059  * a session based HMAC key we can prevent potential replay as both the
1060  * client and server have random numbers used as part of the key creation.
1061  *
1062  * The keys used for integrity and privacy are formulated as below using
1063  * the session key that is the output of the key derivation function.  The
1064  * HMAC algorithm is determined by the shared key algorithm selected in the
1065  * key file.
1066  *
1067  * For ski mode:
1068  * Session HMAC Key = PBKDF2("Integrity", KDF derived Session Key)
1069  *
1070  * For skpi mode:
1071  * Session HMAC Key = PBKDF2("Integrity", KDF derived Session Key)
1072  * Session Encryption Key = PBKDF2("Encrypt", KDF derived Session Key)
1073  *
1074  * \param[in,out]       skc             Shared key credentials structure with
1075  *
1076  * \return      -1              failure
1077  * \return      0               success
1078  */
1079 int sk_compute_keys(struct sk_cred *skc)
1080 {
1081         struct sk_kernel_ctx *kctx = &skc->sc_kctx;
1082         gss_buffer_desc *session_key = &kctx->skc_session_key;
1083         gss_buffer_desc *hmac_key = &kctx->skc_hmac_key;
1084         gss_buffer_desc *encrypt_key = &kctx->skc_encrypt_key;
1085         enum cfs_crypto_hash_alg hmac_alg;
1086         enum cfs_crypto_crypt_alg crypt_alg;
1087         char *encrypt = "Encrypt";
1088         char *integrity = "Integrity";
1089         int rc;
1090
1091         hmac_alg = cfs_crypto_hash_alg(kctx->skc_hmac_alg);
1092         hmac_key->length = cfs_crypto_hash_digestsize(hmac_alg);
1093         hmac_key->value = malloc(hmac_key->length);
1094         if (!hmac_key->value)
1095                 return -ENOMEM;
1096
1097         rc = PKCS5_PBKDF2_HMAC(integrity, -1, session_key->value,
1098                                session_key->length, SK_PBKDF2_ITERATIONS,
1099                                sk_hash_to_evp_md(hmac_alg),
1100                                hmac_key->length, hmac_key->value);
1101         if (rc == 0)
1102                 return -EINVAL;
1103
1104         /* Encryption key is only populated in privacy mode */
1105         if ((skc->sc_flags & LGSS_SVC_PRIV) == 0)
1106                 return 0;
1107
1108         crypt_alg = cfs_crypto_crypt_alg(kctx->skc_crypt_alg);
1109         encrypt_key->length = cfs_crypto_crypt_keysize(crypt_alg);
1110         encrypt_key->value = malloc(encrypt_key->length);
1111         if (!encrypt_key->value)
1112                 return -ENOMEM;
1113
1114         rc = PKCS5_PBKDF2_HMAC(encrypt, -1, session_key->value,
1115                                session_key->length, SK_PBKDF2_ITERATIONS,
1116                                sk_hash_to_evp_md(hmac_alg),
1117                                encrypt_key->length, encrypt_key->value);
1118         if (rc == 0)
1119                 return -EINVAL;
1120
1121         return 0;
1122 }
1123
1124 /**
1125  * Computes a session key based on the DH parameters from the host and its peer
1126  *
1127  * \param[in,out]       skc             Shared key credentials structure with
1128  *                                      the session key populated with the
1129  *                                      compute key
1130  * \param[in]           pub_key         Public key returned from peer in
1131  *                                      gss_buffer_desc
1132  * \return      gss error               failure
1133  * \return      GSS_S_COMPLETE          success
1134  */
1135 uint32_t sk_compute_dh_key(struct sk_cred *skc, const gss_buffer_desc *pub_key)
1136 {
1137         gss_buffer_desc *dh_shared = &skc->sc_dh_shared_key;
1138         BIGNUM *remote_pub_key;
1139         int status;
1140         uint32_t rc = GSS_S_FAILURE;
1141
1142         remote_pub_key = BN_bin2bn(pub_key->value, pub_key->length, NULL);
1143         if (!remote_pub_key) {
1144                 printerr(0, "Failed to convert binary to BIGNUM\n");
1145                 return rc;
1146         }
1147
1148         dh_shared->length = DH_size(skc->sc_params);
1149         dh_shared->value = malloc(dh_shared->length);
1150         if (!dh_shared->value) {
1151                 printerr(0, "Failed to allocate memory for computed shared "
1152                          "secret key\n");
1153                 goto out_err;
1154         }
1155
1156         /* This compute the shared key from the DHKE */
1157         status = DH_compute_key(dh_shared->value, remote_pub_key,
1158                                 skc->sc_params);
1159         if (status == -1) {
1160                 printerr(0, "DH_compute_key() failed: %s\n",
1161                          ERR_error_string(ERR_get_error(), NULL));
1162                 goto out_err;
1163         } else if (status < dh_shared->length) {
1164                 printerr(0, "DH_compute_key() returned a short key of %d "
1165                          "bytes, expected: %zu\n", status, dh_shared->length);
1166                 rc = GSS_S_DEFECTIVE_TOKEN;
1167                 goto out_err;
1168         }
1169
1170         rc = GSS_S_COMPLETE;
1171
1172 out_err:
1173         BN_free(remote_pub_key);
1174         return rc;
1175 }
1176
1177 /**
1178  * Creates a serialized buffer for the kernel in the order of struct
1179  * sk_kernel_ctx.
1180  *
1181  * \param[in,out]       skc             Shared key credentials structure
1182  * \param[in,out]       ctx_token       Serialized buffer for kernel.
1183  *                                      Caller must free this buffer.
1184  *
1185  * \return      0       success
1186  * \return      -1      failure
1187  */
1188 int sk_serialize_kctx(struct sk_cred *skc, gss_buffer_desc *ctx_token)
1189 {
1190         struct sk_kernel_ctx *kctx = &skc->sc_kctx;
1191         char *p, *end;
1192         size_t bufsize;
1193
1194         bufsize = sizeof(*kctx) + kctx->skc_hmac_key.length +
1195                   kctx->skc_encrypt_key.length;
1196
1197         ctx_token->value = malloc(bufsize);
1198         if (!ctx_token->value)
1199                 return -1;
1200         ctx_token->length = bufsize;
1201
1202         p = ctx_token->value;
1203         end = p + ctx_token->length;
1204
1205         if (WRITE_BYTES(&p, end, kctx->skc_version))
1206                 return -1;
1207         if (WRITE_BYTES(&p, end, kctx->skc_hmac_alg))
1208                 return -1;
1209         if (WRITE_BYTES(&p, end, kctx->skc_crypt_alg))
1210                 return -1;
1211         if (WRITE_BYTES(&p, end, kctx->skc_expire))
1212                 return -1;
1213         if (WRITE_BYTES(&p, end, kctx->skc_host_random))
1214                 return -1;
1215         if (WRITE_BYTES(&p, end, kctx->skc_peer_random))
1216                 return -1;
1217         if (write_buffer(&p, end, &kctx->skc_hmac_key))
1218                 return -1;
1219         if (write_buffer(&p, end, &kctx->skc_encrypt_key))
1220                 return -1;
1221
1222         printerr(2, "Serialized buffer of %zu bytes for kernel\n", bufsize);
1223
1224         return 0;
1225 }
1226
1227 /**
1228  * Decodes a netstring \a ns into array of gss_buffer_descs at \a bufs
1229  * up to \a numbufs.  Memory is allocated for each value and length
1230  * will be populated with the length
1231  *
1232  * \param[in,out]       bufs    Array of gss_buffer_descs
1233  * \param[in,out]       numbufs number of gss_buffer_desc in array
1234  * \param[in]           ns      netstring to decode
1235  *
1236  * \return      buffers populated       success
1237  * \return      -1                      failure
1238  */
1239 int sk_decode_netstring(gss_buffer_desc *bufs, int numbufs, gss_buffer_desc *ns)
1240 {
1241         char *ptr = ns->value;
1242         size_t remain = ns->length;
1243         unsigned int size;
1244         int digits;
1245         int sep;
1246         int rc;
1247         int i;
1248
1249         for (i = 0; i < numbufs; i++) {
1250                 /* read the size of first buffer */
1251                 rc = sscanf(ptr, "%9u", &size);
1252                 if (rc < 1)
1253                         goto out_err;
1254                 digits = (size) ? ceil(log10(size + 1)) : 1;
1255
1256                 /* sep of current string */
1257                 sep = size + digits + 2;
1258
1259                 /* check to make sure it's valid */
1260                 if (remain < sep || ptr[digits] != ':' ||
1261                     ptr[sep - 1] != ',')
1262                         goto out_err;
1263
1264                 bufs[i].length = size;
1265                 if (size == 0) {
1266                         bufs[i].value = NULL;
1267                 } else {
1268                         bufs[i].value = malloc(size);
1269                         if (!bufs[i].value)
1270                                 goto out_err;
1271                         memcpy(bufs[i].value, &ptr[digits + 1], size);
1272                 }
1273
1274                 remain -= sep;
1275                 ptr += sep;
1276         }
1277
1278         printerr(2, "Decoded netstring of %zu bytes\n", ns->length);
1279         return i;
1280
1281 out_err:
1282         while (i-- > 0) {
1283                 if (bufs[i].value)
1284                         free(bufs[i].value);
1285                 bufs[i].length = 0;
1286         }
1287         return -1;
1288 }
1289
1290 /**
1291  * Creates a netstring in a gss_buffer_desc that consists of all
1292  * the gss_buffer_desc found in \a bufs.  The netstring should be treated
1293  * as binary as it can contain null characters.
1294  *
1295  * \param[in]           bufs            Array of gss_buffer_desc to use as input
1296  * \param[in]           numbufs         Number of buffers in array
1297  * \param[in,out]       ns              Destination gss_buffer_desc to hold
1298  *                                      netstring
1299  *
1300  * \return      -1      failure
1301  * \return      0       success
1302  */
1303 int sk_encode_netstring(gss_buffer_desc *bufs, int numbufs,
1304                         gss_buffer_desc *ns)
1305 {
1306         unsigned char *ptr;
1307         int size = 0;
1308         int rc;
1309         int i;
1310
1311         /* size of string in decimal, string size, colon, and comma */
1312         for (i = 0; i < numbufs; i++) {
1313
1314                 if (bufs[i].length == 0)
1315                         size += 3;
1316                 else
1317                         size += ceil(log10(bufs[i].length + 1)) +
1318                                 bufs[i].length + 2;
1319         }
1320
1321         ns->length = size;
1322         ns->value = malloc(ns->length);
1323         if (!ns->value) {
1324                 ns->length = 0;
1325                 return -1;
1326         }
1327
1328         ptr = ns->value;
1329         for (i = 0; i < numbufs; i++) {
1330                 /* size */
1331                 rc = snprintf((char *) ptr, size, "%zu:", bufs[i].length);
1332                 ptr += rc;
1333
1334                 /* contents */
1335                 memcpy(ptr, bufs[i].value, bufs[i].length);
1336                 ptr += bufs[i].length;
1337
1338                 /* delimeter */
1339                 *ptr++ = ',';
1340
1341                 size -= bufs[i].length + rc + 1;
1342
1343                 /* should not happen */
1344                 if (size < 0)
1345                         abort();
1346         }
1347
1348         printerr(2, "Encoded netstring of %zu bytes\n", ns->length);
1349         return 0;
1350 }