oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

new files

Browse Source 
git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@885 ec53bebd-3082-4978-b11e-865c3cabbd6b
This commit is contained in:
Assar Westerlund
1996-10-25 05:51:14 +00:00
parent 58bc1c7e9a
commit cc2014c8c7
14 changed files with 3507 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
appl/otp/Makefile.in Normal file
View File

@@ -0,0 +1,73 @@
# $Id$
SHELL = /bin/sh
srcdir = @srcdir@
VPATH = @srcdir@
topdir = ../..
CC = @CC@
AR = ar
RANLIB = @RANLIB@
DEFS = @DEFS@
CFLAGS = @CFLAGS@
LD_FLAGS = @LD_FLAGS@
INSTALL = @INSTALL@
LIBS = @LIBS@
MKINSTALLDIRS = @top_srcdir@/mkinstalldirs
prefix = @prefix@
exec_prefix = $(prefix)
libdir = $(exec_prefix)/lib
libexecdir = $(exec_prefix)/libexec
bindir = $(exec_prefix)/bin
PROG_BIN = otp
PROG_LIBEXEC =
PROGS = $(PROG_BIN) $(PROG_LIBEXEC)
SOURCES_OTP = otp.c
OBJECTS_OTP = otp.o
OBJECTS = $(OBJECTS_OTP)
SOURCES = $(SOURCES_OTP)
all: $(PROGS)
Wall:
make CFLAGS="-g -Wall -Wmissing-prototypes -Wmissing-declarations -D__USE_FIXED_PROTOTYPES__"
.c.o:
$(CC) -c $(CPPFLAGS) $(DEFS) -I../.. -I../../include -I$(srcdir) -I$(srcdir)/../../include $(CFLAGS) $<
install: all
$(MKINSTALLDIRS) $(bindir)
for x in $(PROG_BIN); do $(INSTALL) $$x $(bindir); done
uninstall:
TAGS: $(SOURCES)
etags $(SOURCES)
check:
clean:
rm -f *.a *.o $(PROGS)
mostlyclean: clean
distclean: clean
rm -f Makefile *~
rm -rf CVS
realclean: distclean
rm -f TAGS
OLIB=-L../../lib/otp -lotp -L../../lib/des -ldes -L../../lib/roken -lroken
otp: $(OBJECTS_OTP)
$(CC) $(LD_FLAGS) $(LDFLAGS) -o $@ $(OBJECTS_OTP) $(OLIB) $(LIBS)
$(OBJECTS): ../../config.h

205
appl/otp/otp.c Normal file
View File

@@ -0,0 +1,205 @@
#include "otp_locl.h"
RCSID("$Id$");
char *prog;
static void
usage ()
{
fprintf(stderr,
"Usage: %s [-h] [-r] [-s] [-n count] [-f alg] num seed\n",
prog);
exit (1);
}
static void
strlwr (char *s)
{
while(*s) {
*s = tolower(*s);
s++;
}
}
static int
renew (int argc, char **argv, int count, OtpAlgorithm *alg, int hexp)
{
struct passwd *pwd;
OtpContext oldctx, newctx, *ctx;
char *user;
char prompt[128];
char pw[64];
void *dbm;
int ret;
if (argc != 2)
usage();
pwd = getpwuid (getuid ());
if (pwd == NULL) {
fprintf(stderr, "%s: You don't exist\n", prog);
return 1;
}
user = pwd->pw_name;
ctx = &oldctx;
if(otp_challenge (ctx, user, prompt, sizeof(prompt)))
return 1;
des_read_pw_string (pw, sizeof(pw), prompt, 0);
ret = otp_verify_user_1 (ctx, pw);
if (ret == 0) {
newctx.alg = alg;
newctx.user = user;
newctx.n = atoi (argv[0]);
strncpy (newctx.seed, argv[1], sizeof(newctx.seed));
newctx.seed[sizeof(newctx.seed) - 1] = '\0';
strlwr(newctx.seed);
sprintf (prompt, "[ otp-%s %u %s ]",
newctx.alg->name,
newctx.n,
newctx.seed);
des_read_pw_string (pw, sizeof(pw), prompt, 0);
if (otp_parse (newctx.key, pw, alg) == 0) {
ctx = &newctx;
}
}
dbm = otp_db_open ();
if (dbm == NULL) {
fprintf (stderr, "%s: otp_db_open failed\n", prog);
free (user);
return 1;
}
otp_put (dbm, ctx);
otp_db_close (dbm);
free (user);
return ret;
}
static int
set (int argc, char **argv, int count, OtpAlgorithm *alg, int hexp)
{
void *db;
OtpContext ctx;
struct passwd *pwd;
char pw[OTP_MAX_PASSPHRASE + 1];
int ret;
int i;
if (argc != 2)
usage();
pwd = getpwuid (getuid ());
if (pwd == NULL) {
fprintf(stderr, "%s: You don't exist\n", prog);
return 1;
}
ctx.alg = alg;
ctx.user = strdup (pwd->pw_name);
ctx.n = atoi (argv[0]);
strncpy (ctx.seed, argv[1], sizeof(ctx.seed));
ctx.seed[sizeof(ctx.seed) - 1] = '\0';
strlwr(ctx.seed);
do {
des_read_pw_string (pw, sizeof(pw), "Pass-phrase", 1);
if (strlen (pw) < OTP_MIN_PASSPHRASE)
printf ("Too short pass-phrase. Use at least %d characters\n",
OTP_MIN_PASSPHRASE);
} while(strlen(pw) < OTP_MIN_PASSPHRASE);
ctx.alg->init (ctx.key, pw, ctx.seed);
for (i = 0; i < ctx.n; ++i)
ctx.alg->next (ctx.key);
db = otp_db_open ();
if(db == NULL) {
fprintf (stderr, "%s: otp_db_open failed\n", prog);
free (ctx.user);
return 1;
}
ret = otp_put (db, &ctx);
otp_db_close (db);
free (ctx.user);
return ret;
}
int
print (int argc, char **argv, int count, OtpAlgorithm *alg, int hexp)
{
char pw[64];
OtpKey key;
int n;
int i;
char *seed;
if (argc != 2)
usage ();
n = atoi(argv[0]);
seed = argv[1];
des_read_pw_string (pw, sizeof(pw), "Password: ", 0);
alg->init (key, pw, seed);
for (i = 0; i < n; ++i) {
char s[30];
alg->next (key);
if (i >= n - count) {
if (hexp)
otp_print_hex (key, s);
else
otp_print_stddict (key, s);
printf ("%d: %s\n", i + 1, s);
}
}
return 0;
}
int
main (int argc, char **argv)
{
int c;
int count = 10;
int setp = 0;
int hexp = 0;
int renewp = 0;
OtpAlgorithm *alg = otp_find_alg ("md4");
prog = argv[0];
while ((c = getopt (argc, argv, "rshn:f:")) != EOF)
switch (c) {
case 'r' :
renewp = 1;
break;
case 'n' :
count = atoi (optarg);
break;
case 'h' :
hexp = 1;
break;
case 's' :
setp = 1;
break;
case 'f' :
alg = otp_find_alg (optarg);
if (alg == NULL) {
fprintf (stderr, "%s: Unknown algorithm: %s\n", prog, optarg);
return 1;
}
break;
default :
usage ();
break;
}
if (setp && renewp) {
fprintf (stderr, "%s: `-r' and `-s' incompatible\n", prog);
return 1;
}
argc -= optind;
argv += optind;
if (setp)
return set (argc, argv, count, alg, hexp);
else if (renewp)
return renew (argc, argv, count, alg, hexp);
else
return print (argc, argv, count, alg, hexp);
}

18
appl/otp/otp_locl.h Normal file
View File

@@ -0,0 +1,18 @@
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#include <roken.h>
#include <otp.h>

80
lib/otp/Makefile.in Normal file
View File

@@ -0,0 +1,80 @@
#
# $Id$
#
SHELL = /bin/sh
srcdir = @srcdir@
VPATH = @srcdir@
CC = @CC@
AR = ar
RANLIB = @RANLIB@
DEFS = @DEFS@
CFLAGS = @CFLAGS@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
MKINSTALLDIRS = @top_srcdir@/mkinstalldirs
prefix = @prefix@
exec_prefix = $(prefix)
libdir = $(exec_prefix)/lib
PICFLAGS = @PICFLAGS@
LIBNAME = libotp
LIBEXT = @LIBEXT@
SHLIBEXT = @SHLIBEXT@
SHARED = @SHARED@
LIB = $(LIBNAME).$(LIBEXT)
SOURCES = otp.c otp_challenge.c otp_db.c otp_md.c \
otp_parse.c otp_print.c otp_verify.c
OBJECTS = otp.o otp_challenge.o otp_db.o otp_md.o \
otp_parse.o otp_print.o otp_verify.o
all: $(LIB)
Wall:
make CFLAGS="-g -Wall -Wmissing-prototypes -Wmissing-declarations -D__USE_FIXED_PROTOTYPES__"
.c.o:
$(CC) -c $(CPPFLAGS) $(DEFS) -I../.. -I../../include -I$(srcdir) -I$(srcdir)/../../include -I$(srcdir)/../des $(CFLAGS) $(PICFLAGS) $<
install: all
$(MKINSTALLDIRS) $(libdir)
$(INSTALL) -m 0555 $(LIB) $(libdir)
uninstall:
TAGS: $(SOURCES)
etags $(SOURCES)
check:
clean:
rm -f $(LIB) *.o *.a
mostlyclean: clean
distclean: clean
rm -f Makefile *~
rm -rf CVS
realclean: distclean
rm -f TAGS
$(LIBNAME).a: $(OBJECTS)
rm -f $@
$(AR) cr $@ $(OBJECTS)
-$(RANLIB) $@
$(LIBNAME).$(SHLIBEXT): $(OBJECTS)
rm -f $@
$(CC) $(CFLAGS) $(PICFLAGS) $(SHARED) -o $@ $(OBJECTS)
$(OBJECTS): ../../config.h
.PHONY: all install uninstall check clean mostlyclean distclean realclean

24
lib/otp/otp.c Normal file
View File

@@ -0,0 +1,24 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp_locl.h"
#include "otp_md.h"
static OtpAlgorithm algorithms[] = {
{ALG_MD4, "md4", 16, otp_md4_hash, otp_md4_init, otp_md4_next},
{ALG_MD5, "md5", 16, otp_md5_hash, otp_md5_init, otp_md5_next},
{ALG_SHA, "sha", 16, otp_sha_hash, otp_sha_init, otp_sha_next}
};
OtpAlgorithm *
otp_find_alg (char *name)
{
int i;
for (i = 0; i < sizeof(algorithms)/sizeof(*algorithms); ++i)
if (strcmp (name, algorithms[i].name) == 0)
return &algorithms[i];
return NULL;
}

49
lib/otp/otp.h Normal file
View File

@@ -0,0 +1,49 @@
/* $Id$ */
#include <stdlib.h>
enum {OTPKEYSIZE = 8};
typedef unsigned char OtpKey[OTPKEYSIZE];
#define OTP_MIN_PASSPHRASE 10
#define OTP_MAX_PASSPHRASE 63
#define OTP_USER_TIMEOUT 60
#define OTP_DB_TIMEOUT 60
typedef enum { ALG_MD4, ALG_MD5, ALG_SHA } OtpAlgID;
typedef struct {
OtpAlgID id;
char *name;
int hashsize;
int (*hash)(char *s, size_t len, char *res);
int (*init)(OtpKey key, char *pwd, char *seed);
int (*next)(OtpKey key);
} OtpAlgorithm;
typedef struct {
char *user;
OtpAlgorithm *alg;
unsigned n;
char seed[17];
OtpKey key;
} OtpContext;
OtpAlgorithm *otp_find_alg (char *name);
void otp_print_stddict (OtpKey key, char *str);
void otp_print_hex (OtpKey key, char *str);
unsigned opt_checksum (OtpKey key);
int otp_parse_hex (OtpKey key, char *);
int otp_parse_stddict (OtpKey key, char *);
int otp_parse_altdict (OtpKey key, char *, OtpAlgorithm *);
int otp_parse (OtpKey key, char *, OtpAlgorithm *);
int otp_challenge (OtpContext *ctx, char *user, char *str, size_t len);
int otp_verify_user (OtpContext *ctx, char *passwd);
int otp_verify_user_1 (OtpContext *ctx, char *passwd);
void *otp_db_open ();
void otp_db_close (void *);
int otp_put (void *, OtpContext *ctx);
int otp_get (void *, OtpContext *ctx);

24
lib/otp/otp_challenge.c Normal file
View File

@@ -0,0 +1,24 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp_locl.h"
int
otp_challenge (OtpContext *ctx, char *user, char *str, size_t len)
{
void *dbm;
int ret;
ctx->user = strdup(user);
dbm = otp_db_open ();
if (dbm == NULL)
return -1;
ret = otp_get (dbm, ctx);
otp_db_close (dbm);
if (ret)
return ret;
sprintf (str, "[ otp-%s %u %s ]", ctx->alg->name, ctx->n-1, ctx->seed);
return 0;
}

205
lib/otp/otp_db.c Normal file
View File

@@ -0,0 +1,205 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp_locl.h"
static int
get_filename (char *user, char *buf, size_t len)
{
struct passwd *pwd;
pwd = getpwnam (user);
if (pwd == NULL)
return -1;
strncpy (buf, pwd->pw_dir, len);
buf[len - 1] = '\0';
strncat (buf, OTPKEYS, len - strlen(buf));
buf[len - 1] = '\0';
return 0;
}
static FILE *
open_file (char *user, char *mode)
{
char fname[BUFSIZ];
if (get_filename (user, fname, sizeof(fname)))
return NULL;
return fopen (fname, mode);
}
void *
otp_db_open ()
{
DBM *ret;
int lock;
do {
struct stat statbuf;
lock = open (OTP_DB_LOCK, O_WRONLY | O_CREAT | O_EXCL, 0666);
if (lock >= 0) {
close(lock);
break;
}
if (stat (OTP_DB_LOCK, &statbuf) < 0)
if (errno == ENOENT)
continue;
else
return NULL;
if (time(NULL) - statbuf.st_mtime > OTP_DB_TIMEOUT)
unlink (OTP_DB_LOCK);
} while(1);
return dbm_open (OTP_DB, O_RDWR | O_CREAT, 0600);
}
void
otp_db_close (void *dbm)
{
dbm_close ((DBM *)dbm);
unlink (OTP_DB_LOCK);
}
#if 0
int
otp_put (OtpContext *ctx)
{
FILE *f;
char s[32];
f = open_file (ctx->user, "w");
if (f == NULL)
return -1;
otp_print_hex (ctx->key, s);
if(fprintf (f, "%s %u %s %s\n", ctx->alg->name, ctx->n, ctx->seed, s)
< 0) {
fclose (f);
return -1;
}
if(fclose (f))
return -1;
return 0;
}
#endif
/*
* Read this entry from the database and lock it.
*/
int
otp_get (void *v, OtpContext *ctx)
{
DBM *dbm = (DBM *)v;
datum dat, key;
unsigned char *p;
time_t now, then;
key.dsize = strlen(ctx->user);
key.dptr = ctx->user;
dat = dbm_fetch (dbm, key);
if (dat.dptr == NULL)
return -1;
p = dat.dptr;
time(&now);
memcpy (&then, p, sizeof(then));
if (then && now - then < OTP_USER_TIMEOUT)
return -1;
memcpy (p, &now, sizeof(now));
p += sizeof(now);
ctx->alg = otp_find_alg (p);
if (ctx->alg == NULL)
return -1;
p += strlen(p) + 1;
ctx->n = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
p += 4;
memcpy (ctx->key, p, OTPKEYSIZE);
p += OTPKEYSIZE;
strncpy (ctx->seed, p, sizeof(ctx->seed));
ctx->seed[sizeof(ctx->seed) - 1] = '\0';
return dbm_store (dbm, key, dat, DBM_REPLACE);
}
/*
* Write this entry to the database.
*/
int
otp_put (void *v, OtpContext *ctx)
{
DBM *dbm = (DBM *)v;
datum dat, key;
unsigned char buf[1024], *p;
time_t zero = 0;
key.dsize = strlen(ctx->user);
key.dptr = ctx->user;
p = buf;
memcpy (p, &zero, sizeof(zero));
p += sizeof(zero);
strcpy (p, ctx->alg->name);
p += strlen(p) + 1;
*p++ = (ctx->n >> 24) & 0xFF;
*p++ = (ctx->n >> 16) & 0xFF;
*p++ = (ctx->n >> 8) & 0xFF;
*p++ = (ctx->n >> 0) & 0xFF;
memcpy (p, ctx->key, OTPKEYSIZE);
p += OTPKEYSIZE;
strcpy (p, ctx->seed);
p += strlen(p) + 1;
dat.dptr = buf;
dat.dsize = p - buf;
return dbm_store (dbm, key, dat, DBM_REPLACE);
}
#if 0
int
otp_get (OtpContext *ctx)
{
FILE *f;
char buf[BUFSIZ];
char *p, *pend;
f = open_file (ctx->user, "r");
if (f == NULL)
return -1;
if (fgets (buf, sizeof(buf), f) == NULL) {
fclose (f);
return -1;
}
fclose (f);
p = buf;
pend = strchr (buf, ' ');
if (pend == NULL)
return -1;
*pend++ = '\0';
ctx->alg = otp_find_alg (p);
if (ctx->alg == NULL)
return -1;
p = pend;
if (sscanf (p, "%u", &ctx->n) != 1)
return -1;
pend = strchr (p, ' ');
if (pend == NULL)
return -1;
*pend++ = '\0';
p = pend;
pend = strchr (p, ' ');
if (pend == NULL)
return -1;
*pend++ = '\0';
strncpy (ctx->seed, p, sizeof(ctx->seed));
ctx->seed[sizeof(ctx->seed) - 1] = '\0';
if (ctx->seed == NULL)
return -1;
p = pend;
if(otp_parse (ctx->key, p))
return -1;
return 0;
}
#endif

37
lib/otp/otp_locl.h Normal file
View File

@@ -0,0 +1,37 @@
/* $Id$ */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_NDBM_H
#include <ndbm.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_IO_H
#include <io.h>
#endif
#include <otp.h>
#define OTPKEYS "/.otpkeys"
#define OTP_DB "/tmp/otp"
#define OTP_DB_LOCK "/tmp/otp-lock"

212
lib/otp/otp_md.c Normal file
View File

@@ -0,0 +1,212 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp_locl.h"
#include "otp_md.h"
#include <md4.h>
#include <md5.h>
#include <sha.h>
/*
* Compress len bytes from md into key
*/
static void
compressmd (OtpKey key, unsigned char *md, size_t len)
{
u_char *p = key;
memset (p, 0, OTPKEYSIZE);
while(len) {
*p++ ^= *md++;
*p++ ^= *md++;
*p++ ^= *md++;
*p++ ^= *md++;
len -= 4;
if (p == key + OTPKEYSIZE)
p = key;
}
}
static int
otp_md_init (OtpKey key,
char *pwd,
char *seed,
void (*init)(void *),
void (*update)(void *, u_char *, size_t),
void (*finito)(void *, char *),
void *arg,
char *res,
size_t ressz)
{
char *p;
int len;
int i;
len = strlen(pwd) + strlen(seed);
p = malloc (len + 1);
if (p == NULL)
return -1;
strcpy (p, seed);
strcat (p, pwd);
(*init)(arg);
(*update)(arg, p, len);
(*finito)(arg, res);
free (p);
compressmd (key, res, ressz);
return 0;
}
static int
otp_md_next (OtpKey key,
void (*init)(void *),
void (*update)(void *, u_char *, size_t),
void (*finito)(void *, char *),
void *arg,
char *res,
size_t ressz)
{
(*init)(arg);
(*update)(arg, key, OTPKEYSIZE);
(*finito)(arg, res);
compressmd (key, res, ressz);
return 0;
}
static int
otp_md_hash (char *data,
size_t len,
void (*init)(void *),
void (*update)(void *, u_char *, size_t),
void (*finito)(void *, char *),
void *arg,
char *res,
size_t ressz)
{
(*init)(arg);
(*update)(arg, data, len);
(*finito)(arg, res);
return 0;
}
int
otp_md4_init (OtpKey key, char *pwd, char *seed)
{
unsigned char res[16];
struct md4 md4;
return otp_md_init (key, pwd, seed,
(void (*)(void *))md4_init,
(void (*)(void *, u_char *, size_t))md4_update,
(void (*)(void *, char *))md4_finito,
&md4, res, sizeof(res));
}
int
otp_md4_hash (char *data,
size_t len,
char *res)
{
struct md4 md4;
return otp_md_hash (data, len,
(void (*)(void *))md4_init,
(void (*)(void *, u_char *, size_t))md4_update,
(void (*)(void *, char *))md4_finito,
&md4, res, 16);
}
int
otp_md4_next (OtpKey key)
{
unsigned char res[16];
struct md4 md4;
return otp_md_next (key,
(void (*)(void *))md4_init,
(void (*)(void *, u_char *, size_t))md4_update,
(void (*)(void *, char *))md4_finito,
&md4, res, sizeof(res));
}
int
otp_md5_init (OtpKey key, char *pwd, char *seed)
{
unsigned char res[16];
struct md5 md5;
return otp_md_init (key, pwd, seed,
(void (*)(void *))md5_init,
(void (*)(void *, u_char *, size_t))md5_update,
(void (*)(void *, char *))md5_finito,
&md5, res, sizeof(res));
}
int
otp_md5_hash (char *data,
size_t len,
char *res)
{
struct md5 md5;
return otp_md_hash (data, len,
(void (*)(void *))md5_init,
(void (*)(void *, u_char *, size_t))md5_update,
(void (*)(void *, char *))md5_finito,
&md5, res, 16);
}
int
otp_md5_next (OtpKey key)
{
unsigned char res[16];
struct md5 md5;
return otp_md_next (key,
(void (*)(void *))md5_init,
(void (*)(void *, u_char *, size_t))md5_update,
(void (*)(void *, char *))md5_finito,
&md5, res, sizeof(res));
}
int
otp_sha_init (OtpKey key, char *pwd, char *seed)
{
unsigned char res[20];
struct sha sha;
return otp_md_init (key, pwd, seed,
(void (*)(void *))sha_init,
(void (*)(void *, u_char *, size_t))sha_update,
(void (*)(void *, char *))sha_finito,
&sha, res, sizeof(res));
}
int
otp_sha_hash (char *data,
size_t len,
char *res)
{
struct sha sha;
return otp_md_hash (data, len,
(void (*)(void *))sha_init,
(void (*)(void *, u_char *, size_t))sha_update,
(void (*)(void *, char *))sha_finito,
&sha, res, 20);
}
int
otp_sha_next (OtpKey key)
{
unsigned char res[20];
struct sha sha;
return otp_md_next (key,
(void (*)(void *))sha_init,
(void (*)(void *, u_char *, size_t))sha_update,
(void (*)(void *, char *))sha_finito,
&sha, res, sizeof(res));
}

13
lib/otp/otp_md.h Normal file
View File

@@ -0,0 +1,13 @@
/* $Id$ */
int otp_md4_init (OtpKey key, char *pwd, char *seed);
int otp_md4_hash (char *, size_t, char *res);
int otp_md4_next (OtpKey key);
int otp_md5_init (OtpKey key, char *pwd, char *seed);
int otp_md5_hash (char *, size_t, char *res);
int otp_md5_next (OtpKey key);
int otp_sha_init (OtpKey key, char *pwd, char *seed);
int otp_sha_hash (char *, size_t, char *res);
int otp_sha_next (OtpKey key);

2210
lib/otp/otp_parse.c Normal file
View File

File diff suppressed because it is too large Load Diff

316
lib/otp/otp_print.c Normal file
View File

@@ -0,0 +1,316 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp.h"
static char *std_dict[] =
{ "A", "ABE", "ACE", "ACT", "AD", "ADA", "ADD",
"AGO", "AID", "AIM", "AIR", "ALL", "ALP", "AM", "AMY",
"AN", "ANA", "AND", "ANN", "ANT", "ANY", "APE", "APS",
"APT", "ARC", "ARE", "ARK", "ARM", "ART", "AS", "ASH",
"ASK", "AT", "ATE", "AUG", "AUK", "AVE", "AWE", "AWK",
"AWL", "AWN", "AX", "AYE", "BAD", "BAG", "BAH", "BAM",
"BAN", "BAR", "BAT", "BAY", "BE", "BED", "BEE", "BEG",
"BEN", "BET", "BEY", "BIB", "BID", "BIG", "BIN", "BIT",
"BOB", "BOG", "BON", "BOO", "BOP", "BOW", "BOY", "BUB",
"BUD", "BUG", "BUM", "BUN", "BUS", "BUT", "BUY", "BY",
"BYE", "CAB", "CAL", "CAM", "CAN", "CAP", "CAR", "CAT",
"CAW", "COD", "COG", "COL", "CON", "COO", "COP", "COT",
"COW", "COY", "CRY", "CUB", "CUE", "CUP", "CUR", "CUT",
"DAB", "DAD", "DAM", "DAN", "DAR", "DAY", "DEE", "DEL",
"DEN", "DES", "DEW", "DID", "DIE", "DIG", "DIN", "DIP",
"DO", "DOE", "DOG", "DON", "DOT", "DOW", "DRY", "DUB",
"DUD", "DUE", "DUG", "DUN", "EAR", "EAT", "ED", "EEL",
"EGG", "EGO", "ELI", "ELK", "ELM", "ELY", "EM", "END",
"EST", "ETC", "EVA", "EVE", "EWE", "EYE", "FAD", "FAN",
"FAR", "FAT", "FAY", "FED", "FEE", "FEW", "FIB", "FIG",
"FIN", "FIR", "FIT", "FLO", "FLY", "FOE", "FOG", "FOR",
"FRY", "FUM", "FUN", "FUR", "GAB", "GAD", "GAG", "GAL",
"GAM", "GAP", "GAS", "GAY", "GEE", "GEL", "GEM", "GET",
"GIG", "GIL", "GIN", "GO", "GOT", "GUM", "GUN", "GUS",
"GUT", "GUY", "GYM", "GYP", "HA", "HAD", "HAL", "HAM",
"HAN", "HAP", "HAS", "HAT", "HAW", "HAY", "HE", "HEM",
"HEN", "HER", "HEW", "HEY", "HI", "HID", "HIM", "HIP",
"HIS", "HIT", "HO", "HOB", "HOC", "HOE", "HOG", "HOP",
"HOT", "HOW", "HUB", "HUE", "HUG", "HUH", "HUM", "HUT",
"I", "ICY", "IDA", "IF", "IKE", "ILL", "INK", "INN",
"IO", "ION", "IQ", "IRA", "IRE", "IRK", "IS", "IT",
"ITS", "IVY", "JAB", "JAG", "JAM", "JAN", "JAR", "JAW",
"JAY", "JET", "JIG", "JIM", "JO", "JOB", "JOE", "JOG",
"JOT", "JOY", "JUG", "JUT", "KAY", "KEG", "KEN", "KEY",
"KID", "KIM", "KIN", "KIT", "LA", "LAB", "LAC", "LAD",
"LAG", "LAM", "LAP", "LAW", "LAY", "LEA", "LED", "LEE",
"LEG", "LEN", "LEO", "LET", "LEW", "LID", "LIE", "LIN",
"LIP", "LIT", "LO", "LOB", "LOG", "LOP", "LOS", "LOT",
"LOU", "LOW", "LOY", "LUG", "LYE", "MA", "MAC", "MAD",
"MAE", "MAN", "MAO", "MAP", "MAT", "MAW", "MAY", "ME",
"MEG", "MEL", "MEN", "MET", "MEW", "MID", "MIN", "MIT",
"MOB", "MOD", "MOE", "MOO", "MOP", "MOS", "MOT", "MOW",
"MUD", "MUG", "MUM", "MY", "NAB", "NAG", "NAN", "NAP",
"NAT", "NAY", "NE", "NED", "NEE", "NET", "NEW", "NIB",
"NIIL", "NIP", "NIT", "NO", "NOB", "NOD", "NON", "NOR",
"NOT", "NOV", "NOW", "NU", "NUN", "NUT", "O", "OAF",
"OAK", "OAR", "OAT", "ODD", "ODE", "OF", "OFF", "OFT",
"OH", "OIL", "OK", "OLD", "ON", "ONE", "OR", "ORB",
"ORE", "ORR", "OS", "OTT", "OUR", "OUT", "OVA", "OW",
"OWE", "OWL", "OWN", "OX", "PA", "PAD", "PAL", "PAM",
"PAN", "PAP", "PAR", "PAT", "PAW", "PAY", "PEA", "PEG",
"PEN", "PEP", "PER", "PET", "PEW", "PHI", "PI", "PIE",
"PIN", "PIT", "PLY", "PO", "POD", "POE", "POP", "POT",
"POW", "PRO", "PRY", "PUB", "PUG", "PUN", "PUP", "PUT",
"QUO", "RAG", "RAM", "RAN", "RAP", "RAT", "RAW", "RAY",
"REB", "RED", "REP", "RET", "RIB", "RID", "RIG", "RIM",
"RIO", "RIP", "ROB", "ROD", "ROE", "RON", "ROT", "ROW",
"ROY", "RUB", "RUE", "RUG", "RUM", "RUN", "RYE", "SAC",
"SAD", "SAG", "SAL", "SAM", "SAN", "SAP", "SAT", "SAW",
"SAY", "SEA", "SEC", "SEE", "SEN", "SET", "SEW", "SHE",
"SHY", "SIN", "SIP", "SIR", "SIS", "SIT", "SKI", "SKY",
"SLY", "SO", "SOB", "SOD", "SON", "SOP", "SOW", "SOY",
"SPA", "SPY", "SUB", "SUD", "SUE", "SUM", "SUN", "SUP",
"TAB", "TAD", "TAG", "TAN", "TAP", "TAR", "TEA", "TED",
"TEE", "TEN", "THE", "THY", "TIC", "TIE", "TIM", "TIN",
"TIP", "TO", "TOE", "TOG", "TOM", "TON", "TOO", "TOP",
"TOW", "TOY", "TRY", "TUB", "TUG", "TUM", "TUN", "TWO",
"UN", "UP", "US", "USE", "VAN", "VAT", "VET", "VIE",
"WAD", "WAG", "WAR", "WAS", "WAY", "WE", "WEB", "WED",
"WEE", "WET", "WHO", "WHY", "WIN", "WIT", "WOK", "WON",
"WOO", "WOW", "WRY", "WU", "YAM", "YAP", "YAW", "YE",
"YEA", "YES", "YET", "YOU", "ABED", "ABEL", "ABET", "ABLE",
"ABUT", "ACHE", "ACID", "ACME", "ACRE", "ACTA", "ACTS", "ADAM",
"ADDS", "ADEN", "AFAR", "AFRO", "AGEE", "AHEM", "AHOY", "AIDA",
"AIDE", "AIDS", "AIRY", "AJAR", "AKIN", "ALAN", "ALEC", "ALGA",
"ALIA", "ALLY", "ALMA", "ALOE", "ALSO", "ALTO", "ALUM", "ALVA",
"AMEN", "AMES", "AMID", "AMMO", "AMOK", "AMOS", "AMRA", "ANDY",
"ANEW", "ANNA", "ANNE", "ANTE", "ANTI", "AQUA", "ARAB", "ARCH",
"AREA", "ARGO", "ARID", "ARMY", "ARTS", "ARTY", "ASIA", "ASKS",
"ATOM", "AUNT", "AURA", "AUTO", "AVER", "AVID", "AVIS", "AVON",
"AVOW", "AWAY", "AWRY", "BABE", "BABY", "BACH", "BACK", "BADE",
"BAIL", "BAIT", "BAKE", "BALD", "BALE", "BALI", "BALK", "BALL",
"BALM", "BAND", "BANE", "BANG", "BANK", "BARB", "BARD", "BARE",
"BARK", "BARN", "BARR", "BASE", "BASH", "BASK", "BASS", "BATE",
"BATH", "BAWD", "BAWL", "BEAD", "BEAK", "BEAM", "BEAN", "BEAR",
"BEAT", "BEAU", "BECK", "BEEF", "BEEN", "BEER", "BEET", "BELA",
"BELL", "BELT", "BEND", "BENT", "BERG", "BERN", "BERT", "BESS",
"BEST", "BETA", "BETH", "BHOY", "BIAS", "BIDE", "BIEN", "BILE",
"BILK", "BILL", "BIND", "BING", "BIRD", "BITE", "BITS", "BLAB",
"BLAT", "BLED", "BLEW", "BLOB", "BLOC", "BLOT", "BLOW", "BLUE",
"BLUM", "BLUR", "BOAR", "BOAT", "BOCA", "BOCK", "BODE", "BODY",
"BOGY", "BOHR", "BOIL", "BOLD", "BOLO", "BOLT", "BOMB", "BONA",
"BOND", "BONE", "BONG", "BONN", "BONY", "BOOK", "BOOM", "BOON",
"BOOT", "BORE", "BORG", "BORN", "BOSE", "BOSS", "BOTH", "BOUT",
"BOWL", "BOYD", "BRAD", "BRAE", "BRAG", "BRAN", "BRAY", "BRED",
"BREW", "BRIG", "BRIM", "BROW", "BUCK", "BUDD", "BUFF", "BULB",
"BULK", "BULL", "BUNK", "BUNT", "BUOY", "BURG", "BURL", "BURN",
"BURR", "BURT", "BURY", "BUSH", "BUSS", "BUST", "BUSY", "BYTE",
"CADY", "CAFE", "CAGE", "CAIN", "CAKE", "CALF", "CALL", "CALM",
"CAME", "CANE", "CANT", "CARD", "CARE", "CARL", "CARR", "CART",
"CASE", "CASH", "CASK", "CAST", "CAVE", "CEIL", "CELL", "CENT",
"CERN", "CHAD", "CHAR", "CHAT", "CHAW", "CHEF", "CHEN", "CHEW",
"CHIC", "CHIN", "CHOU", "CHOW", "CHUB", "CHUG", "CHUM", "CITE",
"CITY", "CLAD", "CLAM", "CLAN", "CLAW", "CLAY", "CLOD", "CLOG",
"CLOT", "CLUB", "CLUE", "COAL", "COAT", "COCA", "COCK", "COCO",
"CODA", "CODE", "CODY", "COED", "COIL", "COIN", "COKE", "COLA",
"COLD", "COLT", "COMA", "COMB", "COME", "COOK", "COOL", "COON",
"COOT", "CORD", "CORE", "CORK", "CORN", "COST", "COVE", "COWL",
"CRAB", "CRAG", "CRAM", "CRAY", "CREW", "CRIB", "CROW", "CRUD",
"CUBA", "CUBE", "CUFF", "CULL", "CULT", "CUNY", "CURB", "CURD",
"CURE", "CURL", "CURT", "CUTS", "DADE", "DALE", "DAME", "DANA",
"DANE", "DANG", "DANK", "DARE", "DARK", "DARN", "DART", "DASH",
"DATA", "DATE", "DAVE", "DAVY", "DAWN", "DAYS", "DEAD", "DEAF",
"DEAL", "DEAN", "DEAR", "DEBT", "DECK", "DEED", "DEEM", "DEER",
"DEFT", "DEFY", "DELL", "DENT", "DENY", "DESK", "DIAL", "DICE",
"DIED", "DIET", "DIME", "DINE", "DING", "DINT", "DIRE", "DIRT",
"DISC", "DISH", "DISK", "DIVE", "DOCK", "DOES", "DOLE", "DOLL",
"DOLT", "DOME", "DONE", "DOOM", "DOOR", "DORA", "DOSE", "DOTE",
"DOUG", "DOUR", "DOVE", "DOWN", "DRAB", "DRAG", "DRAM", "DRAW",
"DREW", "DRUB", "DRUG", "DRUM", "DUAL", "DUCK", "DUCT", "DUEL",
"DUET", "DUKE", "DULL", "DUMB", "DUNE", "DUNK", "DUSK", "DUST",
"DUTY", "EACH", "EARL", "EARN", "EASE", "EAST", "EASY", "EBEN",
"ECHO", "EDDY", "EDEN", "EDGE", "EDGY", "EDIT", "EDNA", "EGAN",
"ELAN", "ELBA", "ELLA", "ELSE", "EMIL", "EMIT", "EMMA", "ENDS",
"ERIC", "EROS", "EVEN", "EVER", "EVIL", "EYED", "FACE", "FACT",
"FADE", "FAIL", "FAIN", "FAIR", "FAKE", "FALL", "FAME", "FANG",
"FARM", "FAST", "FATE", "FAWN", "FEAR", "FEAT", "FEED", "FEEL",
"FEET", "FELL", "FELT", "FEND", "FERN", "FEST", "FEUD", "FIEF",
"FIGS", "FILE", "FILL", "FILM", "FIND", "FINE", "FINK", "FIRE",
"FIRM", "FISH", "FISK", "FIST", "FITS", "FIVE", "FLAG", "FLAK",
"FLAM", "FLAT", "FLAW", "FLEA", "FLED", "FLEW", "FLIT", "FLOC",
"FLOG", "FLOW", "FLUB", "FLUE", "FOAL", "FOAM", "FOGY", "FOIL",
"FOLD", "FOLK", "FOND", "FONT", "FOOD", "FOOL", "FOOT", "FORD",
"FORE", "FORK", "FORM", "FORT", "FOSS", "FOUL", "FOUR", "FOWL",
"FRAU", "FRAY", "FRED", "FREE", "FRET", "FREY", "FROG", "FROM",
"FUEL", "FULL", "FUME", "FUND", "FUNK", "FURY", "FUSE", "FUSS",
"GAFF", "GAGE", "GAIL", "GAIN", "GAIT", "GALA", "GALE", "GALL",
"GALT", "GAME", "GANG", "GARB", "GARY", "GASH", "GATE", "GAUL",
"GAUR", "GAVE", "GAWK", "GEAR", "GELD", "GENE", "GENT", "GERM",
"GETS", "GIBE", "GIFT", "GILD", "GILL", "GILT", "GINA", "GIRD",
"GIRL", "GIST", "GIVE", "GLAD", "GLEE", "GLEN", "GLIB", "GLOB",
"GLOM", "GLOW", "GLUE", "GLUM", "GLUT", "GOAD", "GOAL", "GOAT",
"GOER", "GOES", "GOLD", "GOLF", "GONE", "GONG", "GOOD", "GOOF",
"GORE", "GORY", "GOSH", "GOUT", "GOWN", "GRAB", "GRAD", "GRAY",
"GREG", "GREW", "GREY", "GRID", "GRIM", "GRIN", "GRIT", "GROW",
"GRUB", "GULF", "GULL", "GUNK", "GURU", "GUSH", "GUST", "GWEN",
"GWYN", "HAAG", "HAAS", "HACK", "HAIL", "HAIR", "HALE", "HALF",
"HALL", "HALO", "HALT", "HAND", "HANG", "HANK", "HANS", "HARD",
"HARK", "HARM", "HART", "HASH", "HAST", "HATE", "HATH", "HAUL",
"HAVE", "HAWK", "HAYS", "HEAD", "HEAL", "HEAR", "HEAT", "HEBE",
"HECK", "HEED", "HEEL", "HEFT", "HELD", "HELL", "HELM", "HERB",
"HERD", "HERE", "HERO", "HERS", "HESS", "HEWN", "HICK", "HIDE",
"HIGH", "HIKE", "HILL", "HILT", "HIND", "HINT", "HIRE", "HISS",
"HIVE", "HOBO", "HOCK", "HOFF", "HOLD", "HOLE", "HOLM", "HOLT",
"HOME", "HONE", "HONK", "HOOD", "HOOF", "HOOK", "HOOT", "HORN",
"HOSE", "HOST", "HOUR", "HOVE", "HOWE", "HOWL", "HOYT", "HUCK",
"HUED", "HUFF", "HUGE", "HUGH", "HUGO", "HULK", "HULL", "HUNK",
"HUNT", "HURD", "HURL", "HURT", "HUSH", "HYDE", "HYMN", "IBIS",
"ICON", "IDEA", "IDLE", "IFFY", "INCA", "INCH", "INTO", "IONS",
"IOTA", "IOWA", "IRIS", "IRMA", "IRON", "ISLE", "ITCH", "ITEM",
"IVAN", "JACK", "JADE", "JAIL", "JAKE", "JANE", "JAVA", "JEAN",
"JEFF", "JERK", "JESS", "JEST", "JIBE", "JILL", "JILT", "JIVE",
"JOAN", "JOBS", "JOCK", "JOEL", "JOEY", "JOHN", "JOIN", "JOKE",
"JOLT", "JOVE", "JUDD", "JUDE", "JUDO", "JUDY", "JUJU", "JUKE",
"JULY", "JUNE", "JUNK", "JUNO", "JURY", "JUST", "JUTE", "KAHN",
"KALE", "KANE", "KANT", "KARL", "KATE", "KEEL", "KEEN", "KENO",
"KENT", "KERN", "KERR", "KEYS", "KICK", "KILL", "KIND", "KING",
"KIRK", "KISS", "KITE", "KLAN", "KNEE", "KNEW", "KNIT", "KNOB",
"KNOT", "KNOW", "KOCH", "KONG", "KUDO", "KURD", "KURT", "KYLE",
"LACE", "LACK", "LACY", "LADY", "LAID", "LAIN", "LAIR", "LAKE",
"LAMB", "LAME", "LAND", "LANE", "LANG", "LARD", "LARK", "LASS",
"LAST", "LATE", "LAUD", "LAVA", "LAWN", "LAWS", "LAYS", "LEAD",
"LEAF", "LEAK", "LEAN", "LEAR", "LEEK", "LEER", "LEFT", "LEND",
"LENS", "LENT", "LEON", "LESK", "LESS", "LEST", "LETS", "LIAR",
"LICE", "LICK", "LIED", "LIEN", "LIES", "LIEU", "LIFE", "LIFT",
"LIKE", "LILA", "LILT", "LILY", "LIMA", "LIMB", "LIME", "LIND",
"LINE", "LINK", "LINT", "LION", "LISA", "LIST", "LIVE", "LOAD",
"LOAF", "LOAM", "LOAN", "LOCK", "LOFT", "LOGE", "LOIS", "LOLA",
"LONE", "LONG", "LOOK", "LOON", "LOOT", "LORD", "LORE", "LOSE",
"LOSS", "LOST", "LOUD", "LOVE", "LOWE", "LUCK", "LUCY", "LUGE",
"LUKE", "LULU", "LUND", "LUNG", "LURA", "LURE", "LURK", "LUSH",
"LUST", "LYLE", "LYNN", "LYON", "LYRA", "MACE", "MADE", "MAGI",
"MAID", "MAIL", "MAIN", "MAKE", "MALE", "MALI", "MALL", "MALT",
"MANA", "MANN", "MANY", "MARC", "MARE", "MARK", "MARS", "MART",
"MARY", "MASH", "MASK", "MASS", "MAST", "MATE", "MATH", "MAUL",
"MAYO", "MEAD", "MEAL", "MEAN", "MEAT", "MEEK", "MEET", "MELD",
"MELT", "MEMO", "MEND", "MENU", "MERT", "MESH", "MESS", "MICE",
"MIKE", "MILD", "MILE", "MILK", "MILL", "MILT", "MIMI", "MIND",
"MINE", "MINI", "MINK", "MINT", "MIRE", "MISS", "MIST", "MITE",
"MITT", "MOAN", "MOAT", "MOCK", "MODE", "MOLD", "MOLE", "MOLL",
"MOLT", "MONA", "MONK", "MONT", "MOOD", "MOON", "MOOR", "MOOT",
"MORE", "MORN", "MORT", "MOSS", "MOST", "MOTH", "MOVE", "MUCH",
"MUCK", "MUDD", "MUFF", "MULE", "MULL", "MURK", "MUSH", "MUST",
"MUTE", "MUTT", "MYRA", "MYTH", "NAGY", "NAIL", "NAIR", "NAME",
"NARY", "NASH", "NAVE", "NAVY", "NEAL", "NEAR", "NEAT", "NECK",
"NEED", "NEIL", "NELL", "NEON", "NERO", "NESS", "NEST", "NEWS",
"NEWT", "NIBS", "NICE", "NICK", "NILE", "NINA", "NINE", "NOAH",
"NODE", "NOEL", "NOLL", "NONE", "NOOK", "NOON", "NORM", "NOSE",
"NOTE", "NOUN", "NOVA", "NUDE", "NULL", "NUMB", "OATH", "OBEY",
"OBOE", "ODIN", "OHIO", "OILY", "OINT", "OKAY", "OLAF", "OLDY",
"OLGA", "OLIN", "OMAN", "OMEN", "OMIT", "ONCE", "ONES", "ONLY",
"ONTO", "ONUS", "ORAL", "ORGY", "OSLO", "OTIS", "OTTO", "OUCH",
"OUST", "OUTS", "OVAL", "OVEN", "OVER", "OWLY", "OWNS", "QUAD",
"QUIT", "QUOD", "RACE", "RACK", "RACY", "RAFT", "RAGE", "RAID",
"RAIL", "RAIN", "RAKE", "RANK", "RANT", "RARE", "RASH", "RATE",
"RAVE", "RAYS", "READ", "REAL", "REAM", "REAR", "RECK", "REED",
"REEF", "REEK", "REEL", "REID", "REIN", "RENA", "REND", "RENT",
"REST", "RICE", "RICH", "RICK", "RIDE", "RIFT", "RILL", "RIME",
"RING", "RINK", "RISE", "RISK", "RITE", "ROAD", "ROAM", "ROAR",
"ROBE", "ROCK", "RODE", "ROIL", "ROLL", "ROME", "ROOD", "ROOF",
"ROOK", "ROOM", "ROOT", "ROSA", "ROSE", "ROSS", "ROSY", "ROTH",
"ROUT", "ROVE", "ROWE", "ROWS", "RUBE", "RUBY", "RUDE", "RUDY",
"RUIN", "RULE", "RUNG", "RUNS", "RUNT", "RUSE", "RUSH", "RUSK",
"RUSS", "RUST", "RUTH", "SACK", "SAFE", "SAGE", "SAID", "SAIL",
"SALE", "SALK", "SALT", "SAME", "SAND", "SANE", "SANG", "SANK",
"SARA", "SAUL", "SAVE", "SAYS", "SCAN", "SCAR", "SCAT", "SCOT",
"SEAL", "SEAM", "SEAR", "SEAT", "SEED", "SEEK", "SEEM", "SEEN",
"SEES", "SELF", "SELL", "SEND", "SENT", "SETS", "SEWN", "SHAG",
"SHAM", "SHAW", "SHAY", "SHED", "SHIM", "SHIN", "SHOD", "SHOE",
"SHOT", "SHOW", "SHUN", "SHUT", "SICK", "SIDE", "SIFT", "SIGH",
"SIGN", "SILK", "SILL", "SILO", "SILT", "SINE", "SING", "SINK",
"SIRE", "SITE", "SITS", "SITU", "SKAT", "SKEW", "SKID", "SKIM",
"SKIN", "SKIT", "SLAB", "SLAM", "SLAT", "SLAY", "SLED", "SLEW",
"SLID", "SLIM", "SLIT", "SLOB", "SLOG", "SLOT", "SLOW", "SLUG",
"SLUM", "SLUR", "SMOG", "SMUG", "SNAG", "SNOB", "SNOW", "SNUB",
"SNUG", "SOAK", "SOAR", "SOCK", "SODA", "SOFA", "SOFT", "SOIL",
"SOLD", "SOME", "SONG", "SOON", "SOOT", "SORE", "SORT", "SOUL",
"SOUR", "SOWN", "STAB", "STAG", "STAN", "STAR", "STAY", "STEM",
"STEW", "STIR", "STOW", "STUB", "STUN", "SUCH", "SUDS", "SUIT",
"SULK", "SUMS", "SUNG", "SUNK", "SURE", "SURF", "SWAB", "SWAG",
"SWAM", "SWAN", "SWAT", "SWAY", "SWIM", "SWUM", "TACK", "TACT",
"TAIL", "TAKE", "TALE", "TALK", "TALL", "TANK", "TASK", "TATE",
"TAUT", "TEAL", "TEAM", "TEAR", "TECH", "TEEM", "TEEN", "TEET",
"TELL", "TEND", "TENT", "TERM", "TERN", "TESS", "TEST", "THAN",
"THAT", "THEE", "THEM", "THEN", "THEY", "THIN", "THIS", "THUD",
"THUG", "TICK", "TIDE", "TIDY", "TIED", "TIER", "TILE", "TILL",
"TILT", "TIME", "TINA", "TINE", "TINT", "TINY", "TIRE", "TOAD",
"TOGO", "TOIL", "TOLD", "TOLL", "TONE", "TONG", "TONY", "TOOK",
"TOOL", "TOOT", "TORE", "TORN", "TOTE", "TOUR", "TOUT", "TOWN",
"TRAG", "TRAM", "TRAY", "TREE", "TREK", "TRIG", "TRIM", "TRIO",
"TROD", "TROT", "TROY", "TRUE", "TUBA", "TUBE", "TUCK", "TUFT",
"TUNA", "TUNE", "TUNG", "TURF", "TURN", "TUSK", "TWIG", "TWIN",
"TWIT", "ULAN", "UNIT", "URGE", "USED", "USER", "USES", "UTAH",
"VAIL", "VAIN", "VALE", "VARY", "VASE", "VAST", "VEAL", "VEDA",
"VEIL", "VEIN", "VEND", "VENT", "VERB", "VERY", "VETO", "VICE",
"VIEW", "VINE", "VISE", "VOID", "VOLT", "VOTE", "WACK", "WADE",
"WAGE", "WAIL", "WAIT", "WAKE", "WALE", "WALK", "WALL", "WALT",
"WAND", "WANE", "WANG", "WANT", "WARD", "WARM", "WARN", "WART",
"WASH", "WAST", "WATS", "WATT", "WAVE", "WAVY", "WAYS", "WEAK",
"WEAL", "WEAN", "WEAR", "WEED", "WEEK", "WEIR", "WELD", "WELL",
"WELT", "WENT", "WERE", "WERT", "WEST", "WHAM", "WHAT", "WHEE",
"WHEN", "WHET", "WHOA", "WHOM", "WICK", "WIFE", "WILD", "WILL",
"WIND", "WINE", "WING", "WINK", "WINO", "WIRE", "WISE", "WISH",
"WITH", "WOLF", "WONT", "WOOD", "WOOL", "WORD", "WORE", "WORK",
"WORM", "WORN", "WOVE", "WRIT", "WYNN", "YALE", "YANG", "YANK",
"YARD", "YARN", "YAWL", "YAWN", "YEAH", "YEAR", "YELL", "YOGA",
"YOKE" };
static char *
add_word (char *s, unsigned n)
{
char *w;
w = std_dict[n];
strcpy (s, w);
s += strlen(w);
*s++ = ' ';
return s;
}
unsigned
otp_checksum (OtpKey key)
{
int i;
unsigned sum = 0;
for (i = 0; i < OTPKEYSIZE; ++i)
sum += ((key[i] >> 0) & 0x03)
+ ((key[i] >> 2) & 0x03)
+ ((key[i] >> 4) & 0x03)
+ ((key[i] >> 6) & 0x03);
sum &= 0x03;
return sum;
}
void
otp_print_stddict (OtpKey key, char *str)
{
unsigned sum;
sum = otp_checksum (key);
str = add_word (str, (key[0] << 3) | (key[1] >> 5));
str = add_word (str, ((key[1] & 0x1F) << 6) | (key[2] >> 2));
str = add_word (str, ((key[2] & 0x03) << 9) | (key[3] << 1) | (key[4] >> 7));
str = add_word (str, ((key[4] & 0x7F) << 4) | (key[5] >> 4));
str = add_word (str, ((key[5] & 0x0F) << 7) | (key[6] >> 1));
str = add_word (str, ((key[6] & 0x01) << 10) | (key[7] << 2) | sum);
*str = '\0';
}
void
otp_print_hex (OtpKey key, char *str)
{
sprintf (str, "%02x%02x%02x%02x%02x%02x%02x%02x",
key[0], key[1], key[2], key[3],
key[4], key[5], key[6], key[7]);
}

41
lib/otp/otp_verify.c Normal file
View File

@@ -0,0 +1,41 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
RCSID("$Id$");
#endif
#include "otp_locl.h"
int
otp_verify_user_1 (OtpContext *ctx, char *passwd)
{
OtpKey key1, key2;
if (otp_parse (key1, passwd, ctx->alg))
return -1;
memcpy (key2, key1, sizeof(key1));
ctx->alg->next (key2);
if (memcmp (ctx->key, key2, sizeof(key2)) == 0) {
--ctx->n;
memcpy (ctx->key, key1, sizeof(key1));
return 0;
} else
return -1;
}
int
otp_verify_user (OtpContext *ctx, char *passwd)
{
void *dbm;
int ret;
otp_verify_user_1 (ctx, passwd);
dbm = otp_db_open ();
if (dbm == NULL) {
free(ctx->user);
return -1;
}
ret = otp_put (dbm, ctx);
free(ctx->user);
otp_db_close (dbm);
return ret;
}