static void *
skey_salt(char *ciphertext)
{
static struct skey_salt_st salt;
static char buf[128];
char *p;
strnzcpy(buf, ciphertext, sizeof(buf));
if ((p = strtok(buf, " \t")) == NULL)
return (NULL);
if (isalpha(*p)) {
strnzcpy(salt.type, p, sizeof(salt.type));
if ((p = strtok(NULL, " \t")) == NULL)
return (NULL);
}
else strnzcpy(salt.type, "md4", sizeof(salt.type));
salt.num = atoi(p);
if ((p = strtok(NULL, " \t")) == NULL)
return (NULL);
strnzcpy(salt.seed, p, sizeof(salt.seed) - 1);
if ((p = strtok(NULL, " \t")) == NULL)
return (NULL);
hex_decode(p, salt.hash, sizeof(salt.hash));
return (&salt);
}
/**
* void * krb5_salt // {{{
*
*/
static void * krb5_salt(char *ciphertext) {
struct salt *salt = NULL;
char *data = ciphertext, *p;
// check the presence of $krb5$
if (strncmp(data, MAGIC_PREFIX, strlen(MAGIC_PREFIX)) == 0) {
// advance past the $krb5$ string
data += strlen(MAGIC_PREFIX);
// allocate memory for the struct
salt = malloc(sizeof(struct salt));
if (salt == NULL)
return NULL;
// find and copy the user field
p = strchr(data, '$');
strnzcpy(salt->user, data, (p - data) + 1);
data = p + 1;
// find and copy the realm field
p = strchr(data, '$');
strnzcpy(salt->realm, data, (p - data) + 1);
data = p + 1;
// copy over the TGT in a binary form to the salt struct
hex2bin(data, (unsigned char *) salt->tgt_ebin, TGT_SIZE);
}
return salt;
}
/**
* void * krb5_salt // {{{
*
*/
static void * krb5_salt(char *ciphertext) {
static struct salt salt;
char *data = ciphertext, *p;
int n;
// advance past the $krb5$ string - it was checked for in valid()
data += strlen(MAGIC_PREFIX);
// find and copy the user field
p = strchr(data, '$');
if (!p)
return NULL;
n = (p - data) + 1;
if (n >= sizeof(salt.user))
return NULL;
strnzcpy(salt.user, data, n);
data = p + 1;
// find and copy the realm field
p = strchr(data, '$');
if (!p)
return NULL;
n = (p - data) + 1;
if (n >= sizeof(salt.realm))
return NULL;
strnzcpy(salt.realm, data, n);
data = p + 1;
// copy over the TGT in a binary form to the salt struct
p = hex2bin(data, (unsigned char *) salt.tgt_ebin, TGT_SIZE);
if (*p || p - data != TGT_SIZE * 2)
return NULL;
return &salt;
}
char *abspath(char *dst,size_t dstSize,const char *path) {
if(*path != '/') {
/* translate "abc://def" to "/dev/abc/def" */
const char *p = path;
while(*p) {
if(p[0] == ':' && p[1] == '/' && p[2] == '/') {
size_t slen = p - path;
strncpy(dst,"/dev/",SSTRLEN("/dev/"));
strncpy(dst + SSTRLEN("/dev/"),path,slen);
strnzcpy(dst + SSTRLEN("/dev/") + slen,p + 2,dstSize - (SSTRLEN("/dev/") + slen));
return dst;
}
p++;
}
/* prepend CWD */
size_t len = getenvto(dst,dstSize,"CWD");
if(len < dstSize - 1 && dst[len - 1] != '/') {
dst[len++] = '/';
dst[len] = '\0';
}
strnzcpy(dst + len,path,dstSize - len);
return dst;
}
return (char*)path;
}
int reply(info_t * in) {
char *p;
if (in->cmd == cmd_numeric && in->numeric == 1) {
strnzcpy(in->me, in->argv[0], NICKLEN+1);
} else if (in->cmd == cmd_nick) {
if (!strcasecmp(in->sender_nick, in->me)) {
if (strlen(in->tail))
strnzcpy(in->me, in->tail, NICKLEN+1);
else if (strlen(in->argv[0]))
strnzcpy(in->me, in->argv[0], NICKLEN+1);
if (!strcasecmp(in->me, wantednick))
wantednick[0] = '\0';
} else if (wantednick[0] && !strcasecmp(in->sender_nick, wantednick)){
irc_send("NICK %s", wantednick);
lasttry = time(NULL);
}
} else if (in->cmd == cmd_numeric && in->numeric == 433 && !in->me[0]) {
irc_send("NICK %s_", in->argv[1]);
lasttry = time(NULL);
strnzcpy(wantednick, in->argv[1], NICKLEN+1);
} else if (in->cmd == cmd_privmsg && CHECKAUTH(in->sender, UL_OP)) {
in->tail = skip_nick(in->tail, in->me);
if(!tail_cmd(&in->tail, "nick") && (p = tail_getp(&in->tail))) {
irc_send("NICK %s", p);
lasttry = time(NULL);
strnzcpy(wantednick, p, NICKLEN+1);
}
if(!tail_cmd(&in->tail, "whoareyou"))
irc_privmsg(to_sender(in), "I am %s", in->me);
}
return 0;
}
static void set_key(char *key, int index)
{
if(!key) return;
key_len = strlen(key);
// Yes, I'm overwriting the last byte of the salt, perhaps the coder at ElektoPost whom wrote the EPiServer password checking function used to be a C coder (their code is written in .NET)
strnzcpy(global_salt+SALT_LENGTH-1, key, PLAINTEXT_LENGTH + 1);
}
static void set_key(char *key, int index)
{
#ifdef MMX_COEF
int len;
int i;
if(index==0)
{
total_len = 0;
memset(saved_key, 0, sizeof(saved_key));
memset(length, 0, sizeof(length));
}
len = strlen(key);
if(len>PLAINTEXT_LENGTH)
len = PLAINTEXT_LENGTH;
length[index] = len;
total_len += (len + SALT_SIZE) << ( ( (32/MMX_COEF) * index ) );
for(i=0;i<len;i++)
saved_key[GETPOS(i, index)] = key[i];
saved_key[GETPOS( (i+SALT_SIZE) , index)] = 0x80;
#else
strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
#endif
}
static char *split(char *ciphertext, int index, struct fmt_main *self)
{
static char out[TOTAL_LENGTH + 1];
char *data;
if (!strncmp(ciphertext, "$mskrb5$", 8)) {
char in[TOTAL_LENGTH + 1];
char *c, *t;
strnzcpy(in, ciphertext, sizeof(in));
t = strrchr(in, '$'); *t++ = 0;
c = strrchr(in, '$'); *c++ = 0;
snprintf(out, sizeof(out), "$krb5pa$23$$$$%s%s", t, c);
} else {
char *tc;
tc = strrchr(ciphertext, '$');
snprintf(out, sizeof(out), "$krb5pa$23$$$$%s", ++tc);
}
data = out + strlen(out) - 2 * (CHECKSUM_SIZE + TIMESTAMP_SIZE) - 1;
strlwr(data);
return out;
}
static void status_print_cracking(char *percent)
{
unsigned int time = status_get_time();
char *key, saved_key[PLAINTEXT_BUFFER_SIZE];
char s_cps[64];
if (!(options.flags & FLG_STATUS_CHK)) {
if ((key = crk_get_key2()))
strnzcpy(saved_key, key, PLAINTEXT_BUFFER_SIZE);
else
saved_key[0] = 0;
}
fprintf(stderr,
"guesses: %u "
"time: %u:%02u:%02u:%02u"
"%s "
"c/s: %s",
status.guess_count,
time / 86400, time % 86400 / 3600, time % 3600 / 60, time % 60,
percent,
status_get_cps(s_cps));
if ((options.flags & FLG_STATUS_CHK) ||
!(status.crypts.lo | status.crypts.hi))
fputc('\n', stderr);
else
fprintf(stderr,
" trying: %s%s%s\n",
crk_get_key1(), saved_key[0] ? " - " : "", saved_key);
}
void path_init(char **argv)
{
#if JOHN_SYSTEMWIDE
struct passwd *pw;
#ifdef JOHN_PRIVATE_HOME
const char *private;
#endif
#else
char *pos;
#endif
#if JOHN_SYSTEMWIDE
john_home_path = mem_alloc(PATH_BUFFER_SIZE);
strnzcpy(john_home_path, JOHN_SYSTEMWIDE_HOME "/", PATH_BUFFER_SIZE);
john_home_length = strlen(john_home_path);
if (user_home_path) return;
pw = getpwuid(getuid());
endpwent();
if (!pw) return;
user_home_length = strlen(pw->pw_dir) + 1;
if (user_home_length >= PATH_BUFFER_SIZE) return;
user_home_path = mem_alloc(PATH_BUFFER_SIZE);
memcpy(user_home_path, pw->pw_dir, user_home_length - 1);
user_home_path[user_home_length - 1] = '/';
#ifdef JOHN_PRIVATE_HOME
private = path_expand(JOHN_PRIVATE_HOME);
static int
skey_valid(char *ciphertext, struct fmt_main *self)
{
char *p, *q, buf[24];
if (*ciphertext == '#')
return (0);
strnzcpy(buf, ciphertext, sizeof(buf));
if ((p = strchr(buf, ' ')) == NULL)
return (0);
*p++ = '\0';
if (isalpha(*buf)) {
if (skey_set_algorithm(buf) == NULL ||
(q = strchr(p, ' ')) == NULL)
return (0);
*q = '\0';
}
else p = buf;
for ( ; *p; p++) {
if (!isdigit(*p))
return (0);
}
return (1);
}
static void charset_filter_plaintexts(struct db_main *db)
{
struct list_entry *current, *last;
unsigned char *ptr;
char key[PLAINTEXT_BUFFER_SIZE];
last = NULL;
if ((current = db->plaintexts->head))
do {
if (!current->data[0]) {
list_del_next(db->plaintexts, last);
continue;
}
for (ptr = (unsigned char *)current->data; *ptr; ptr++)
if (*ptr < CHARSET_MIN || *ptr > CHARSET_MAX) {
list_del_next(db->plaintexts, last);
break;
}
if (*ptr) continue;
strnzcpy(key, current->data, PLAINTEXT_BUFFER_SIZE);
if (ext_filter(key)) {
if (strlen(key) <= strlen(current->data))
strcpy(current->data, key);
} else {
list_del_next(db->plaintexts, last);
continue;
}
last = current;
} while ((current = current->next));
}
char *strip_suffixes(const char *src, const char *suffixes[], int count)
{
int i, suflen, retlen, done;
static char ret[PATH_BUFFER_SIZE + 1];
done = ret[0] = 0;
if (src == NULL)
return ret;
strnzcpy(ret, src, sizeof(ret));
if (suffixes == NULL)
return ret;
while (done == 0) {
done = 1;
for (i = 0; i < count; i++) {
if (!suffixes[i] || !*suffixes[i])
continue;
retlen = strlen(ret);
suflen = strlen(suffixes[i]);
if (retlen >= suflen && !strcmp(&ret[retlen - suflen], suffixes[i])) {
ret[retlen - suflen] = 0;
done = 0;
}
}
}
return ret;
}
static void set_key(char *key, int index)
{
#ifdef MMX_COEF
int len;
int i;
if(index==0)
{
memset(saved_key, 0, sizeof(saved_key));
}
len = strlen(key);
if(len>PLAINTEXT_LENGTH)
len = PLAINTEXT_LENGTH;
length[index] = len;
for(i=0;i<len;i++)
saved_key[GETPOS(i, index)] = key[i];
saved_key[GETPOS( (i+SALT_SIZE) , index)] = 0x80;
((unsigned int *)saved_key)[15*MMX_COEF+index] = (len+SALT_SIZE)<<3;
#else
strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
#endif
}
/**
* void krb5_set_key // {{{
*
*/
static void krb5_set_key(char *key, int index) {
// copy the string key to the saved key
memset(skey.passwd, 0x00, MAX_PASS_LEN);
strnzcpy(skey.passwd, key, sizeof(skey.passwd));
}
static char *split(char *ciphertext, int index, struct fmt_main *self)
{
static char out[MAX_CIPHERTEXT_LENGTH + 1];
strnzcpy(out, ciphertext, sizeof(out));
strlwr(out);
return out;
}
// Handle a .include "file" or a .include <file>
static int cfg_process_directive_include_config(char *line, int number)
{
char *p, *p2, *saved_fname;
char Name[PATH_BUFFER_SIZE];
// Ok, we are including a file.
if (!strncmp(line, ".include \"", 10)) {
p = &line[10];
p2 = strchr(&p[1], '\"');
if (!p2) {
fprintf(stderr, "ERROR, invalid config include line: %s\n", line);
#ifndef BENCH_BUILD
log_event("! ERROR, invalid config include line: %s", line);
#endif
return 1;
}
*p2 = 0;
strnzcpy(Name, p, PATH_BUFFER_SIZE);
}
else {
p = &line[10];
p2 = strchr(&p[1], '>');
if (!p2) {
fprintf(stderr, "ERROR, invalid config include line: %s\n", line);
#ifndef BENCH_BUILD
log_event("! ERROR, invalid config include line: %s", line);
#endif
return 1;
}
*p2 = 0;
strcpy(Name, "$JOHN/");
strnzcpy(&Name[6], p, PATH_BUFFER_SIZE - 6);
}
if (cfg_recursion == 20) {
fprintf(stderr, "ERROR, .include recursion too deep in john.ini processing file .include \"%s\"\n", p);
#ifndef BENCH_BUILD
log_event("! ERROR, .include recursion too deep in john.ini processing file .include \"%s\"", p);
#endif
return 1;
}
saved_fname = cfg_name;
cfg_recursion++;
cfg_init(Name, 0);
cfg_recursion--;
cfg_name = saved_fname;
return 0;
}
static char *split(char *ciphertext, int index, struct fmt_main *self)
{
static char out[CIPHERTEXT_LENGTH + 1];
strnzcpy(out, ciphertext, CIPHERTEXT_LENGTH + 1);
strlwr(strrchr(out, '#'));
return out;
}
static void
krb4_set_key(char *key, int index)
{
if (saved_salt->realm[0] != '\0')
afs_string_to_key(key, saved_salt->realm, &saved_key.key);
else
des_string_to_key(key, &saved_key.key);
strnzcpy(saved_key.string, key, sizeof(saved_key.string));
}
/*
* JamGetProp
*
* Parse a text buffer of property name-value pairs and return
* the value of the property identified by <propName>. <buffer>
* is a NUL-terminated string containing text in the following format:
*
* "Prop-Name1: prop value 1\nProp-Name2: prop value 2..."
*
* Return-value:
*
* A pointer into the buffer of the first non-space character of
* the property value. <*length> returns the length of the property
* value, excluding any trailing white-space characters.
*
* If the given property is not found in <buffer>, NULL is returned.
*/
char* JamGetProp(char* buffer, char* name, int* length) {
char* p;
char* retval;
int len;
for (p=buffer;*p;) {
if (strncmp(p, name, strlen(name)) != 0) {
while (*p) {
if (*p == '\n') {
++p;
break;
}
++ p;
}
continue;
}
p += strlen(name);
while (*p && *p != '\n' && IS_SPACE(*p)) {
p++;
}
if (*p == ':') {
p++;
}
while (*p && *p != '\n' && IS_SPACE(*p)) {
p++;
}
retval = p;
while (*p && *p != '\n') {
p++;
}
while (p > retval && IS_SPACE(*p)) {
p--;
}
len = (p - retval + 1);
if (length == NULL) { /* DUP the string */
char * newStr;
if ((newStr = browser_malloc(len + 1)) == NULL) {
return NULL;
}
strnzcpy(newStr, retval, len);
newStr[len] = 0;
for (p=newStr; *p; p++) {
if (*p == '\r') {
*p = '\0';
}
}
return newStr;
} else {
*length = len;
return retval;
}
}
return NULL;
}
void crypt_all(int count)
{
static SHA_CTX ctx;
// Yes, I'm overwriting the last byte of the salt, perhaps the coder at ElektoPost whom wrote the EPiServer password checking function used to be a C coder (their code is written in .NET)
strnzcpy(global_salt+SALT_LENGTH-1, global_key, PLAINTEXT_LENGTH);
SHA1_Init(&ctx);
SHA1_Update(&ctx, (unsigned char*)global_salt, SALT_LENGTH+strlen(global_key));
SHA1_Final((unsigned char*)global_crypt, &ctx);
}
NODE *lerasefile(NODE *arg)
{
char *fnstr;
arg = cnv_node_to_strnode(car(arg));
if (arg == UNBOUND) return(UNBOUND);
fnstr = malloc((size_t)getstrlen(arg) + 1);
strnzcpy(fnstr, getstrptr(arg), getstrlen(arg));
unlink(fnstr);
free(fnstr);
return(UNBOUND);
}
ssize_t getenvito(char *name,size_t nameSize,size_t index) {
if(index >= envcount())
return -EINVAL;
char *val = strchr(environ[index],'=');
if(!val)
return -EFAULT;
*val = '\0';
size_t len = strnzcpy(name,environ[index],nameSize);
*val = '=';
return len;
}
static void status_print_cracking(char *percent)
{
unsigned int time = status_get_time();
char *key1, key2[PLAINTEXT_BUFFER_SIZE];
int64 g;
char s_gps[32], s_pps[32], s_crypts_ps[32], s_combs_ps[32];
char s[1024], *p;
int n;
key1 = NULL;
key2[0] = 0;
if (!(options.flags & FLG_STATUS_CHK) &&
(status.crypts.lo | status.crypts.hi)) {
char *key = crk_get_key2();
if (key)
strnzcpy(key2, key, sizeof(key2));
key1 = crk_get_key1();
}
p = s;
if (options.fork) {
n = sprintf(p, "%u ", options.node_min);
if (n > 0)
p += n;
}
g.lo = status.guess_count; g.hi = 0;
n = sprintf(p,
"%ug %u:%02u:%02u:%02u%.100s %.31sg/s ",
status.guess_count,
time / 86400, time % 86400 / 3600, time % 3600 / 60, time % 60,
percent,
status_get_cps(s_gps, &g, 0));
if (n > 0)
p += n;
if (!status.compat) {
n = sprintf(p,
"%.31sp/s %.31sc/s ",
status_get_cps(s_pps, &status.cands, 0),
status_get_cps(s_crypts_ps, &status.crypts, 0));
if (n > 0)
p += n;
}
n = sprintf(p, "%.31sC/s%s%.200s%s%.200s\n",
status_get_cps(s_combs_ps, &status.combs, status.combs_ehi),
key1 ? " " : "", key1 ? key1 : "", key2[0] ? ".." : "", key2);
if (n > 0)
p += n;
fwrite(s, p - s, 1, stderr);
}
/*
* Translates a flo line using rf_rules.
* Returns 0 if no rf_rules defined, otherwise returned value
* should be free()'d
*/
char *trans_flo_line (char *s, RF_RULE *rf_rules)
{
RF_RULE *curr;
char buf[MAXPATHLEN + 1];
if (rf_rules)
{
char *w;
strnzcpy (buf, s, MAXPATHLEN);
for (curr = rf_rules; curr; curr = curr->next)
{
w = ed (buf, curr->from, curr->to, NULL);
strnzcpy (buf, w, MAXPATHLEN);
free (w);
}
return xstrdup (buf);
}
else
return 0;
}
ssize_t getenvto(char *value,size_t valSize,const char *name) {
char **var = environ;
size_t len = strlen(name);
while(*var) {
char *val = strchr(*var,'=');
if(val) {
if(len == (size_t)(val - *var) && strncmp(*var,name,len) == 0)
return strnzcpy(value,val + 1,valSize);
}
var++;
}
return -ENOTFOUND;
}
FILE *open_file(NODE *arg, char *access)
{
char *fnstr;
FILE *tstrm;
ref(arg);
arg = reref(arg, cnv_node_to_strnode(arg));
if (arg == UNBOUND) return(NULL);
fnstr = (char *) malloc((size_t)getstrlen(arg) + 1);
strnzcpy(fnstr, getstrptr(arg), getstrlen(arg));
tstrm = fopen(fnstr, access);
deref(arg);
free(fnstr);
return(tstrm);
}
NODE *lerasefile(NODE *arg) {
char *fnstr;
arg = cnv_node_to_strnode(car(arg));
if (arg == UNBOUND) return(UNBOUND);
fnstr = malloc((size_t)getstrlen(arg) + 1);
if (fnstr == NULL) {
err_logo(FILE_ERROR, make_static_strnode(message_texts[MEM_LOW]));
return UNBOUND;
}
strnzcpy(fnstr, getstrptr(arg), getstrlen(arg));
unlink(fnstr);
free(fnstr);
return(UNBOUND);
}
static void set_key(char *key, int index)
{
#ifdef SIMD_COEF_32
const ARCH_WORD_32 *wkey = (ARCH_WORD_32*)key;
ARCH_WORD_32 *keybuffer = &((ARCH_WORD_32*)saved_key)[(index&(SIMD_COEF_32-1)) + (unsigned int)index/SIMD_COEF_32*SHA_BUF_SIZ*SIMD_COEF_32];
ARCH_WORD_32 *keybuf_word = keybuffer;
unsigned int len;
ARCH_WORD_32 temp;
len = 0;
while((unsigned char)(temp = *wkey++)) {
if (!(temp & 0xff00))
{
*keybuf_word = JOHNSWAP((temp & 0xff) | (0x80 << 8));
len++;
goto key_cleaning;
}
if (!(temp & 0xff0000))
{
*keybuf_word = JOHNSWAP((temp & 0xffff) | (0x80 << 16));
len+=2;
goto key_cleaning;
}
if (!(temp & 0xff000000))
{
*keybuf_word = JOHNSWAP(temp | (0x80 << 24));
len+=3;
goto key_cleaning;
}
*keybuf_word = JOHNSWAP(temp);
len += 4;
keybuf_word += SIMD_COEF_32;
}
*keybuf_word = 0x80000000;
key_cleaning:
keybuf_word += SIMD_COEF_32;
while(*keybuf_word) {
*keybuf_word = 0;
keybuf_word += SIMD_COEF_32;
}
saved_len[index] = len;
#else
strnzcpy(saved_key[index], key, PLAINTEXT_LENGTH + 1);
#endif
}
static void *get_salt(char *ciphertext)
{
char *ctcopy = strdup(ciphertext);
char *keeptr = ctcopy;
char *p;
int i;
static struct custom_salt cs;
ctcopy += 10; /* skip over "$postgres$" */
p = strtok(ctcopy, "*");
strnzcpy((char*)cs.user, p, MAX_USERNAME_LEN + 1);
p = strtok(NULL, "*");
for (i = 0; i < 4; i++)
cs.salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
MEM_FREE(keeptr);
return (void *)&cs;
}
