2 * Copyright (c) 1995-1997, 1999 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
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.
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
43 static char* alg_string
;
45 static int version_flag
;
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
}
61 int num_args
= sizeof(args
) / sizeof(args
[0]);
66 arg_printusage(args
, num_args
, NULL
, "[num seed]");
71 * Renew the OTP for a user.
72 * The pass-phrase is not required (RFC 1938/8.0)
76 renew (int argc
, char **argv
, OtpAlgorithm
*alg
, char *inuser
)
78 OtpContext newctx
, *ctx
;
86 newctx
.n
= atoi (argv
[0]);
87 strlcpy (newctx
.seed
, argv
[1], sizeof(newctx
.seed
));
89 snprintf (prompt
, sizeof(prompt
),
94 if (UI_UTIL_read_pw_string (pw
, sizeof(pw
), prompt
, 0) == 0 &&
95 otp_parse (newctx
.key
, pw
, alg
) == 0) {
101 dbm
= otp_db_open ();
103 warnx ("otp_db_open failed");
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.
117 verify_user_otp(char *username
)
120 char passwd
[OTP_MAX_PASSPHRASE
+ 1];
124 if (otp_challenge (&ctx
, username
, ss
, sizeof(ss
)) != 0) {
125 warnx("no otp challenge found for %s", username
);
129 if (asprintf(&prompt
, "%s's %s Password: ", username
, ss
) == -1 ||
131 err(1, "out of memory");
132 if (UI_UTIL_read_pw_string(passwd
, sizeof(passwd
)-1, prompt
, 0)) {
137 return otp_verify_user (&ctx
, passwd
);
141 * Set the OTP for a user
145 set (int argc
, char **argv
, OtpAlgorithm
*alg
, char *inuser
)
149 char pw
[OTP_MAX_PASSPHRASE
+ 1];
154 ctx
.user
= strdup (inuser
);
155 if (ctx
.user
== NULL
)
156 err (1, "out of memory");
158 ctx
.n
= atoi (argv
[0]);
159 strlcpy (ctx
.seed
, argv
[1], sizeof(ctx
.seed
));
162 if (UI_UTIL_read_pw_string (pw
, sizeof(pw
), "Pass-phrase: ",
163 UI_UTIL_FLAG_VERIFY
))
165 if (strlen (pw
) < OTP_MIN_PASSPHRASE
)
166 printf ("Too short pass-phrase. Use at least %d characters\n",
168 } while(strlen(pw
) < OTP_MIN_PASSPHRASE
);
169 ctx
.alg
->init (ctx
.key
, pw
, ctx
.seed
);
170 for (i
= 0; i
< ctx
.n
; ++i
)
171 ctx
.alg
->next (ctx
.key
);
175 err (1, "otp_db_open failed");
177 ret
= otp_put (db
, &ctx
);
184 * Delete otp of user from the database
188 delete_otp (int argc
, char **argv
, char *inuser
)
196 errx (1, "otp_db_open failed");
199 ret
= otp_delete(db
, &ctx
);
205 * Tell whether the user has an otp
209 has_an_otp(char *inuser
)
217 warnx ("otp_db_open failed");
218 return 0; /* if no db no otp! */
222 ret
= otp_simple_get(db
, &ctx
);
229 * Get and print out the otp entry for some user
233 print_otp_entry_for_name (void *db
, char *inuser
)
238 if (!otp_simple_get(db
, &ctx
)) {
241 ctx
.user
, ctx
.alg
->name
, ctx
.n
, ctx
.seed
);
245 ctime(&ctx
.lock_time
));
247 fprintf(stdout
, "\n");
252 open_otp (int argc
, char **argv
, char *inuser
)
260 errx (1, "otp_db_open failed");
263 ret
= otp_simple_get (db
, &ctx
);
265 ret
= otp_put (db
, &ctx
);
271 * Print otp entries for one or all users
275 list_otps (int argc
, char **argv
, char *inuser
)
282 errx (1, "otp_db_open failed");
285 print_otp_entry_for_name(db
, inuser
);
287 /* scans all users... so as to get a deterministic order */
288 while ((pw
= getpwent()))
289 print_otp_entry_for_name(db
, pw
->pw_name
);
296 main (int argc
, char **argv
)
300 OtpAlgorithm
*alg
= otp_find_alg (OTP_ALG_DEFAULT
);
304 setprogname (argv
[0]);
305 if(getarg(args
, num_args
, argc
, argv
, &optidx
))
314 if(deletep
&& uid
!= 0)
315 errx (1, "Only root can delete OTPs");
317 alg
= otp_find_alg (alg_string
);
319 errx (1, "Unknown algorithm: %s", alg_string
);
321 if (user
&& uid
!= 0)
322 errx (1, "Only root can use `-u'");
326 if (!(listp
|| deletep
|| renewp
|| openp
))
329 if ( listp
+ deletep
+ renewp
+ defaultp
+ openp
!= 1)
330 usage(1); /* one of -d or -l or -r or none */
332 if(deletep
|| openp
|| listp
) {
334 errx(1, "delete, open, and list requires no arguments");
337 errx(1, "setup, and renew requires `num', and `seed'");
340 return list_otps (argc
, argv
, user
);
343 user
= roken_get_username(userbuf
, sizeof(userbuf
));
345 err (1, "You don't exist");
349 * users other that root must provide the next OTP to update the sequence.
350 * it avoids someone to use a pending session to change an OTP sequence.
353 if (uid
!= 0 && (defaultp
|| renewp
)) {
354 if (!has_an_otp(user
)) {
355 errx (1, "Only root can set an initial OTP");
356 } else { /* Check the next OTP (RFC 1938/8.0: SHOULD) */
357 if (verify_user_otp(user
) != 0) {
358 errx (1, "User authentication failed");
364 return delete_otp (argc
, argv
, user
);
366 return renew (argc
, argv
, alg
, user
);
368 return open_otp (argc
, argv
, user
);
370 return set (argc
, argv
, alg
, user
);