1 /* $OpenBSD: passwd.c,v 1.12 2021/12/12 20:40:25 tb Exp $ */ 2 3 #if defined OPENSSL_NO_MD5 4 #define NO_MD5CRYPT_1 5 #endif 6 7 #if !defined(OPENSSL_NO_DES) || !defined(NO_MD5CRYPT_1) 8 9 #include <assert.h> 10 #include <string.h> 11 12 #include "apps.h" 13 14 #include <openssl/bio.h> 15 #include <openssl/err.h> 16 #include <openssl/evp.h> 17 18 #ifndef OPENSSL_NO_DES 19 #include <openssl/des.h> 20 #endif 21 22 #ifndef NO_MD5CRYPT_1 23 #include <openssl/md5.h> 24 #endif 25 26 static unsigned const char cov_2char[64] = { 27 /* from crypto/des/fcrypt.c */ 28 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 29 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 30 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 31 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 32 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 33 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 34 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 35 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A 36 }; 37 38 static int 39 do_passwd(int passed_salt, char **salt_p, char **salt_malloc_p, 40 char *passwd, BIO * out, int quiet, int table, int reverse, 41 size_t pw_maxlen, int usecrypt, int use1, int useapr1); 42 43 static struct { 44 char *infile; 45 int in_stdin; 46 int noverify; 47 int quiet; 48 int reverse; 49 char *salt; 50 int table; 51 int use1; 52 int useapr1; 53 int usecrypt; 54 } passwd_config; 55 56 static const struct option passwd_options[] = { 57 #ifndef NO_MD5CRYPT_1 58 { 59 .name = "1", 60 .desc = "Use MD5 based BSD password algorithm 1", 61 .type = OPTION_FLAG, 62 .opt.flag = &passwd_config.use1, 63 }, 64 { 65 .name = "apr1", 66 .desc = "Use apr1 algorithm (Apache variant of BSD algorithm)", 67 .type = OPTION_FLAG, 68 .opt.flag = &passwd_config.useapr1, 69 }, 70 #endif 71 #ifndef OPENSSL_NO_DES 72 { 73 .name = "crypt", 74 .desc = "Use crypt algorithm (default)", 75 .type = OPTION_FLAG, 76 .opt.flag = &passwd_config.usecrypt, 77 }, 78 #endif 79 { 80 .name = "in", 81 .argname = "file", 82 .desc = "Read passwords from specified file", 83 .type = OPTION_ARG, 84 .opt.arg = &passwd_config.infile, 85 }, 86 { 87 .name = "noverify", 88 .desc = "Do not verify password", 89 .type = OPTION_FLAG, 90 .opt.flag = &passwd_config.noverify, 91 }, 92 { 93 .name = "quiet", 94 .desc = "Do not output warnings", 95 .type = OPTION_FLAG, 96 .opt.flag = &passwd_config.quiet, 97 }, 98 { 99 .name = "reverse", 100 .desc = "Reverse table columns (requires -table)", 101 .type = OPTION_FLAG, 102 .opt.flag = &passwd_config.reverse, 103 }, 104 { 105 .name = "salt", 106 .argname = "string", 107 .desc = "Use specified salt", 108 .type = OPTION_ARG, 109 .opt.arg = &passwd_config.salt, 110 }, 111 { 112 .name = "stdin", 113 .desc = "Read passwords from stdin", 114 .type = OPTION_FLAG, 115 .opt.flag = &passwd_config.in_stdin, 116 }, 117 { 118 .name = "table", 119 .desc = "Output cleartext and hashed passwords (tab separated)", 120 .type = OPTION_FLAG, 121 .opt.flag = &passwd_config.table, 122 }, 123 { NULL }, 124 }; 125 126 static void 127 passwd_usage(void) 128 { 129 fprintf(stderr, "usage: passwd [-1 | -apr1 | -crypt] [-in file] " 130 "[-noverify] [-quiet]\n" 131 " [-reverse] [-salt string] [-stdin] [-table] [password]\n\n"); 132 options_usage(passwd_options); 133 } 134 135 int 136 passwd_main(int argc, char **argv) 137 { 138 char *passwd = NULL, **passwds = NULL; 139 char *salt_malloc = NULL, *passwd_malloc = NULL; 140 size_t passwd_malloc_size = 0; 141 BIO *in = NULL, *out = NULL; 142 int badopt = 0; 143 int passed_salt = 0; 144 size_t pw_maxlen = 0; 145 int argsused; 146 int ret = 1; 147 148 if (single_execution) { 149 if (pledge("stdio cpath wpath rpath tty", NULL) == -1) { 150 perror("pledge"); 151 exit(1); 152 } 153 } 154 155 memset(&passwd_config, 0, sizeof(passwd_config)); 156 157 if (options_parse(argc, argv, passwd_options, NULL, &argsused) != 0) { 158 passwd_usage(); 159 goto err; 160 } 161 162 if (argsused < argc) 163 passwds = &argv[argsused]; 164 if (passwd_config.salt != NULL) 165 passed_salt = 1; 166 167 if (!passwd_config.usecrypt && !passwd_config.use1 && 168 !passwd_config.useapr1) 169 passwd_config.usecrypt = 1; /* use default */ 170 if (passwd_config.usecrypt + passwd_config.use1 + 171 passwd_config.useapr1 > 1) 172 badopt = 1; /* conflicting options */ 173 174 /* Reject unsupported algorithms */ 175 #ifdef OPENSSL_NO_DES 176 if (passwd_config.usecrypt) 177 badopt = 1; 178 #endif 179 #ifdef NO_MD5CRYPT_1 180 if (passwd_config.use1 || passwd_config.useapr1) 181 badopt = 1; 182 #endif 183 184 if (badopt) { 185 passwd_usage(); 186 goto err; 187 } 188 189 if ((out = BIO_new(BIO_s_file())) == NULL) 190 goto err; 191 BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT); 192 193 if (passwd_config.infile != NULL || passwd_config.in_stdin) { 194 if ((in = BIO_new(BIO_s_file())) == NULL) 195 goto err; 196 if (passwd_config.infile != NULL) { 197 assert(passwd_config.in_stdin == 0); 198 if (BIO_read_filename(in, passwd_config.infile) <= 0) 199 goto err; 200 } else { 201 assert(passwd_config.in_stdin); 202 BIO_set_fp(in, stdin, BIO_NOCLOSE); 203 } 204 } 205 if (passwd_config.usecrypt) 206 pw_maxlen = 8; 207 else if (passwd_config.use1 || passwd_config.useapr1) 208 pw_maxlen = 256;/* arbitrary limit, should be enough for most 209 * passwords */ 210 211 if (passwds == NULL) { 212 /* no passwords on the command line */ 213 214 passwd_malloc_size = pw_maxlen + 2; 215 /* longer than necessary so that we can warn about truncation */ 216 passwd = passwd_malloc = malloc(passwd_malloc_size); 217 if (passwd_malloc == NULL) 218 goto err; 219 } 220 if (in == NULL && passwds == NULL) { 221 /* build a null-terminated list */ 222 static char *passwds_static[2] = {NULL, NULL}; 223 224 passwds = passwds_static; 225 if (in == NULL) 226 if (EVP_read_pw_string(passwd_malloc, 227 passwd_malloc_size, "Password: ", 228 !(passed_salt || passwd_config.noverify)) != 0) 229 goto err; 230 passwds[0] = passwd_malloc; 231 } 232 if (in == NULL) { 233 assert(passwds != NULL); 234 assert(*passwds != NULL); 235 236 do { /* loop over list of passwords */ 237 passwd = *passwds++; 238 if (!do_passwd(passed_salt, &passwd_config.salt, 239 &salt_malloc, passwd, out, passwd_config.quiet, 240 passwd_config.table, passwd_config.reverse, 241 pw_maxlen, passwd_config.usecrypt, 242 passwd_config.use1, passwd_config.useapr1)) 243 goto err; 244 } while (*passwds != NULL); 245 } else { 246 int done; 247 248 assert(passwd != NULL); 249 do { 250 int r = BIO_gets(in, passwd, pw_maxlen + 1); 251 if (r > 0) { 252 char *c = (strchr(passwd, '\n')); 253 if (c != NULL) 254 *c = 0; /* truncate at newline */ 255 else { 256 /* ignore rest of line */ 257 char trash[BUFSIZ]; 258 do 259 r = BIO_gets(in, trash, sizeof trash); 260 while ((r > 0) && (!strchr(trash, '\n'))); 261 } 262 263 if (!do_passwd(passed_salt, &passwd_config.salt, 264 &salt_malloc, passwd, out, 265 passwd_config.quiet, passwd_config.table, 266 passwd_config.reverse, pw_maxlen, 267 passwd_config.usecrypt, passwd_config.use1, 268 passwd_config.useapr1)) 269 goto err; 270 } 271 done = (r <= 0); 272 } while (!done); 273 } 274 ret = 0; 275 276 err: 277 ERR_print_errors(bio_err); 278 279 free(salt_malloc); 280 free(passwd_malloc); 281 282 BIO_free(in); 283 BIO_free_all(out); 284 285 return (ret); 286 } 287 288 289 #ifndef NO_MD5CRYPT_1 290 /* MD5-based password algorithm (should probably be available as a library 291 * function; then the static buffer would not be acceptable). 292 * For magic string "1", this should be compatible to the MD5-based BSD 293 * password algorithm. 294 * For 'magic' string "apr1", this is compatible to the MD5-based Apache 295 * password algorithm. 296 * (Apparently, the Apache password algorithm is identical except that the 297 * 'magic' string was changed -- the laziest application of the NIH principle 298 * I've ever encountered.) 299 */ 300 static char * 301 md5crypt(const char *passwd, const char *magic, const char *salt) 302 { 303 static char out_buf[6 + 9 + 24 + 2]; /* "$apr1$..salt..$.......md5h 304 * ash..........\0" */ 305 unsigned char buf[MD5_DIGEST_LENGTH]; 306 char *salt_out; 307 int n; 308 unsigned int i; 309 EVP_MD_CTX *md = NULL, *md2 = NULL; 310 size_t passwd_len, salt_len; 311 312 passwd_len = strlen(passwd); 313 out_buf[0] = '$'; 314 out_buf[1] = 0; 315 assert(strlen(magic) <= 4); /* "1" or "apr1" */ 316 strlcat(out_buf, magic, sizeof(out_buf)); 317 strlcat(out_buf, "$", sizeof(out_buf)); 318 strlcat(out_buf, salt, sizeof(out_buf)); 319 assert(strlen(out_buf) <= 6 + 8); /* "$apr1$..salt.." */ 320 salt_out = out_buf + 2 + strlen(magic); 321 salt_len = strlen(salt_out); 322 assert(salt_len <= 8); 323 324 if ((md = EVP_MD_CTX_new()) == NULL) 325 goto err; 326 if (!EVP_DigestInit_ex(md, EVP_md5(), NULL)) 327 goto err; 328 if (!EVP_DigestUpdate(md, passwd, passwd_len)) 329 goto err; 330 if (!EVP_DigestUpdate(md, "$", 1)) 331 goto err; 332 if (!EVP_DigestUpdate(md, magic, strlen(magic))) 333 goto err; 334 if (!EVP_DigestUpdate(md, "$", 1)) 335 goto err; 336 if (!EVP_DigestUpdate(md, salt_out, salt_len)) 337 goto err; 338 339 if ((md2 = EVP_MD_CTX_new()) == NULL) 340 goto err; 341 if (!EVP_DigestInit_ex(md2, EVP_md5(), NULL)) 342 goto err; 343 if (!EVP_DigestUpdate(md2, passwd, passwd_len)) 344 goto err; 345 if (!EVP_DigestUpdate(md2, salt_out, salt_len)) 346 goto err; 347 if (!EVP_DigestUpdate(md2, passwd, passwd_len)) 348 goto err; 349 if (!EVP_DigestFinal_ex(md2, buf, NULL)) 350 goto err; 351 352 for (i = passwd_len; i > sizeof buf; i -= sizeof buf) { 353 if (!EVP_DigestUpdate(md, buf, sizeof buf)) 354 goto err; 355 } 356 if (!EVP_DigestUpdate(md, buf, i)) 357 goto err; 358 359 n = passwd_len; 360 while (n) { 361 if (!EVP_DigestUpdate(md, (n & 1) ? "\0" : passwd, 1)) 362 goto err; 363 n >>= 1; 364 } 365 if (!EVP_DigestFinal_ex(md, buf, NULL)) 366 goto err; 367 368 for (i = 0; i < 1000; i++) { 369 if (!EVP_DigestInit_ex(md2, EVP_md5(), NULL)) 370 goto err; 371 if (!EVP_DigestUpdate(md2, 372 (i & 1) ? (unsigned const char *) passwd : buf, 373 (i & 1) ? passwd_len : sizeof buf)) 374 goto err; 375 if (i % 3) { 376 if (!EVP_DigestUpdate(md2, salt_out, salt_len)) 377 goto err; 378 } 379 if (i % 7) { 380 if (!EVP_DigestUpdate(md2, passwd, passwd_len)) 381 goto err; 382 } 383 if (!EVP_DigestUpdate(md2, 384 (i & 1) ? buf : (unsigned const char *) passwd, 385 (i & 1) ? sizeof buf : passwd_len)) 386 goto err; 387 if (!EVP_DigestFinal_ex(md2, buf, NULL)) 388 goto err; 389 } 390 EVP_MD_CTX_free(md2); 391 md2 = NULL; 392 393 { 394 /* transform buf into output string */ 395 396 unsigned char buf_perm[sizeof buf]; 397 int dest, source; 398 char *output; 399 400 /* silly output permutation */ 401 for (dest = 0, source = 0; dest < 14; dest++, source = (source + 6) % 17) 402 buf_perm[dest] = buf[source]; 403 buf_perm[14] = buf[5]; 404 buf_perm[15] = buf[11]; 405 assert(16 == sizeof buf_perm); 406 407 output = salt_out + salt_len; 408 assert(output == out_buf + strlen(out_buf)); 409 410 *output++ = '$'; 411 412 for (i = 0; i < 15; i += 3) { 413 *output++ = cov_2char[buf_perm[i + 2] & 0x3f]; 414 *output++ = cov_2char[((buf_perm[i + 1] & 0xf) << 2) | 415 (buf_perm[i + 2] >> 6)]; 416 *output++ = cov_2char[((buf_perm[i] & 3) << 4) | 417 (buf_perm[i + 1] >> 4)]; 418 *output++ = cov_2char[buf_perm[i] >> 2]; 419 } 420 assert(i == 15); 421 *output++ = cov_2char[buf_perm[i] & 0x3f]; 422 *output++ = cov_2char[buf_perm[i] >> 6]; 423 *output = 0; 424 assert(strlen(out_buf) < sizeof(out_buf)); 425 } 426 EVP_MD_CTX_free(md); 427 428 return out_buf; 429 err: 430 EVP_MD_CTX_free(md); 431 EVP_MD_CTX_free(md2); 432 433 return NULL; 434 } 435 #endif 436 437 438 static int 439 do_passwd(int passed_salt, char **salt_p, char **salt_malloc_p, 440 char *passwd, BIO * out, int quiet, int table, int reverse, 441 size_t pw_maxlen, int usecrypt, int use1, int useapr1) 442 { 443 char *hash = NULL; 444 445 assert(salt_p != NULL); 446 assert(salt_malloc_p != NULL); 447 448 /* first make sure we have a salt */ 449 if (!passed_salt) { 450 #ifndef OPENSSL_NO_DES 451 if (usecrypt) { 452 if (*salt_malloc_p == NULL) { 453 *salt_p = *salt_malloc_p = malloc(3); 454 if (*salt_malloc_p == NULL) 455 goto err; 456 } 457 arc4random_buf(*salt_p, 2); 458 (*salt_p)[0] = cov_2char[(*salt_p)[0] & 0x3f]; /* 6 bits */ 459 (*salt_p)[1] = cov_2char[(*salt_p)[1] & 0x3f]; /* 6 bits */ 460 (*salt_p)[2] = 0; 461 } 462 #endif /* !OPENSSL_NO_DES */ 463 464 #ifndef NO_MD5CRYPT_1 465 if (use1 || useapr1) { 466 int i; 467 468 if (*salt_malloc_p == NULL) { 469 *salt_p = *salt_malloc_p = malloc(9); 470 if (*salt_malloc_p == NULL) 471 goto err; 472 } 473 arc4random_buf(*salt_p, 8); 474 475 for (i = 0; i < 8; i++) 476 (*salt_p)[i] = cov_2char[(*salt_p)[i] & 0x3f]; /* 6 bits */ 477 (*salt_p)[8] = 0; 478 } 479 #endif /* !NO_MD5CRYPT_1 */ 480 } 481 assert(*salt_p != NULL); 482 483 /* truncate password if necessary */ 484 if ((strlen(passwd) > pw_maxlen)) { 485 if (!quiet) 486 BIO_printf(bio_err, 487 "Warning: truncating password to %zu characters\n", 488 pw_maxlen); 489 passwd[pw_maxlen] = 0; 490 } 491 assert(strlen(passwd) <= pw_maxlen); 492 493 /* now compute password hash */ 494 #ifndef OPENSSL_NO_DES 495 if (usecrypt) 496 hash = DES_crypt(passwd, *salt_p); 497 #endif 498 #ifndef NO_MD5CRYPT_1 499 if (use1 || useapr1) 500 if ((hash = md5crypt(passwd, (use1 ? "1" : "apr1"), *salt_p)) == NULL) 501 goto err; 502 #endif 503 assert(hash != NULL); 504 505 if (table && !reverse) 506 BIO_printf(out, "%s\t%s\n", passwd, hash); 507 else if (table && reverse) 508 BIO_printf(out, "%s\t%s\n", hash, passwd); 509 else 510 BIO_printf(out, "%s\n", hash); 511 return 1; 512 513 err: 514 free(*salt_malloc_p); 515 *salt_malloc_p = NULL; 516 return 0; 517 } 518 #else 519 520 int 521 passwd_main(int argc, char **argv) 522 { 523 fputs("Program not available.\n", stderr) 524 return (1); 525 } 526 #endif 527