third_party/heimdal/appl/otp/otp.c

   1 /*
   2  * Copyright (c) 1995-1997, 1999 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "otp_locl.h"
  35 #include <getarg.h>
  36
  37 RCSID("$Id$");
  38
  39 static int listp;
  40 static int deletep;
  41 static int openp;
  42 static int renewp;
  43 static char* alg_string;
  44 static char *user;
  45 static int version_flag;
  46 static int help_flag;
  47
  48 struct getargs args[] = {
  49     { "list", 'l', arg_flag, &listp, "list OTP status", NULL },
  50     { "delete", 'd', arg_flag, &deletep, "delete OTP", NULL },
  51     { "open", 'o', arg_flag, &openp, "open a locked OTP", NULL },
  52     { "renew", 'r', arg_flag, &renewp, "securely renew OTP", NULL },
  53     { "hash", 'f', arg_string, &alg_string,
  54       "hash algorithm (md4, md5, or sha)", "algorithm"},
  55     { "user", 'u', arg_string, &user,
  56       "user other than current user (root only)", "user" },
  57     { "version", 0, arg_flag, &version_flag, NULL, NULL },
  58     { "help", 'h', arg_flag, &help_flag, NULL, NULL }
  59 };
  60
  61 int num_args = sizeof(args) / sizeof(args[0]);
  62
  63 static void
  64 usage(int code)
  65 {
  66     arg_printusage(args, num_args, NULL, "[num seed]");
  67     exit(code);
  68 }
  69
  70 /*
  71  * Renew the OTP for a user.
  72  * The pass-phrase is not required (RFC 1938/8.0)
  73  */
  74
  75 static int
  76 renew (int argc, char **argv, OtpAlgorithm *alg, char *inuser)
  77 {
  78     OtpContext newctx, *ctx;
  79     char prompt[128];
  80     char pw[64];
  81     void *dbm;
  82     int ret;
  83
  84     newctx.alg = alg;
  85     newctx.user = inuser;
  86     newctx.n = atoi (argv[0]);
  87     strlcpy (newctx.seed, argv[1], sizeof(newctx.seed));
  88     strlwr(newctx.seed);
  89     snprintf (prompt, sizeof(prompt),
  90               "[ otp-%s %u %s ]",
  91               newctx.alg->name,
  92               newctx.n,
  93               newctx.seed);
  94     if (UI_UTIL_read_pw_string (pw, sizeof(pw), prompt, 0) == 0 &&
  95         otp_parse (newctx.key, pw, alg) == 0) {
  96         ctx = &newctx;
  97         ret = 0;
  98     } else
  99         return 1;
 100
 101     dbm = otp_db_open ();
 102     if (dbm == NULL) {
 103         warnx ("otp_db_open failed");
 104         return 1;
 105     }
 106     otp_put (dbm, ctx);
 107     otp_db_close (dbm);
 108     return ret;
 109 }
 110
 111 /*
 112  * Return 0 if the user could enter the next OTP.
 113  * I would rather have returned !=0 but it's shell-like here around.
 114  */
 115
 116 static int
 117 verify_user_otp(char *username)
 118 {
 119     OtpContext ctx;
 120     char passwd[OTP_MAX_PASSPHRASE + 1];
 121     char prompt[128], ss[256];
 122
 123     if (otp_challenge (&ctx, username, ss, sizeof(ss)) != 0) {
 124         warnx("no otp challenge found for %s", username);
 125         return 1;
 126     }
 127
 128     snprintf (prompt, sizeof(prompt), "%s's %s Password: ", username, ss);
 129     if(UI_UTIL_read_pw_string(passwd, sizeof(passwd)-1, prompt, 0))
 130         return 1;
 131     return otp_verify_user (&ctx, passwd);
 132 }
 133
 134 /*
 135  * Set the OTP for a user
 136  */
 137
 138 static int
 139 set (int argc, char **argv, OtpAlgorithm *alg, char *inuser)
 140 {
 141     void *db;
 142     OtpContext ctx;
 143     char pw[OTP_MAX_PASSPHRASE + 1];
 144     int ret;
 145     int i;
 146
 147     ctx.alg = alg;
 148     ctx.user = strdup (inuser);
 149     if (ctx.user == NULL)
 150         err (1, "out of memory");
 151
 152     ctx.n = atoi (argv[0]);
 153     strlcpy (ctx.seed, argv[1], sizeof(ctx.seed));
 154     strlwr(ctx.seed);
 155     do {
 156         if (UI_UTIL_read_pw_string (pw, sizeof(pw), "Pass-phrase: ",
 157             UI_UTIL_FLAG_VERIFY))
 158             return 1;
 159         if (strlen (pw) < OTP_MIN_PASSPHRASE)
 160             printf ("Too short pass-phrase.  Use at least %d characters\n",
 161                     OTP_MIN_PASSPHRASE);
 162     } while(strlen(pw) < OTP_MIN_PASSPHRASE);
 163     ctx.alg->init (ctx.key, pw, ctx.seed);
 164     for (i = 0; i < ctx.n; ++i)
 165         ctx.alg->next (ctx.key);
 166     db = otp_db_open ();
 167     if(db == NULL) {
 168         free (ctx.user);
 169         err (1, "otp_db_open failed");
 170     }
 171     ret = otp_put (db, &ctx);
 172     otp_db_close (db);
 173     free (ctx.user);
 174     return ret;
 175 }
 176
 177 /*
 178  * Delete otp of user from the database
 179  */
 180
 181 static int
 182 delete_otp (int argc, char **argv, char *inuser)
 183 {
 184     void *db;
 185     OtpContext ctx;
 186     int ret;
 187
 188     db = otp_db_open ();
 189     if(db == NULL)
 190         errx (1, "otp_db_open failed");
 191
 192     ctx.user = inuser;
 193     ret = otp_delete(db, &ctx);
 194     otp_db_close (db);
 195     return ret;
 196 }
 197
 198 /*
 199  * Tell whether the user has an otp
 200  */
 201
 202 static int
 203 has_an_otp(char *inuser)
 204 {
 205     void *db;
 206     OtpContext ctx;
 207     int ret;
 208
 209     db = otp_db_open ();
 210     if(db == NULL) {
 211         warnx ("otp_db_open failed");
 212         return 0; /* if no db no otp! */
 213     }
 214
 215     ctx.user = inuser;
 216     ret = otp_simple_get(db, &ctx);
 217
 218     otp_db_close (db);
 219     return !ret;
 220 }
 221
 222 /*
 223  * Get and print out the otp entry for some user
 224  */
 225
 226 static void
 227 print_otp_entry_for_name (void *db, char *inuser)
 228 {
 229     OtpContext ctx;
 230
 231     ctx.user = inuser;
 232     if (!otp_simple_get(db, &ctx)) {
 233         fprintf(stdout,
 234                 "%s\totp-%s %d %s",
 235                 ctx.user, ctx.alg->name, ctx.n, ctx.seed);
 236         if (ctx.lock_time)
 237             fprintf(stdout,
 238                     "\tlocked since %s",
 239                     ctime(&ctx.lock_time));
 240         else
 241             fprintf(stdout, "\n");
 242     }
 243 }
 244
 245 static int
 246 open_otp (int argc, char **argv, char *inuser)
 247 {
 248     void *db;
 249     OtpContext ctx;
 250     int ret;
 251
 252     db = otp_db_open ();
 253     if (db == NULL)
 254         errx (1, "otp_db_open failed");
 255
 256     ctx.user = inuser;
 257     ret = otp_simple_get (db, &ctx);
 258     if (ret == 0)
 259         ret = otp_put (db, &ctx);
 260     otp_db_close (db);
 261     return ret;
 262 }
 263
 264 /*
 265  * Print otp entries for one or all users
 266  */
 267
 268 static int
 269 list_otps (int argc, char **argv, char *inuser)
 270 {
 271     void *db;
 272     struct passwd *pw;
 273
 274     db = otp_db_open ();
 275     if(db == NULL)
 276         errx (1, "otp_db_open failed");
 277
 278     if (inuser)
 279         print_otp_entry_for_name(db, inuser);
 280     else
 281         /* scans all users... so as to get a deterministic order */
 282         while ((pw = getpwent()))
 283             print_otp_entry_for_name(db, pw->pw_name);
 284
 285     otp_db_close (db);
 286     return 0;
 287 }
 288
 289 int
 290 main (int argc, char **argv)
 291 {
 292     int defaultp = 0;
 293     int uid = getuid();
 294     OtpAlgorithm *alg = otp_find_alg (OTP_ALG_DEFAULT);
 295     int optidx = 0;
 296     char userbuf[128];
 297
 298     setprogname (argv[0]);
 299     if(getarg(args, num_args, argc, argv, &optidx))
 300         usage(1);
 301     if(help_flag)
 302         usage(0);
 303     if(version_flag) {
 304         print_version(NULL);
 305         exit(0);
 306     }
 307
 308     if(deletep && uid != 0)
 309         errx (1, "Only root can delete OTPs");
 310     if(alg_string) {
 311         alg = otp_find_alg (alg_string);
 312         if (alg == NULL)
 313             errx (1, "Unknown algorithm: %s", alg_string);
 314     }
 315     if (user && uid != 0)
 316         errx (1, "Only root can use `-u'");
 317     argc -= optidx;
 318     argv += optidx;
 319
 320     if (!(listp || deletep || renewp || openp))
 321         defaultp = 1;
 322
 323     if ( listp + deletep + renewp + defaultp + openp != 1)
 324         usage(1); /* one of -d or -l or -r or none */
 325
 326     if(deletep || openp || listp) {
 327         if(argc != 0)
 328             errx(1, "delete, open, and list requires no arguments");
 329     } else {
 330         if(argc != 2)
 331             errx(1, "setup, and renew requires `num', and `seed'");
 332     }
 333     if (listp)
 334         return list_otps (argc, argv, user);
 335
 336     if (user == NULL) {
 337         user = roken_get_username(userbuf, sizeof(userbuf));
 338         if (user == NULL)
 339             err (1, "You don't exist");
 340     }
 341
 342     /*
 343      * users other that root must provide the next OTP to update the sequence.
 344      * it avoids someone to use a pending session to change an OTP sequence.
 345      * see RFC 1938/8.0.
 346      */
 347     if (uid != 0 && (defaultp || renewp)) {
 348         if (!has_an_otp(user)) {
 349             errx (1, "Only root can set an initial OTP");
 350         } else { /* Check the next OTP (RFC 1938/8.0: SHOULD) */
 351             if (verify_user_otp(user) != 0) {
 352                 errx (1, "User authentication failed");
 353             }
 354         }
 355     }
 356
 357     if (deletep)
 358         return delete_otp (argc, argv, user);
 359     else if (renewp)
 360         return renew (argc, argv, alg, user);
 361     else if (openp)
 362         return open_otp (argc, argv, user);
 363     else
 364         return set (argc, argv, alg, user);
 365 }