lustre/utils/gss/lgss_sk.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, Intel Corporation.
  26  *
  27  * Author: Jeremy Filizetti <jfilizet@iu.edu>
  28  */
  29
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <getopt.h>
  34 #include <limits.h>
  35 #include <stdarg.h>
  36 #include <stdbool.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <unistd.h>
  43 #include <linux/lustre/lustre_user.h>
  44
  45 #include "sk_utils.h"
  46 #include "err_util.h"
  47
  48 #ifndef _GNU_SOURCE
  49 #define _GNU_SOURCE
  50 #endif
  51
  52 /* One week default expiration */
  53 #define SK_DEFAULT_EXPIRE 604800
  54 #define SK_DEFAULT_SK_KEYLEN 256
  55 #define SK_DEFAULT_PRIME_BITS 2048
  56 #define SK_DEFAULT_NODEMAP "default"
  57
  58 static void usage(FILE *fp, char *program)
  59 {
  60         int i;
  61
  62         fprintf(fp, "Usage %s [OPTIONS] {-l|-m|-r|-w} <keyfile>\n", program);
  63         fprintf(fp, "-l|--load       <keyfile>  Load key from file into user's "
  64                 "session keyring\n");
  65         fprintf(fp, "-m|--modify     <keyfile>  Modify keyfile's attributes\n");
  66         fprintf(fp, "-r|--read       <keyfile>  Show keyfile's attributes\n");
  67         fprintf(fp, "-w|--write      <keyfile>  Generate keyfile\n\n");
  68         fprintf(fp, "Modify/Write Options:\n");
  69         fprintf(fp, "-c|--crypt      <num>      Cipher for encryption "
  70                 "(Default: AES Counter mode)\n");
  71         for (i = 1; i < ARRAY_SIZE(sk_crypt_algs); i++)
  72                 fprintf(fp, "                        %s\n",
  73                         sk_crypt_algs[i].sct_name);
  74         fprintf(fp, "-i|--hmac       <num>      Hash algorithm for integrity "
  75                 "(Default: SHA256)\n");
  76         for (i = 1; i < ARRAY_SIZE(sk_hmac_algs); i++)
  77                 fprintf(fp, "                        %s\n",
  78                         sk_hmac_algs[i].sht_name);
  79         fprintf(fp, "-e|--expire     <num>      Seconds before contexts from "
  80                 "key expire (Default: %d seconds (%.3g days))\n",
  81                 SK_DEFAULT_EXPIRE, (double)SK_DEFAULT_EXPIRE / 3600 / 24);
  82         fprintf(fp, "-f|--fsname     <name>     File system name for key\n");
  83         fprintf(fp, "-g|--mgsnids    <nids>     Comma seperated list of MGS "
  84                 "NIDs.  Only required when mgssec is used (Default: \"\")\n");
  85         fprintf(fp, "-n|--nodemap    <name>     Nodemap name for key "
  86                 "(Default: \"%s\")\n", SK_DEFAULT_NODEMAP);
  87         fprintf(fp, "-p|--prime-bits <len>      Prime length (p) for DHKE in "
  88                 "bits (Default: %d)\n", SK_DEFAULT_PRIME_BITS);
  89         fprintf(fp, "-t|--type       <type>     Key type (mgs, server, "
  90                 "client)\n");
  91         fprintf(fp, "-k|--key-bits   <len>      Shared key length in bits "
  92                 "(Default: %d)\n", SK_DEFAULT_SK_KEYLEN);
  93         fprintf(fp, "-d|--data       <file>     Key data source for new keys "
  94                 "(Default: /dev/random)\n");
  95         fprintf(fp, "                        Not a seed value. "
  96                 "This is the actual key value.\n\n");
  97         fprintf(fp, "Other Options:\n");
  98         fprintf(fp, "-v|--verbose           Increase verbosity for errors\n");
  99         exit(EXIT_FAILURE);
 100 }
 101
 102 static ssize_t get_key_data(char *src, void *buffer, size_t bits)
 103 {
 104         char *ptr = buffer;
 105         size_t remain;
 106         ssize_t rc;
 107         int fd;
 108
 109         /* convert bits to minimum number of bytes */
 110         remain = (bits + 7) / 8;
 111
 112         printf("Reading random data for shared key from '%s'\n", src);
 113         fd = open(src, O_RDONLY);
 114         if (fd < 0) {
 115                 fprintf(stderr, "error: opening '%s': %s\n", src,
 116                         strerror(errno));
 117                 return -errno;
 118         }
 119
 120         while (remain > 0) {
 121                 rc = read(fd, ptr, remain);
 122                 if (rc < 0) {
 123                         if (errno == EINTR)
 124                                 continue;
 125                         fprintf(stderr, "error: reading from '%s': %s\n", src,
 126                                 strerror(errno));
 127                         rc = -errno;
 128                         goto out;
 129
 130                 } else if (rc == 0) {
 131                         fprintf(stderr,
 132                                 "error: key source too short for %zd-bit key\n",
 133                                 bits);
 134                         rc = -ENODATA;
 135                         goto out;
 136                 }
 137                 ptr += rc;
 138                 remain -= rc;
 139         }
 140         rc = 0;
 141
 142 out:
 143         close(fd);
 144         return rc;
 145 }
 146
 147 static int write_config_file(char *output_file,
 148                              struct sk_keyfile_config *config, bool overwrite)
 149 {
 150         size_t rc;
 151         int fd;
 152         int flags = O_WRONLY | O_CREAT;
 153
 154         if (!overwrite)
 155                 flags |= O_EXCL;
 156
 157         sk_config_cpu_to_disk(config);
 158
 159         fd = open(output_file, flags, 0400);
 160         if (fd < 0) {
 161                 fprintf(stderr, "error: opening '%s': %s\n", output_file,
 162                         strerror(errno));
 163                 return -errno;
 164         }
 165
 166         rc = write(fd, config, sizeof(*config));
 167         if (rc < 0) {
 168                 fprintf(stderr, "error: writing to '%s': %s\n", output_file,
 169                         strerror(errno));
 170                 rc = -errno;
 171         } else if (rc != sizeof(*config)) {
 172                 fprintf(stderr, "error: short write to '%s'\n", output_file);
 173                 rc = -ENOSPC;
 174
 175         } else {
 176                 rc = 0;
 177         }
 178
 179         close(fd);
 180         return rc;
 181 }
 182
 183 static int print_config(char *filename)
 184 {
 185         struct sk_keyfile_config *config;
 186         int i;
 187
 188         config = sk_read_file(filename);
 189         if (!config)
 190                 return EXIT_FAILURE;
 191
 192         if (sk_validate_config(config)) {
 193                 fprintf(stderr, "error: key configuration failed validation\n");
 194                 free(config);
 195                 return EXIT_FAILURE;
 196         }
 197
 198         printf("Version:        %u\n", config->skc_version);
 199         printf("Type:          ");
 200         if (config->skc_type & SK_TYPE_MGS)
 201                 printf(" mgs");
 202         if (config->skc_type & SK_TYPE_SERVER)
 203                 printf(" server");
 204         if (config->skc_type & SK_TYPE_CLIENT)
 205                 printf(" client");
 206         printf("\n");
 207         printf("HMAC alg:       %s\n", sk_hmac2name(config->skc_hmac_alg));
 208         printf("Crypto alg:     %s\n", sk_crypt2name(config->skc_crypt_alg));
 209         printf("Ctx Expiration: %u seconds\n", config->skc_expire);
 210         printf("Shared keylen:  %u bits\n", config->skc_shared_keylen);
 211         printf("Prime length:   %u bits\n", config->skc_prime_bits);
 212         printf("File system:    %s\n", config->skc_fsname);
 213         printf("MGS NIDs:      ");
 214         for (i = 0; i < MAX_MGSNIDS; i++) {
 215                 if (config->skc_mgsnids[i] == LNET_NID_ANY)
 216                         continue;
 217                 printf(" %s", libcfs_nid2str(config->skc_mgsnids[i]));
 218         }
 219         printf("\n");
 220         printf("Nodemap name:   %s\n", config->skc_nodemap);
 221         printf("Shared key:\n");
 222         print_hex(0, config->skc_shared_key, config->skc_shared_keylen / 8);
 223
 224         /* Don't print empty keys */
 225         for (i = 0; i < SK_MAX_P_BYTES; i++)
 226                 if (config->skc_p[i] != 0)
 227                         break;
 228
 229         if (i != SK_MAX_P_BYTES) {
 230                 printf("Prime (p):\n");
 231                 print_hex(0, config->skc_p, config->skc_prime_bits / 8);
 232         }
 233
 234         free(config);
 235         return EXIT_SUCCESS;
 236 }
 237
 238 static int parse_mgsnids(char *mgsnids, struct sk_keyfile_config *config)
 239 {
 240         lnet_nid_t nid;
 241         char *ptr;
 242         char *sep;
 243         char *end;
 244         int rc = 0;
 245         int i;
 246
 247         /* replace all old values */
 248         for (i = 0; i < MAX_MGSNIDS; i++)
 249                 config->skc_mgsnids[i] = LNET_NID_ANY;
 250
 251         i = 0;
 252         end = mgsnids + strlen(mgsnids);
 253         ptr = mgsnids;
 254         while (ptr < end && i < MAX_MGSNIDS) {
 255                 sep = strstr(ptr, ",");
 256                 if (sep != NULL)
 257                         *sep = '\0';
 258
 259                 nid = libcfs_str2nid(ptr);
 260                 if (nid == LNET_NID_ANY) {
 261                         fprintf(stderr, "error: invalid MGS NID: %s\n", ptr);
 262                         rc = -EINVAL;
 263                         break;
 264                 }
 265
 266                 config->skc_mgsnids[i++] = nid;
 267                 ptr += strlen(ptr) + 1;
 268         }
 269
 270         if (i == MAX_MGSNIDS) {
 271                 fprintf(stderr, "error: more than %u MGS NIDs provided\n", i);
 272                 rc = -E2BIG;
 273         }
 274
 275         return rc;
 276 }
 277
 278 static inline int __gen_ssk_prime(struct sk_keyfile_config *config)
 279 {
 280         int rc = -1;
 281         EVP_PKEY_CTX *ctx = NULL;
 282         EVP_PKEY *dh = NULL;
 283         BIGNUM *p;
 284
 285         ctx = EVP_PKEY_CTX_new_from_name(NULL, "DH", NULL);
 286         if (!ctx || EVP_PKEY_paramgen_init(ctx) != 1) {
 287                 fprintf(stderr, "error: ctx cannot be init\n");
 288                 goto prime_end;
 289         }
 290
 291         if (EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx,
 292                                                  config->skc_prime_bits) <= 0 ||
 293             EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, SK_GENERATOR) <= 0) {
 294                 fprintf(stderr, "error: cannot set prime or generator\n");
 295                 goto prime_end;
 296         }
 297
 298         if (EVP_PKEY_paramgen(ctx, &dh) != 1) {
 299                 fprintf(stderr, "error: cannot generate DH parameters\n");
 300                 goto prime_end;
 301         }
 302
 303         if (!EVP_PKEY_get_bn_param(dh, OSSL_PKEY_PARAM_FFC_P, &p)) {
 304                 fprintf(stderr, "error: cannot get p from dh\n");
 305                 goto prime_end;
 306         }
 307
 308         if (BN_num_bytes(p) > SK_MAX_P_BYTES) {
 309                 fprintf(stderr,
 310                         "error: cannot generate DH parameters: requested length %d exceeds maximum %d\n",
 311                         config->skc_prime_bits, SK_MAX_P_BYTES * 8);
 312                 goto prime_end;
 313         }
 314         if (BN_bn2bin(p, config->skc_p) != BN_num_bytes(p)) {
 315                 fprintf(stderr,
 316                         "error: convert BIGNUM p to binary failed\n");
 317                 goto prime_end;
 318         }
 319
 320         rc = 0;
 321
 322 prime_end:
 323         EVP_PKEY_free(dh);
 324         EVP_PKEY_CTX_free(ctx);
 325         return rc;
 326 }
 327
 328 int main(int argc, char **argv)
 329 {
 330         struct sk_keyfile_config *config;
 331         char *datafile = NULL;
 332         char *input = NULL;
 333         char *load = NULL;
 334         char *modify = NULL;
 335         char *output = NULL;
 336         char *mgsnids = NULL;
 337         char *nodemap = NULL;
 338         char *fsname = NULL;
 339         char *tmp;
 340         char *tmp2;
 341         int crypt = SK_CRYPT_EMPTY;
 342         int hmac = SK_HMAC_EMPTY;
 343         int expire = -1;
 344         int shared_keylen = -1;
 345         int prime_bits = -1;
 346         int verbose = 0;
 347         int i;
 348         int opt;
 349         enum sk_key_type type = SK_TYPE_INVALID;
 350         bool generate_prime = false;
 351
 352         static struct option long_opts[] = {
 353         { .name = "crypt",      .has_arg = required_argument, .val = 'c'},
 354         { .name = "data",       .has_arg = required_argument, .val = 'd'},
 355         { .name = "expire",     .has_arg = required_argument, .val = 'e'},
 356         { .name = "fsname",     .has_arg = required_argument, .val = 'f'},
 357         { .name = "mgsnids",    .has_arg = required_argument, .val = 'g'},
 358         { .name = "help",       .has_arg = no_argument,       .val = 'h'},
 359         { .name = "hmac",       .has_arg = required_argument, .val = 'i'},
 360         { .name = "integrity",  .has_arg = required_argument, .val = 'i'},
 361         { .name = "key-bits",   .has_arg = required_argument, .val = 'k'},
 362         { .name = "shared",     .has_arg = required_argument, .val = 'k'},
 363         { .name = "load",       .has_arg = required_argument, .val = 'l'},
 364         { .name = "modify",     .has_arg = required_argument, .val = 'm'},
 365         { .name = "nodemap",    .has_arg = required_argument, .val = 'n'},
 366         { .name = "prime-bits", .has_arg = required_argument, .val = 'p'},
 367         { .name = "read",       .has_arg = required_argument, .val = 'r'},
 368         { .name = "type",       .has_arg = required_argument, .val = 't'},
 369         { .name = "verbose",    .has_arg = no_argument,       .val = 'v'},
 370         { .name = "write",      .has_arg = required_argument, .val = 'w'},
 371         { .name = NULL, } };
 372
 373         while ((opt = getopt_long(argc, argv,
 374                                   "c:d:e:f:g:hi:l:m:n:p:r:s:k:t:w:v", long_opts,
 375                                   NULL)) != EOF) {
 376                 switch (opt) {
 377                 case 'c':
 378                         crypt = sk_name2crypt(optarg);
 379                         break;
 380                 case 'd':
 381                         datafile = optarg;
 382                         break;
 383                 case 'e':
 384                         expire = atoi(optarg);
 385                         if (expire < 60)
 386                                 fprintf(stderr, "warning: using a %us key "
 387                                         "expiration may cause issues during "
 388                                         "key renegotiation\n", expire);
 389                         break;
 390                 case 'f':
 391                         fsname = optarg;
 392                         if (strlen(fsname) > MTI_NAME_MAXLEN) {
 393                                 fprintf(stderr,
 394                                         "error: file system name longer than "
 395                                         "%u characters\n", MTI_NAME_MAXLEN);
 396                                 return EXIT_FAILURE;
 397                         }
 398                         break;
 399                 case 'g':
 400                         mgsnids = optarg;
 401                         break;
 402                 case 'h':
 403                         usage(stdout, argv[0]);
 404                         break;
 405                 case 'i':
 406                         hmac = sk_name2hmac(optarg);
 407                         break;
 408                 case 'k':
 409                         shared_keylen = atoi(optarg);
 410                         break;
 411                 case 'l':
 412                         load = optarg;
 413                         break;
 414                 case 'm':
 415                         modify = optarg;
 416                         break;
 417                 case 'n':
 418                         nodemap = optarg;
 419                         if (strlen(nodemap) > LUSTRE_NODEMAP_NAME_LENGTH) {
 420                                 fprintf(stderr,
 421                                         "error: nodemap name longer than "
 422                                         "%u characters\n",
 423                                         LUSTRE_NODEMAP_NAME_LENGTH);
 424                                 return EXIT_FAILURE;
 425                         }
 426                         break;
 427                 case 'p':
 428                         prime_bits = atoi(optarg);
 429                         if (prime_bits <= 0) {
 430                                 fprintf(stderr,
 431                                         "error: invalid prime length: '%s'\n",
 432                                         optarg);
 433                                 return EXIT_FAILURE;
 434                         }
 435                         break;
 436                 case 'r':
 437                         input = optarg;
 438                         break;
 439                 case 't':
 440                         tmp2 = strdup(optarg);
 441                         if (!tmp2) {
 442                                 fprintf(stderr,
 443                                         "error: failed to allocate type\n");
 444                                 return EXIT_FAILURE;
 445                         }
 446                         tmp = strsep(&tmp2, ",");
 447                         while (tmp != NULL) {
 448                                 if (strcasecmp(tmp, "server") == 0) {
 449                                         type |= SK_TYPE_SERVER;
 450                                 } else if (strcasecmp(tmp, "mgs") == 0) {
 451                                         type |= SK_TYPE_MGS;
 452                                 } else if (strcasecmp(tmp, "client") == 0) {
 453                                         type |= SK_TYPE_CLIENT;
 454                                 } else {
 455                                         fprintf(stderr,
 456                                                 "error: invalid type '%s', "
 457                                                 "must be mgs, server, or client"
 458                                                 "\n", optarg);
 459                                         return EXIT_FAILURE;
 460                                 }
 461                                 tmp = strsep(&tmp2, ",");
 462                         }
 463                         free(tmp2);
 464                         break;
 465                 case 'v':
 466                         verbose++;
 467                         break;
 468                 case 'w':
 469                         output = optarg;
 470                         break;
 471                 default:
 472                         fprintf(stderr, "error: unknown option: '%c'\n", opt);
 473                         return EXIT_FAILURE;
 474                         break;
 475                 }
 476         }
 477
 478         if (optind != argc) {
 479                 fprintf(stderr,
 480                         "error: extraneous arguments provided, check usage\n");
 481                 return EXIT_FAILURE;
 482         }
 483
 484         if (!input && !output && !load && !modify) {
 485                 usage(stderr, argv[0]);
 486                 return EXIT_FAILURE;
 487         }
 488
 489         /* init gss logger for foreground (no syslog) which prints to stderr */
 490         initerr(NULL, verbose, 1);
 491
 492         if (input)
 493                 return print_config(input);
 494
 495         if (load) {
 496                 if (sk_load_keyfile(load))
 497                         return EXIT_FAILURE;
 498                 return EXIT_SUCCESS;
 499         }
 500
 501         if (crypt == SK_CRYPT_INVALID) {
 502                 fprintf(stderr, "error: invalid crypt algorithm specified\n");
 503                 return EXIT_FAILURE;
 504         }
 505         if (hmac == SK_HMAC_INVALID) {
 506                 fprintf(stderr, "error: invalid HMAC algorithm specified\n");
 507                 return EXIT_FAILURE;
 508         }
 509
 510         if (modify && datafile) {
 511                 fprintf(stderr,
 512                         "error: data file option not valid in key modify\n");
 513                 return EXIT_FAILURE;
 514         }
 515
 516         if (modify) {
 517                 config = sk_read_file(modify);
 518                 if (!config)
 519                         return EXIT_FAILURE;
 520
 521                 if (type != SK_TYPE_INVALID) {
 522                         /* generate key when adding client type */
 523                         if (!(config->skc_type & SK_TYPE_CLIENT) &&
 524                             type & SK_TYPE_CLIENT)
 525                                 generate_prime = true;
 526                         else if (!(type & SK_TYPE_CLIENT))
 527                                 memset(config->skc_p, 0, SK_MAX_P_BYTES);
 528
 529                         config->skc_type = type;
 530                 }
 531                 if (prime_bits != -1) {
 532                         memset(config->skc_p, 0, SK_MAX_P_BYTES);
 533                         if (config->skc_prime_bits != prime_bits &&
 534                             config->skc_type & SK_TYPE_CLIENT)
 535                                 generate_prime = true;
 536                 }
 537         } else {
 538                 /* write mode for a new key */
 539                 if (!fsname && !mgsnids) {
 540                         fprintf(stderr,
 541                                 "error: missing --fsname or --mgsnids\n");
 542                         return EXIT_FAILURE;
 543                 }
 544
 545                 config = calloc(1, sizeof(*config));
 546                 if (!config)
 547                         return EXIT_FAILURE;
 548
 549                 /* Set the defaults for new key */
 550                 config->skc_version = SK_CONF_VERSION;
 551                 config->skc_expire = SK_DEFAULT_EXPIRE;
 552                 config->skc_shared_keylen = SK_DEFAULT_SK_KEYLEN;
 553                 config->skc_prime_bits = SK_DEFAULT_PRIME_BITS;
 554                 config->skc_crypt_alg = SK_CRYPT_AES256_CTR;
 555                 config->skc_hmac_alg = SK_HMAC_SHA256;
 556                 for (i = 0; i < MAX_MGSNIDS; i++)
 557                         config->skc_mgsnids[i] = LNET_NID_ANY;
 558
 559                 if (type == SK_TYPE_INVALID) {
 560                         fprintf(stderr, "error: no type specified for key\n");
 561                         goto error;
 562                 }
 563                 config->skc_type = type;
 564                 generate_prime = type & SK_TYPE_CLIENT;
 565
 566                 /* SK_DEFAULT_NODEMAP is made to fit in skc_nodemap */
 567                 strcpy(config->skc_nodemap, SK_DEFAULT_NODEMAP);
 568
 569                 if (!datafile)
 570                         datafile = "/dev/random";
 571         }
 572
 573         if (crypt != SK_CRYPT_EMPTY)
 574                 config->skc_crypt_alg = crypt;
 575         if (hmac != SK_HMAC_EMPTY)
 576                 config->skc_hmac_alg = hmac;
 577         if (expire != -1)
 578                 config->skc_expire = expire;
 579         if (shared_keylen != -1)
 580                 config->skc_shared_keylen = shared_keylen;
 581         if (prime_bits != -1) {
 582 #ifdef HAVE_OPENSSL_EVP_PKEY
 583                 /* #define DH_MIN_MODULUS_BITS 512, not exported by OpenSSL */
 584                 if (prime_bits < 512) {
 585                         fprintf(stderr,
 586                                 "error: prime length must be at least 512\n");
 587                         return EXIT_FAILURE;
 588                 }
 589 #endif
 590                 config->skc_prime_bits = prime_bits;
 591         }
 592         if (fsname)
 593                 /* fsname string length was checked when parsing
 594                  * command-line options
 595                  */
 596                 strcpy(config->skc_fsname, fsname);
 597         if (nodemap)
 598                 /* nodemap string length was checked when parsing
 599                  * command-line options
 600                  */
 601                 strcpy(config->skc_nodemap, nodemap);
 602         if (mgsnids && parse_mgsnids(mgsnids, config))
 603                 goto error;
 604         if (sk_validate_config(config)) {
 605                 fprintf(stderr, "error: key configuration failed validation\n");
 606                 goto error;
 607         }
 608
 609         if (datafile && get_key_data(datafile, config->skc_shared_key,
 610                                      config->skc_shared_keylen)) {
 611                 fprintf(stderr, "error: failure getting key data from '%s'\n",
 612                         datafile);
 613                 goto error;
 614         }
 615
 616         if (generate_prime) {
 617                 printf("Generating DH parameters, this can take a while...\n");
 618                 if (__gen_ssk_prime(config))
 619                         goto error;
 620         }
 621
 622         if (write_config_file(modify ?: output, config, modify))
 623                 goto error;
 624
 625         return EXIT_SUCCESS;
 626
 627 error:
 628         free(config);
 629         return EXIT_FAILURE;
 630 }