MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-29 10:12:39 +01:00
Code Issues Releases Wiki Activity

Import new mkpasswd from ircd-ratbox.

Browse source 
This now uses libratbox.
This commit is contained in:
Jilles Tjoelker 2009-02-22 00:59:16 +01:00
parent 4a584d412e
commit f1d07f6b7c
2 changed files with 441 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
tools/Makefile.in
View file

@ -15,13 +15,14 @@ MV = @MV@
RM = @RM@ RM = @RM@
LN = @LN@ LN = @LN@
IRCDLIBS = @LIBS@ IRCDLIBS = -L../libratbox/src/.libs -lratbox @LIBS@
INCLUDES = -I../include INCLUDES = -I../include -I../libratbox/include
CPPFLAGS = ${INCLUDES} @CPPFLAGS@ CPPFLAGS = ${INCLUDES} @CPPFLAGS@
prefix = @prefix@ prefix = @prefix@
exec_prefix = @exec_prefix@ exec_prefix = @exec_prefix@
bindir = @bindir@ bindir = @bindir@
libdir = @libdir@
libexecdir = @libexecdir@ libexecdir = @libexecdir@
confdir = @confdir@ confdir = @confdir@
localstatedir = @localstatedir@ localstatedir = @localstatedir@

256
tools/mkpasswd.c
View file

@ -9,7 +9,7 @@
** /dev/random for salt generation added by ** /dev/random for salt generation added by
** Aaron Sethman <androsyn@ratbox.org> ** Aaron Sethman <androsyn@ratbox.org>
** **
** $Id: mkpasswd.c 6 2005-09-10 01:02:21Z nenolod $ ** $Id: mkpasswd.c 26439 2009-02-01 15:27:24Z jilles $
*/ */
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@ -17,6 +17,10 @@
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
#include "ratbox_lib.h"
#ifndef __MINGW32__
#include <pwd.h>
#endif
#define FLAG_MD5 0x00000001 #define FLAG_MD5 0x00000001
#define FLAG_DES 0x00000002 #define FLAG_DES 0x00000002
@ -26,15 +30,19 @@
#define FLAG_BLOWFISH 0x00000020 #define FLAG_BLOWFISH 0x00000020
#define FLAG_ROUNDS 0x00000040 #define FLAG_ROUNDS 0x00000040
#define FLAG_EXT 0x00000080 #define FLAG_EXT 0x00000080
#define FLAG_SHA256 0x00000100
#define FLAG_SHA512 0x00000200
extern char *getpass();
extern char *crypt();
static char *make_des_salt(void); static char *make_des_salt(void);
static char *make_ext_salt(int); static char *make_ext_salt(int);
static char *make_ext_salt_para(int, char *); static char *make_ext_salt_para(int, char *);
static char *make_md5_salt(int); static char *make_md5_salt(int);
static char *make_md5_salt_para(char *); static char *make_md5_salt_para(char *);
static char *make_sha256_salt(int);
static char *make_sha256_salt_para(char *);
static char *make_sha512_salt(int);
static char *make_sha512_salt_para(char *);
static char *make_bf_salt(int, int); static char *make_bf_salt(int, int);
static char *make_bf_salt_para(int, char *); static char *make_bf_salt_para(int, char *);
static char *int_to_base64(int); static char *int_to_base64(int);
@ -44,13 +52,50 @@ static char *generate_poor_salt(char *, int);
static void full_usage(void); static void full_usage(void);
static void brief_usage(void); static void brief_usage(void);
static char saltChars[] = static char saltChars[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* 0 .. 63, ascii - 64 */ /* 0 .. 63, ascii - 64 */
extern char *optarg; extern char *optarg;
int main(int argc, char *argv[])
#ifdef __MINGW32__
#include <conio.h>
#ifdef PASS_MAX
#undef PASS_MAX
#endif
#define PASS_MAX 256
static char getpassbuf[PASS_MAX + 1];
static char *
getpass(const char *prompt)
{
int c;
int i = 0;
memset(getpassbuf, sizeof(getpassbuf), 0);
fputs(prompt, stderr);
for(;;)
{
c = _getch();
if(c == '\r')
{
getpassbuf[i] = '\0';
break;
}
else if(i < PASS_MAX)
{
getpassbuf[i++] = c;
}
}
fputs("\r\n", stderr);
return getpassbuf;
}
#endif
int
main(int argc, char *argv[])
{ {
char *plaintext = NULL; char *plaintext = NULL;
int c; int c;
@ -64,9 +109,9 @@ int main(int argc, char *argv[])
** parameter. ** parameter.
*/ */
while( (c=getopt(argc, argv, "mdber:h?l:s:p:")) != -1) while((c = getopt(argc, argv, "xymdber:h?l:s:p:")) != -1)
{ {
switch(c) switch (c)
{ {
case 'm': case 'm':
flag |= FLAG_MD5; flag |= FLAG_MD5;
@ -98,6 +143,12 @@ int main(int argc, char *argv[])
flag |= FLAG_PASS; flag |= FLAG_PASS;
plaintext = optarg; plaintext = optarg;
break; break;
case 'x':
flag |= FLAG_SHA256;
break;
case 'y':
flag |= FLAG_SHA512;
break;
case 'h': case 'h':
full_usage(); full_usage();
/* NOT REACHED */ /* NOT REACHED */
@ -112,30 +163,48 @@ int main(int argc, char *argv[])
} }
} }
if (flag & FLAG_MD5) if(flag & FLAG_MD5)
{ {
if (length == 0) if(length == 0)
length = 8; length = 8;
if (flag & FLAG_SALT) if(flag & FLAG_SALT)
salt = make_md5_salt_para(saltpara); salt = make_md5_salt_para(saltpara);
else else
salt = make_md5_salt(length); salt = make_md5_salt(length);
} }
else if (flag & FLAG_BLOWFISH) else if(flag & FLAG_BLOWFISH)
{ {
if (length == 0) if(length == 0)
length = 22; length = 22;
if (flag & FLAG_SALT) if(flag & FLAG_SALT)
salt = make_bf_salt_para(rounds, saltpara); salt = make_bf_salt_para(rounds, saltpara);
else else
salt = make_bf_salt(rounds, length); salt = make_bf_salt(rounds, length);
} }
else if (flag & FLAG_EXT) else if(flag & FLAG_SHA256)
{
if(length == 0)
length = 16;
if(flag & FLAG_SALT)
salt = make_sha256_salt_para(saltpara);
else
salt = make_sha256_salt(length);
}
else if(flag & FLAG_SHA512)
{
if(length == 0)
length = 16;
if(flag & FLAG_SALT)
salt = make_sha512_salt_para(saltpara);
else
salt = make_sha512_salt(length);
}
else if(flag & FLAG_EXT)
{ {
/* XXX - rounds needs to be done */ /* XXX - rounds needs to be done */
if (flag & FLAG_SALT) if(flag & FLAG_SALT)
{ {
if ((strlen(saltpara) == 4)) if((strlen(saltpara) == 4))
{ {
salt = make_ext_salt_para(rounds, saltpara); salt = make_ext_salt_para(rounds, saltpara);
} }
@ -152,9 +221,9 @@ int main(int argc, char *argv[])
} }
else else
{ {
if (flag & FLAG_SALT) if(flag & FLAG_SALT)
{ {
if ((strlen(saltpara) == 2)) if((strlen(saltpara) == 2))
{ {
salt = saltpara; salt = saltpara;
} }
@ -170,9 +239,9 @@ int main(int argc, char *argv[])
} }
} }
if (flag & FLAG_PASS) if(flag & FLAG_PASS)
{ {
if (!plaintext) if(!plaintext)
printf("Please enter a valid password\n"); printf("Please enter a valid password\n");
} }
else else
@ -180,11 +249,12 @@ int main(int argc, char *argv[])
plaintext = getpass("plaintext: "); plaintext = getpass("plaintext: ");
} }
printf("%s\n", crypt(plaintext, salt)); printf("%s\n", rb_crypt(plaintext, salt));
return 0; return 0;
} }
static char *make_des_salt() static char *
make_des_salt()
{ {
static char salt[3]; static char salt[3];
generate_random_salt(salt, 2); generate_random_salt(salt, 2);
@ -192,12 +262,13 @@ static char *make_des_salt()
return salt; return salt;
} }
char *int_to_base64(int value) char *
int_to_base64(int value)
{ {
static char buf[5]; static char buf[5];
int i; int i;
for (i = 0; i < 4; i++) for(i = 0; i < 4; i++)
{ {
buf[i] = saltChars[value & 63]; buf[i] = saltChars[value & 63];
value >>= 6; /* Right shifting 6 places is the same as dividing by 64 */ value >>= 6; /* Right shifting 6 places is the same as dividing by 64 */
@ -209,7 +280,8 @@ char *int_to_base64(int value)
return buf; return buf;
} }
char *make_ext_salt(int rounds) char *
make_ext_salt(int rounds)
{ {
static char salt[10]; static char salt[10];
@ -219,7 +291,8 @@ char *make_ext_salt(int rounds)
return salt; return salt;
} }
char *make_ext_salt_para(int rounds, char *saltpara) char *
make_ext_salt_para(int rounds, char *saltpara)
{ {
static char salt[10]; static char salt[10];
@ -227,10 +300,11 @@ char *make_ext_salt_para(int rounds, char *saltpara)
return salt; return salt;
} }
char *make_md5_salt_para(char *saltpara) char *
make_md5_salt_para(char *saltpara)
{ {
static char salt[21]; static char salt[21];
if (saltpara && (strlen(saltpara) <= 16)) if(saltpara && (strlen(saltpara) <= 16))
{ {
/* sprintf used because of portability requirements, the length /* sprintf used because of portability requirements, the length
** is checked above, so it should not be too much of a concern ** is checked above, so it should not be too much of a concern
@ -245,10 +319,11 @@ char *make_md5_salt_para(char *saltpara)
return NULL; return NULL;
} }
char *make_md5_salt(int length) char *
make_md5_salt(int length)
{ {
static char salt[21]; static char salt[21];
if (length > 16) if(length > 16)
{ {
printf("MD5 salt length too long\n"); printf("MD5 salt length too long\n");
exit(0); exit(0);
@ -257,16 +332,92 @@ char *make_md5_salt(int length)
salt[1] = '1'; salt[1] = '1';
salt[2] = '$'; salt[2] = '$';
generate_random_salt(&salt[3], length); generate_random_salt(&salt[3], length);
salt[length+3] = '$'; salt[length + 3] = '$';
salt[length+4] = '\0'; salt[length + 4] = '\0';
return salt; return salt;
} }
char *make_bf_salt_para(int rounds, char *saltpara) char *
make_sha256_salt_para(char *saltpara)
{
static char salt[21];
if(saltpara && (strlen(saltpara) <= 16))
{
/* sprintf used because of portability requirements, the length
** is checked above, so it should not be too much of a concern
*/
sprintf(salt, "$5$%s$", saltpara);
return salt;
}
printf("Invalid Salt, please use up to 16 random alphanumeric characters\n");
exit(1);
/* NOT REACHED */
return NULL;
}
char *
make_sha512_salt_para(char *saltpara)
{
static char salt[21];
if(saltpara && (strlen(saltpara) <= 16))
{
/* sprintf used because of portability requirements, the length
** is checked above, so it should not be too much of a concern
*/
sprintf(salt, "$6$%s$", saltpara);
return salt;
}
printf("Invalid Salt, please use up to 16 random alphanumeric characters\n");
exit(1);
/* NOT REACHED */
return NULL;
}
char *
make_sha256_salt(int length)
{
static char salt[21];
if(length > 16)
{
printf("SHA256 salt length too long\n");
exit(0);
}
salt[0] = '$';
salt[1] = '5';
salt[2] = '$';
generate_random_salt(&salt[3], length);
salt[length + 3] = '$';
salt[length + 4] = '\0';
return salt;
}
char *
make_sha512_salt(int length)
{
static char salt[21];
if(length > 16)
{
printf("SHA512 salt length too long\n");
exit(0);
}
salt[0] = '$';
salt[1] = '6';
salt[2] = '$';
generate_random_salt(&salt[3], length);
salt[length + 3] = '$';
salt[length + 4] = '\0';
return salt;
}
char *
make_bf_salt_para(int rounds, char *saltpara)
{ {
static char salt[31]; static char salt[31];
char tbuf[3]; char tbuf[3];
if (saltpara && (strlen(saltpara) <= 22)) if(saltpara && (strlen(saltpara) <= 22))
{ {
/* sprintf used because of portability requirements, the length /* sprintf used because of portability requirements, the length
** is checked above, so it should not be too much of a concern ** is checked above, so it should not be too much of a concern
@ -282,11 +433,12 @@ char *make_bf_salt_para(int rounds, char *saltpara)
return NULL; return NULL;
} }
char *make_bf_salt(int rounds, int length) char *
make_bf_salt(int rounds, int length)
{ {
static char salt[31]; static char salt[31];
char tbuf[3]; char tbuf[3];
if (length > 22) if(length > 22)
{ {
printf("BlowFish salt length too long\n"); printf("BlowFish salt length too long\n");
exit(0); exit(0);
@ -294,35 +446,37 @@ char *make_bf_salt(int rounds, int length)
sprintf(tbuf, "%02d", rounds); sprintf(tbuf, "%02d", rounds);
sprintf(salt, "$2a$%s$", tbuf); sprintf(salt, "$2a$%s$", tbuf);
generate_random_salt(&salt[7], length); generate_random_salt(&salt[7], length);
salt[length+7] = '$'; salt[length + 7] = '$';
salt[length+8] = '\0'; salt[length + 8] = '\0';
return salt; return salt;
} }
char *generate_poor_salt(char *salt, int length) char *
generate_poor_salt(char *salt, int length)
{ {
int i; int i;
srandom(time(NULL)); srand(time(NULL));
for(i = 0; i < length; i++) for(i = 0; i < length; i++)
{ {
salt[i] = saltChars[random() % 64]; salt[i] = saltChars[rand() % 64];
} }
return(salt); return (salt);
} }
char *generate_random_salt(char *salt, int length) char *
generate_random_salt(char *salt, int length)
{ {
char *buf; char *buf;
int fd, i; int fd, i;
if((fd = open("/dev/random", O_RDONLY)) < 0) if((fd = open("/dev/random", O_RDONLY)) < 0)
{ {
return(generate_poor_salt(salt, length)); return (generate_poor_salt(salt, length));
} }
buf = calloc(1, length); buf = calloc(1, length);
if(read(fd, buf, length) != length) if(read(fd, buf, length) != length)
{ {
free(buf); free(buf);
return(generate_poor_salt(salt, length)); return (generate_poor_salt(salt, length));
} }
for(i = 0; i < length; i++) for(i = 0; i < length; i++)
@ -330,12 +484,15 @@ char *generate_random_salt(char *salt, int length)
salt[i] = saltChars[abs(buf[i]) % 64]; salt[i] = saltChars[abs(buf[i]) % 64];
} }
free(buf); free(buf);
return(salt); return (salt);
} }
void full_usage() void
full_usage()
{ {
printf("mkpasswd [-m|-d|-b|-e] [-l saltlength] [-r rounds] [-s salt] [-p plaintext]\n"); printf("mkpasswd [-m|-d|-b|-e] [-l saltlength] [-r rounds] [-s salt] [-p plaintext]\n");
printf("-x Generate a SHA256 password\n");
printf("-y Generate a SHA512 password\n");
printf("-m Generate an MD5 password\n"); printf("-m Generate an MD5 password\n");
printf("-d Generate a DES password\n"); printf("-d Generate a DES password\n");
printf("-b Generate a BlowFish password\n"); printf("-b Generate a BlowFish password\n");
@ -351,7 +508,8 @@ void full_usage()
exit(0); exit(0);
} }
void brief_usage() void
brief_usage()
{ {
printf("mkpasswd - password hash generator\n"); printf("mkpasswd - password hash generator\n");
printf("Standard DES: mkpasswd [-d] [-s salt] [-p plaintext]\n"); printf("Standard DES: mkpasswd [-d] [-s salt] [-p plaintext]\n");