4d7def117f71589712fa1f9b13b1997609e4a0b0Christian Maeder

#include "apr.h"

#include "apr_lib.h"

#include "apr_strings.h"

#include "apr_errno.h"

#include "apr_file_io.h"

#include "apr_general.h"

#include "apr_signal.h"

#if APR_HAVE_STDIO_H

#include <stdio.h>

#endif

#include "apr_md5.h"

#include "apr_sha1.h"

#include <time.h>

#if APR_HAVE_CRYPT_H

#include <crypt.h>

#endif

#if APR_HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if APR_HAVE_STRING_H

#include <string.h>

#endif

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef WIN32

#include <conio.h>

#define unlink _unlink

#endif

#if !APR_CHARSET_EBCDIC

#define LF 10

#define CR 13

#else /*APR_CHARSET_EBCDIC*/

#define LF '\n'

#define CR '\r'

#endif /*APR_CHARSET_EBCDIC*/

#define MAX_STRING_LEN 256

#define ALG_PLAIN 0

#define ALG_CRYPT 1

#define ALG_APMD5 2

#define ALG_APSHA 3

#define ERR_FILEPERM 1

#define ERR_SYNTAX 2

#define ERR_PWMISMATCH 3

#define ERR_INTERRUPTED 4

#define ERR_OVERFLOW 5

#define ERR_BADUSER 6

static char *tempfilename;

#ifdef L_tmpnam

static char tname_buf[L_tmpnam];

#else

static char *tname_buf = NULL;

#endif

static int getline(char *s, int n, FILE *f)

{

register int i = 0;

while (1) {

s[i] = (char) fgetc(f);

if (s[i] == CR) {

s[i] = fgetc(f);

}

if ((s[i] == 0x4) || (s[i] == LF) || (i == (n - 1))) {

s[i] = '\0';

return (feof(f) ? 1 : 0);

}

++i;

}

}

static void putline(FILE *f, char *l)

{

int x;

for (x = 0; l[x]; x++) {

fputc(l[x], f);

}

fputc('\n', f);

}

static void to64(char *s, unsigned long v, int n)

{

static unsigned char itoa64[] = /* 0 ... 63 => ASCII - 64 */

"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

while (--n >= 0) {

*s++ = itoa64[v&0x3f];

v >>= 6;

}

}

static int mkrecord(char *user, char *record, size_t rlen, char *passwd,

int alg)

{

char *pw;

char cpw[120];

char pwin[MAX_STRING_LEN];

char pwv[MAX_STRING_LEN];

char salt[9];

size_t bufsize;

if (passwd != NULL) {

pw = passwd;

}

else {

bufsize = sizeof(pwin);

if (apr_password_get("New password: ", pwin, &bufsize) != 0) {

apr_snprintf(record, (rlen - 1), "password too long (>%" APR_SIZE_T_FMT

")", sizeof(pwin) - 1);

return ERR_OVERFLOW;

}

bufsize = sizeof(pwv);

apr_password_get("Re-type new password: ", pwv, &bufsize);

if (strcmp(pwin, pwv) != 0) {

apr_cpystrn(record, "password verification error", (rlen - 1));

return ERR_PWMISMATCH;

}

pw = pwin;

memset(pwv, '\0', sizeof(pwin));

}

switch (alg) {

case ALG_APSHA:

/* XXX cpw >= 28 + strlen(sha1) chars - fixed len SHA */

apr_sha1_base64(pw,strlen(pw),cpw);

break;

case ALG_APMD5:

(void) srand((int) time((time_t *) NULL));

to64(&salt[0], rand(), 8);

salt[8] = '\0';

apr_md5_encode((const char *)pw, (const char *)salt,

cpw, sizeof(cpw));

break;

case ALG_PLAIN:

/* XXX this len limitation is not in sync with any HTTPd len. */

apr_cpystrn(cpw,pw,sizeof(cpw));

break;

#if !(defined(WIN32) || defined(NETWARE))

case ALG_CRYPT:

default:

(void) srand((int) time((time_t *) NULL));

to64(&salt[0], rand(), 8);

salt[8] = '\0';

apr_cpystrn(cpw, (char *)crypt(pw, salt), sizeof(cpw) - 1);

break;

#endif

}

memset(pw, '\0', strlen(pw));

/*

if ((strlen(user) + 1 + strlen(cpw)) > (rlen - 1)) {

apr_cpystrn(record, "resultant record too long", (rlen - 1));

return ERR_OVERFLOW;

}

strcpy(record, user);

strcat(record, ":");

strcat(record, cpw);

return 0;

}

static int usage(void)

{

fprintf(stderr, "Usage:\n");

fprintf(stderr, "\thtpasswd [-cmdps] passwordfile username\n");

fprintf(stderr, "\thtpasswd -b[cmdps] passwordfile username password\n\n");

fprintf(stderr, "\thtpasswd -n[mdps] username\n");

fprintf(stderr, "\thtpasswd -nb[mdps] username password\n");

fprintf(stderr, " -c Create a new file.\n");

fprintf(stderr, " -n Don't update file; display results on stdout.\n");

fprintf(stderr, " -m Force MD5 encryption of the password"

#if defined(WIN32) || defined(TPF) || defined(NETWARE)

" (default)"

#endif

".\n");

fprintf(stderr, " -d Force CRYPT encryption of the password"

#if (!(defined(WIN32) || defined(TPF) || defined(NETWARE)))

" (default)"

#endif

".\n");

fprintf(stderr, " -p Do not encrypt the password (plaintext).\n");

fprintf(stderr, " -s Force SHA encryption of the password.\n");

fprintf(stderr, " -b Use the password from the command line rather "

"than prompting for it.\n");

fprintf(stderr,

"On Windows, NetWare and TPF systems the '-m' flag is used by default.\n");

fprintf(stderr,

"On all other systems, the '-p' flag will probably not work.\n");

return ERR_SYNTAX;

}

static void interrupted(void)

{

fprintf(stderr, "Interrupted.\n");

if (tempfilename != NULL) {

unlink(tempfilename);

}

exit(ERR_INTERRUPTED);

}

static int accessible(char *fname, char *mode)

{

FILE *s;

s = fopen(fname, mode);

if (s == NULL) {

return 0;

}

fclose(s);

return 1;

}

static int readable(char *fname)

{

return accessible(fname, "r");

}

static int writable(char *fname)

{

return accessible(fname, "a");

}

static int exists(char *fname, apr_pool_t *pool)

{

apr_finfo_t sbuf;

apr_status_t check;

check = apr_stat(&sbuf, fname, APR_FINFO_TYPE, pool);

return ((check || sbuf.filetype != APR_REG) ? 0 : 1);

}

static void copy_file(FILE *target, FILE *source)

{

static char line[MAX_STRING_LEN];

while (fgets(line, sizeof(line), source) != NULL) {

fputs(line, target);

}

}

#ifdef NETWARE

void nwTerminate()

{

pressanykey();

apr_terminate();

}

#endif

int main(int argc, char *argv[])

{

FILE *ftemp = NULL;

FILE *fpw = NULL;

char user[MAX_STRING_LEN];

char password[MAX_STRING_LEN];

char record[MAX_STRING_LEN];

char line[MAX_STRING_LEN];

char pwfilename[MAX_STRING_LEN];

char *arg;

int found = 0;

int alg = ALG_CRYPT;

int newfile = 0;

int nofile = 0;

int noninteractive = 0;

int i;

int args_left = 2;

apr_pool_t *pool;

#if APR_CHARSET_EBCDIC

apr_status_t rv;

apr_xlate_t *to_ascii;

#endif

apr_initialize();

#ifdef NETWARE

atexit(nwTerminate);

#else

atexit(apr_terminate);

#endif

apr_pool_create(&pool, NULL);

#if APR_CHARSET_EBCDIC

rv = apr_xlate_open(&to_ascii, "ISO8859-1", APR_DEFAULT_CHARSET, pool);

if (rv) {

fprintf(stderr, "apr_xlate_open(to ASCII)->%d\n", rv);

exit(1);

}

rv = apr_SHA1InitEBCDIC(to_ascii);

if (rv) {

fprintf(stderr, "apr_SHA1InitEBCDIC()->%d\n", rv);

exit(1);

}

rv = apr_MD5InitEBCDIC(to_ascii);

if (rv) {

fprintf(stderr, "apr_MD5InitEBCDIC()->%d\n", rv);

exit(1);

}

#endif /*APR_CHARSET_EBCDIC*/

tempfilename = NULL;

apr_signal(SIGINT, (void (*)(int)) interrupted);

/*

if (argc < 3) {

return usage();

}

/*

for (i = 1; i < argc; i++) {

arg = argv[i];

if (*arg != '-') {

break;

}

while (*++arg != '\0') {

if (*arg == 'c') {

newfile++;

}

else if (*arg == 'n') {

nofile++;

args_left--;

}

else if (*arg == 'm') {

alg = ALG_APMD5;

}

else if (*arg == 's') {

alg = ALG_APSHA;

}

else if (*arg == 'p') {

alg = ALG_PLAIN;

}

else if (*arg == 'd') {

alg = ALG_CRYPT;

}

else if (*arg == 'b') {

noninteractive++;

args_left++;

}

else {

return usage();

}

}

}

/*

if ((argc - i) != args_left) {

return usage();

}

if (newfile && nofile) {

fprintf(stderr, "%s: -c and -n options conflict\n", argv[0]);

return ERR_SYNTAX;

}

if (nofile) {

i--;

}

else {

if (strlen(argv[i]) > (sizeof(pwfilename) - 1)) {

fprintf(stderr, "%s: filename too long\n", argv[0]);

return ERR_OVERFLOW;

}

strcpy(pwfilename, argv[i]);

if (strlen(argv[i + 1]) > (sizeof(user) - 1)) {

fprintf(stderr, "%s: username too long (>%" APR_SIZE_T_FMT ")\n",

argv[0], sizeof(user) - 1);

return ERR_OVERFLOW;

}

}

strcpy(user, argv[i + 1]);

if ((arg = strchr(user, ':')) != NULL) {

fprintf(stderr, "%s: username contains illegal character '%c'\n",

argv[0], *arg);

return ERR_BADUSER;

}

if (noninteractive) {

if (strlen(argv[i + 2]) > (sizeof(password) - 1)) {

fprintf(stderr, "%s: password too long (>%" APR_SIZE_T_FMT ")\n",

argv[0], sizeof(password) - 1);

return ERR_OVERFLOW;

}

strcpy(password, argv[i + 2]);

}

#if defined(WIN32) || defined(NETWARE)

if (alg == ALG_CRYPT) {

alg = ALG_APMD5;

fprintf(stderr, "Automatically using MD5 format.\n");

}

#endif

#if (!(defined(WIN32) || defined(TPF) || defined(NETWARE)))

if (alg == ALG_PLAIN) {

fprintf(stderr,"Warning: storing passwords as plain text might "

"just not work on this platform.\n");

}

#endif

if (! nofile) {

/*

if ((! newfile) && (! exists(pwfilename, pool))) {

fprintf(stderr,

"%s: cannot modify file %s; use '-c' to create it\n",

argv[0], pwfilename);

perror("fopen");

exit(ERR_FILEPERM);

}

/*

if ((! newfile) && (! readable(pwfilename))) {

fprintf(stderr, "%s: cannot open file %s for read access\n",

argv[0], pwfilename);

perror("fopen");

exit(ERR_FILEPERM);

}

/*

if (newfile && exists(pwfilename, pool) && (! readable(pwfilename))) {

fprintf(stderr, "%s: cannot open file %s for read access\n"

"%s: existing auth data would be lost on "

"password mismatch",

argv[0], pwfilename, argv[0]);

perror("fopen");

exit(ERR_FILEPERM);

}

/*

if (! writable(pwfilename)) {

fprintf(stderr, "%s: cannot open file %s for write access\n",

argv[0], pwfilename);

perror("fopen");

exit(ERR_FILEPERM);

}

}

/*

i = mkrecord(user, record, sizeof(record) - 1,

noninteractive ? password : NULL,

alg);

if (i != 0) {

fprintf(stderr, "%s: %s\n", argv[0], record);

exit(i);

}

if (nofile) {

printf("%s\n", record);

exit(0);

}

/*

errno = 0;

tempfilename = tmpnam(tname_buf);

if ((tempfilename == NULL) || (*tempfilename == '\0')) {

fprintf(stderr, "%s: unable to generate temporary filename\n",

argv[0]);

if (errno == 0) {

errno = ENOENT;

}

perror("tmpnam");

exit(ERR_FILEPERM);

}

ftemp = fopen(tempfilename, "w+");

if (ftemp == NULL) {

fprintf(stderr, "%s: unable to create temporary file '%s'\n", argv[0],

tempfilename);

perror("fopen");

exit(ERR_FILEPERM);

}

/*

if (! newfile) {

char scratch[MAX_STRING_LEN];

fpw = fopen(pwfilename, "r");

while (! (getline(line, sizeof(line), fpw))) {

char *colon;

if ((line[0] == '#') || (line[0] == '\0')) {

putline(ftemp, line);

continue;

}

strcpy(scratch, line);

/*

colon = strchr(scratch, ':');

if (colon != NULL) {

*colon = '\0';

}

if (strcmp(user, scratch) != 0) {

putline(ftemp, line);

continue;

}

found++;

break;

}

}

if (found) {

fprintf(stderr, "Updating ");

}

else {

fprintf(stderr, "Adding ");

}

fprintf(stderr, "password for user %s\n", user);

/*

putline(ftemp, record);

/*

if (! newfile) {

copy_file(ftemp, fpw);

fclose(fpw);

}

/*

fclose(ftemp);

fpw = fopen(pwfilename, "w+");

ftemp = fopen(tempfilename, "r");

copy_file(fpw, ftemp);

fclose(fpw);

fclose(ftemp);

unlink(tempfilename);

return 0;

}