Attachment #82400 for bug #122435

View | Details | Raw Unified | Return to bug 122435
Collapse All | Expand All





Q: What's this?
A: It's a patch to Solar Designer's "john the ripper" password cracker.

Q: What's it good for, then?
A: It enables cracking of many different hashes. The list includes:
	- Kerberos AFS DES
	- Eggdrop Blowfish
	- OpenBSD Blowfish
	- BSDI DES
	- Traditional DES
	- NT LM DES
	- Lotus V5 web password
	- Apache MD5
	- FreeBSD MD5
	- MS Cache Hash
	- MYSQL
	- Netscape LDAP SHA
	- NTHASH (md4)
	- Raw MD5
	- Raw SHA1
	- Oracle

Q: Who made this?
A: The original patches are from the /contrib/ directory of john the ripper.
Their respective authors are shown on the john page, except:
	- Domino v5 by Jeff Fay
	- mscash, raw-md5, raw-sha1, hmac-md5, oracle 
	by Bartavelle@bandecon.com

Q: How do I install it?
A: I assume you are able to install john from a source distribution,
   if you are not, PLEASE read john's documentation before e-mailing me. 
   To install run 'gunzip -c john-1.6.37-bigpatch.x.ge | patch -p0' from the
   directory containing john   and then run 'make (your-system-type-here)' to 
   build john.

Q: NT hash support is broken!
A: NT hash support works with file whose format is:
USERNAME:$NT$A04B60AC43771EB386B94FEBAC779BBC
if your file looks that way:
USERNAME:A04B60AC43771EB386B94FEBAC779BBC
use the "-format:NT" option.

Q: It doesn't work!
A: This big patch has not been extensively tested. It should work most of the
time on all architectures. Please send all questions to bartavelle@bandecon.com

Thanks to:
Solar Designer for john and the advises
Arnaud Pilon for the MS Cash algorithm and the CacheDump tool
Moof (from thinko.net) for the macintosh shell
HP for their testdrive systems, and the fact they allow me to use john on their
servers.





Q: What's this?
A: It's a patch to Solar Designer's "john the ripper" password cracker.

Q: What's it good for, then?
A: It enables cracking of Windows NT/2000 MD4 (case-sensitive) password hashes.

Q: Who made this?
A: This patch was thrown together on a boring Sunday by Olle Segerdahl.
   It uses Andrew Tridgell's NTLM and MD4 code stolen from samba-2.0.7 .

Q: How do I install it?
A: I assume you are able to install john from a source distribution,
   if you are not, PLEASE read john's documentation before e-mailing me. 
   To install run 'patch < john-ntlm-v02.diff' from the john "src" directory
   and then run 'make (your-system-type-here)' to build john.

Q: How do I use john to crack NT password hashes?
A: Use pwdump2 or L0phtcrack to dump the password hashes into a file,
   then run 'john pwfile -format:NT' to start cracking!

Q: I get all kinds of compile errors!
A: This patch was made against john-1.6.36, lots of stuff might have broken
   source compatibility since then... Use something closer to john-1.6.36.

Q: I have a question not covered by this FAQ!
A: Make sure you have read all there is to read about john, then
   mail me at olle@nxs.se with "JOHN-NTLM" in the subject.





***************
*** 1,6 ****
  #
  # This file is part of John the Ripper password cracker,
- # Copyright (c) 1996-2004 by Solar Designer
  #
  
  [Options]
--- 1,6 ----
  #
  # This file is part of John the Ripper password cracker,
+ # Copyright (c) 1996-2003 by Solar Designer
  #
  
  [Options]




/*
 * This file is part of Eggdrop blowfish patch for John The Ripper.
 * Copyright (c) 2002 by Sun-Zero <sun-zero@freemail.hu>
 * This is a free software distributable under terms of the GNU GPL. 
 */

#include <string.h>

#include "misc.h"
#include "formats.h"
#include "common.h"
#include "blowfish.c"

#define FORMAT_LABEL			"bfegg"
#define FORMAT_NAME			"Eggdrop"
#define ALG_NAME			"blowfish"

#define BENCHMARK_COMMENT		""
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		31
#define CIPHERTEXT_LENGTH		33

#define BINARY_SIZE			13
#define SALT_SIZE			0

#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1

static struct fmt_tests tests[] = {
    {"+9F93o1OxwgK1", "123456"},
    {"+C/.8o.Wuph9.", "qwerty"},
    {"+EEHgy/MBLDd0", "walkman"},
    {"+vPBrs07OTXE/", "tesztuser"},
    {"+zIvO/1nDsd9.", "654321"},
    {NULL}
};

int zerolengthkey = 0;

static char crypt_key[BINARY_SIZE + 1]; //changed by bartavelle so that it works on alpha
static char saved_key[PLAINTEXT_LENGTH + 1];

static int valid(char *ciphertext) {
    if (strncmp(ciphertext, "+", 1) != 0) return 0;
    if (strlen(ciphertext) != 13) return 0;
    
    return 1;
}

void init() {
    blowfish_first_init();
}


static void set_key(char *key, int index) {
    strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
}

static char *get_key(int index) {
  return saved_key;
}

static int cmp_all(void *binary, int index) {
  if (zerolengthkey) return 0;
  return !memcmp(binary, crypt_key, BINARY_SIZE);
}

static int cmp_exact(char *source, int index) {
  return 1;
}

static void set_salt(void *salt) { }

static void crypt_all(int count) {  
    if (saved_key[0] == '\0') {
	zerolengthkey = 1;
    } else {
	zerolengthkey = 0;
        blowfish_encrypt_pass(saved_key, crypt_key);
    }
}

struct fmt_main fmt_BFEgg = {
  {
    FORMAT_LABEL,
    FORMAT_NAME,
    ALG_NAME,
    BENCHMARK_COMMENT,
    BENCHMARK_LENGTH,
    PLAINTEXT_LENGTH,
    BINARY_SIZE,
    SALT_SIZE,
    MIN_KEYS_PER_CRYPT,
    MAX_KEYS_PER_CRYPT,
    FMT_CASE | FMT_8_BIT,
    tests
  }, {
    init,
    valid,
    fmt_default_split,
    fmt_default_binary,
    fmt_default_salt,
    {
	fmt_default_binary_hash,
	fmt_default_binary_hash,
	fmt_default_binary_hash,
    },
	fmt_default_salt_hash,
	set_salt,
	set_key,
	get_key,
	fmt_default_clear_keys,
	crypt_all, 
	{
	    fmt_default_get_hash,
	    fmt_default_get_hash,
	    fmt_default_get_hash,
	},
	    cmp_all,
	    cmp_all,
	    cmp_exact
  }
};





/*
    Modified by Sun-Zero <sun-zero@freemail.hu>
    2004. 07. 26. 
    
    Now, its work with md5 hash of apache.
    The original john patch came from 
    http://lists.jammed.com/pen-test/2001/11/0134.html by
    Kostas Evangelinos (kos@bastard.net)
*/

/*
 * This file is part of John the Ripper password cracker,
 * Copyright (c) 1996-2001 by Solar Designer
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "MD5_std.h"
#include "common.h"
#include "formats.h"

#define FORMAT_LABEL			"md5a"
#define FORMAT_NAME			"Apache MD5"

#define BENCHMARK_COMMENT		""
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		15
#define CIPHERTEXT_LENGTH		22

#define BINARY_SIZE			4
#define SALT_SIZE			8

#define MIN_KEYS_PER_CRYPT		MD5_N
#define MAX_KEYS_PER_CRYPT		MD5_N


static struct fmt_tests tests[] = {
	{"$apr1$Q6ZYh...$RV6ft2bZ8j.NGrxLYaJt9.", "test"},
	{"$apr1$rBXqc...$NlXxN9myBOk95T0AyLAsJ0", "john"},
	{"$apr1$Grpld/..$qp5GyjwM2dnA5Cdej9b411", "the"},
	{"$apr1$GBx.D/..$yfVeeYFCIiEXInfRhBRpy/", "ripper"},
	{NULL}
};

static char saved_key[MD5_N][PLAINTEXT_LENGTH + 1];

static int valid(char *ciphertext)
{
	char *pos, *start;

	if (strncmp(ciphertext, "$apr1$", 6)) return 0;

        /* magic string */
        start = &ciphertext[1];
	for (pos = start; *pos && *pos != '$'; pos++);
    		if (!*pos || pos < start+1 || pos > start+MD5_MAGIC_LENGTH+1) 
		    return 0;

        /* salt */
        start = ++pos;
        for (pos = start; *pos && *pos != '$'; pos++);
    	    if (!*pos || pos < start || pos > start+8) 
		return 0;


	start = ++pos;
	while (atoi64[ARCH_INDEX(*pos)] != 0x7F) pos++;
	if (*pos || pos - start != CIPHERTEXT_LENGTH) return 0;

	if (atoi64[ARCH_INDEX(*(pos - 1))] & 0x3C) return 0;

	return 1;
}

static int binary_hash_0(void *binary)
{
	return *(MD5_word *)binary & 0xF;
}

static int binary_hash_1(void *binary)
{
	return *(MD5_word *)binary & 0xFF;
}

static int binary_hash_2(void *binary)
{
	return *(MD5_word *)binary & 0xFFF;
}

static int get_hash_0(int index)
{
	return MD5_out[index][0] & 0xF;
}

static int get_hash_1(int index)
{
	return MD5_out[index][0] & 0xFF;
}

static int get_hash_2(int index)
{
	return MD5_out[index][0] & 0xFFF;
}

static int salt_hash(void *salt)
{
	return
		((int)atoi64[ARCH_INDEX(((char *)salt)[0])] |
		((int)atoi64[ARCH_INDEX(((char *)salt)[1])] << 6)) & 0x3FF;
}

static void set_key(char *key, int index)
{
	MD5_std_set_key(key, index);

	strnfcpy(saved_key[index], key, PLAINTEXT_LENGTH);
}

static char *get_key(int index)
{
	saved_key[index][PLAINTEXT_LENGTH] = 0;

	return saved_key[index];
}

static int cmp_all(void *binary, int index)
{

#if MD5_X2
	return *(MD5_word *)binary == MD5_out[0][0] ||
		*(MD5_word *)binary == MD5_out[1][0];
#else
	return *(MD5_word *)binary == MD5_out[0][0];
#endif
}


static int cmp_exact(char *source, int index)
{
	return !memcmp(MD5_std_get_binary(source, MD5_TYPE_APACHE), MD5_out[index],
		sizeof(MD5_binary));
}


static void crypt_all(int count) {
    MD5_std_crypt(MD5_TYPE_APACHE);
}

static void *get_salt(char *ciphertext) {
    return MD5_std_get_salt(ciphertext, MD5_TYPE_APACHE);
}

static void *get_binary(char *ciphertext) {
    return MD5_std_get_binary(ciphertext, MD5_TYPE_APACHE);
}


struct fmt_main fmt_MD5_apache = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		MD5_ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		tests
	}, {
		MD5_std_init,
		valid,
		fmt_default_split,
		get_binary,		//(void *(*)(char *))MD5_std_get_binary,
		get_salt,  		//(void *(*)(char *))MD5_std_get_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		salt_hash,
		(void (*)(void *))MD5_std_set_salt,
		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all,		//(void (*)(int))MD5_std_crypt,
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		cmp_all,
		cmp_all,
		cmp_exact
	}
};





static int cmp_exact(char *source, int index)
{
	return !memcmp(MD5_std_get_binary(source, MD5_TYPE_STD), MD5_out[index],
		sizeof(MD5_binary));
}

static void crypt_all(int count) {
	MD5_std_crypt(MD5_TYPE_STD);
}

static void *get_salt(char *ciphertext) {
	return MD5_std_get_salt(ciphertext, MD5_TYPE_STD);
}

static void *get_binary(char *ciphertext) {
	return MD5_std_get_binary(ciphertext, MD5_TYPE_STD);
}

struct fmt_main fmt_MD5 = {
	{
		FORMAT_LABEL,

		MD5_std_init,
		valid,
		fmt_default_split,
		get_binary,		/* (void *(*)(char *))MD5_std_get_binary, */
		get_salt,		/* (void *(*)(char *))MD5_std_get_salt, */
		{
			binary_hash_0,
			binary_hash_1,

		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all,		/* (void (*)(int))MD5_std_crypt, */
		{
			get_hash_0,
			get_hash_1,




	order[19][index].length = current->l.pp;
}

void MD5_std_crypt(int md5_type)
{
	int length, index, mask;
	MD5_pattern *line;

	for (index = 0, key = pool; index < MD5_N; index++, key++) {
#endif
		memcpy(&block[index], key->o.p.b, key->l.p);
		if (md5_type == MD5_TYPE_APACHE) {
			memcpy(&block[index].b[key->l.p], "$apr1$", 6);
			memcpy(&block[index].b[key->l.p + 6], key->s, key->l.s);
			memcpy(&block[index].b[key->l.ps + 6],
				MD5_out[index], key->l.p);
			length = key->l.psp + 6;
		} else {
			memcpy(&block[index].b[key->l.p], "$1$", 3);
			memcpy(&block[index].b[key->l.p + 3], key->s, key->l.s);
			memcpy(&block[index].b[key->l.ps + 3],
				MD5_out[index], key->l.p);
			length = key->l.psp + 3;
		}
		if ((mask = key->l.p))
		do {
			block[index].b[length++] =


#endif

char *MD5_std_get_salt(char *ciphertext, int md5_type)
{
	static char out[9];
	int length;
	char *pos;
	char *start;

	start = &ciphertext[1];
	if (md5_type == MD5_TYPE_APACHE) {
		for (pos = start; *pos && *pos != '$'; pos++);
		start = ++pos;
	}

	for (length = 0; length < 8; length++) {
		if (md5_type == MD5_TYPE_APACHE) {
			if ((out[length] = start[length]) == '$') break;
		} else {
			if ((out[length] = ciphertext[3 + length]) == '$') break;
		}
	}
	out[length] = 0;

	return out;

	out.b[b2] = value >> 8; \
	out.b[b3] = value;

MD5_word *MD5_std_get_binary(char *ciphertext, int md5_type)
{
	static union {
		MD5_binary w;

	char *pos;
	MD5_word value;

	char *start;
	if (md5_type == MD5_TYPE_APACHE) {
		start = &ciphertext[1];
		for (pos = start; *pos && *pos != '$'; pos++);
		if (!*pos || pos < start+1 || pos > start+MD5_MAGIC_LENGTH+1) return 0;
		pos++;
		while (*pos++ != '$');
	} else {
		pos = ciphertext + 3; while (*pos++ != '$');
	}

	TO_BINARY(0, 6, 12);
	TO_BINARY(1, 7, 13);

Lines 13-18 Link Here

(-)john-1.7.0.1/src/MD5_std.h (-3 / +8 lines)
13	#include "arch.h"	13	#include "arch.h"
14	#include "common.h"	14	#include "common.h"
15		15
		16	#define MD5_TYPE_STD 0
		17	#define MD5_TYPE_APACHE 1
		18
16	typedef ARCH_WORD_32 MD5_word;	19	typedef ARCH_WORD_32 MD5_word;
17		20
18	/*	21	/*
Lines 88-93 Link Here
88	#define MD5_ALGORITHM_NAME "32/" ARCH_BITS_STR	91	#define MD5_ALGORITHM_NAME "32/" ARCH_BITS_STR
89	#endif	92	#endif
90		93
		94	#define MD5_MAGIC_LENGTH 10
		95
91	/*	96	/*
92	* Initializes the internal structures.	97	* Initializes the internal structures.
93	*/	98	*/
Lines 107-122 Link Here
107	/*	112	/*
108	* Main encryption routine, sets MD5_out.	113	* Main encryption routine, sets MD5_out.
109	*/	114	*/
110	extern void MD5_std_crypt(void);	115	extern void MD5_std_crypt(int md5_type);
111		116
112	/*	117	/*
113	* Returns the salt for MD5_std_set_salt().	118	* Returns the salt for MD5_std_set_salt().
114	*/	119	*/
115	extern char MD5_std_get_salt(char ciphertext);	120	extern char MD5_std_get_salt(char ciphertext, int md5_type);
116		121
117	/*	122	/*
118	* Converts an ASCII ciphertext to binary.	123	* Converts an ASCII ciphertext to binary.
119	*/	124	*/
120	extern MD5_word MD5_std_get_binary(char ciphertext);	125	extern MD5_word MD5_std_get_binary(char ciphertext, int md5_type);
121		126
122	#endif	127	#endif




////////////////////////////////////////////////////////////////
// MySQL password cracker - v1.0 - 16.1.2003
//
//    by Andrew Hintz <http://guh.nu> drew@overt.org
//  
//    This production has been brought to you by
//    4tphi <http://4tphi.net> and violating <http://violating.us>
//
// This file is an add-on to John the Ripper <http://www.openwall.com/john/> 
//
// Part of this code is based on the MySQL brute password cracker
//   mysqlpassword.c by Chris Given
// This program executes about 75% faster than mysqlpassword.c
// John the ripper also performs sophisticated password guessing.
//
// John the Ripper will expect the MySQL password file to be
// in the following format (without the leading // ):
// dumb_user:5d2e19393cc5ef67
// another_luser:28ff8d49159ffbaf
//
// performance enhancements by bartavelle@bandecon.com

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// johntr includes
#include "arch.h"
#include "misc.h"
#include "formats.h"
#include "common.h"

//johntr defines
#define FORMAT_LABEL "mysql"
#define FORMAT_NAME "mysql"
#define ALGORITHM_NAME "mysql"

#define BENCHMARK_COMMENT ""
#define BENCHMARK_LENGTH -1

// Increase the PLAINTEXT_LENGTH value for longer passwords.
// You can also set it to 8 when using MySQL systems that truncate 
//  the password to only 8 characters.
#define PLAINTEXT_LENGTH 32

#define CIPHERTEXT_LENGTH 16

#define BINARY_SIZE 16
#define SALT_SIZE 0

#define MIN_KEYS_PER_CRYPT 1
#define MAX_KEYS_PER_CRYPT 1


//used for mysql scramble function
struct rand_struct {
  unsigned long seed1,seed2,max_value;
  double max_value_dbl;
};


void make_scrambled_password(char *,const char *);
char *scramble(char *,const char *,const char *, int);

//test cases
static struct fmt_tests mysql_tests[] = {
  {"30f098972cc8924d", "http://guh.nu"},
  {"3fc56f6037218993", "Andrew Hintz"},
  {"697a7de87c5390b2", "drew"},
  {"1eb71cf460712b3e", "http://4tphi.net"},
  {"28ff8d49159ffbaf", "http://violating.us"},
  {"5d2e19393cc5ef67", "password"},
  {NULL}
};


//stores the ciphertext for value currently being tested
static char crypt_key[BINARY_SIZE+1];

//used by set_key
static char saved_key[PLAINTEXT_LENGTH + 1];

static int mysql_valid(char *ciphertext) { //returns 0 for invalid ciphertexts

  int i; //used as counter in loop
  
  //ciphertext is 16 characters
  if (strlen(ciphertext) != 16) return 0;  

  //ciphertext is ASCII representation of hex digits
  for (i = 0; i < 16; i++){
    if (!(  ((48 <= ciphertext[i])&&(ciphertext[i] <= 57)) ||
	    ((97 <= ciphertext[i])&&(ciphertext[i] <= 102))  ))
      return 0;
  }

  return 1;
}

static void mysql_set_salt(void *salt) { }

static void mysql_set_key(char *key, int index) {
  strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
}

static char *mysql_get_key(int index) {
    return saved_key;
}

static int mysql_cmp_all(void *binary, int index) { //also is mysql_cmp_one
	int i = 0;
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
	return 1;
}

static int mysql_cmp_exact(char *source, int count){
  return (1); //  mysql_cmp_all fallthrough?
}

static void mysql_crypt_all(int count) {  
  // get plaintext input in saved_key put it into ciphertext crypt_key
  make_scrambled_password(crypt_key,saved_key);
}

////////////////////////////////////////////////////////////////
//begin mysql code
// This code was copied from mysqlpassword.c by Chris Given
// He probably copied it from password.c in the MySQL source
// The code is GPLed

void randominit(struct rand_struct *rand_st,unsigned long seed1, unsigned long seed2) {
  rand_st->max_value= 0x3FFFFFFFL;
  rand_st->max_value_dbl=(double) rand_st->max_value;
  rand_st->seed1=seed1%rand_st->max_value ;
  rand_st->seed2=seed2%rand_st->max_value;
}
static void old_randominit(struct rand_struct *rand_st,unsigned long seed1) {
  rand_st->max_value= 0x01FFFFFFL;
  rand_st->max_value_dbl=(double) rand_st->max_value;
  seed1%=rand_st->max_value;
  rand_st->seed1=seed1 ; rand_st->seed2=seed1/2;
}
double rnd(struct rand_struct *rand_st) {
  rand_st->seed1=(rand_st->seed1*3+rand_st->seed2) %
    rand_st->max_value;
  rand_st->seed2=(rand_st->seed1+rand_st->seed2+33) %
    rand_st->max_value;
  return(((double) rand_st->seed1)/rand_st->max_value_dbl);
}
void hash_password(unsigned long *result, const char *password) {
  unsigned long nr=1345345333L, add=7, nr2=0x12345671L;
  unsigned long tmp;
  for (; *password ; password++) {
    if (*password == ' ' || *password == '\t')
      continue;
    //tmp= (unsigned long) (unsigned char) *password;
    tmp= (unsigned long) (*password & 0xFF);
    nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
    nr2+=(nr2 << 8) ^ nr;
    add+=tmp;
  }
  result[0]=nr & (((unsigned long) 1L << 31) -1L); /* Don't use sign bit
					      (str2int) */;
  result[1]=nr2 & (((unsigned long) 1L << 31) -1L);
  return;
}
void make_scrambled_password(char *to,const char *password) {
  unsigned long hash_res[2];
  hash_password(hash_res,password);
  sprintf(to,"%08lx%08lx",hash_res[0],hash_res[1]);
}
static inline unsigned int char_val(char X) {
  return (unsigned int) (X >= '0' && X <= '9' ? X-'0' : X >= 'A' && X <= 'Z' ?
		 X-'A'+10 : X-'a'+10);
}
char *scramble(char *to,const char *message,const char *password, int
	       old_ver) {
  struct rand_struct rand_st;
  unsigned long hash_pass[2],hash_message[2];
  if(password && password[0]) {
    char *to_start=to;
    hash_password(hash_pass,password);
    hash_password(hash_message,message);
    if (old_ver)
      old_randominit(&rand_st,hash_pass[0] ^
		     hash_message[0]);
    else
      randominit(&rand_st,hash_pass[0] ^ hash_message[0],
		 hash_pass[1] ^ hash_message[1]);
    while (*message++)
      *to++= (char) (floor(rnd(&rand_st)*31)+64);
    if (!old_ver) {
      char extra=(char) (floor(rnd(&rand_st)*31));
      while(to_start != to)
        *(to_start++)^=extra;
    }
  }
  *to=0;
  return to;
}

//end mysql code
////////////////////////////////////////////////////////////////

struct fmt_main fmt_MYSQL = {
  {
    FORMAT_LABEL,
    FORMAT_NAME,
    ALGORITHM_NAME,
    BENCHMARK_COMMENT,
    BENCHMARK_LENGTH,
    PLAINTEXT_LENGTH,
    BINARY_SIZE,
    SALT_SIZE,
    MIN_KEYS_PER_CRYPT,
    MAX_KEYS_PER_CRYPT,
    FMT_CASE | FMT_8_BIT,
    mysql_tests
    }, {
      fmt_default_init,
      mysql_valid, 
      fmt_default_split,
      fmt_default_binary,
      fmt_default_salt,
      {
	fmt_default_binary_hash,
	fmt_default_binary_hash,
	fmt_default_binary_hash
      },
      fmt_default_salt_hash,
      mysql_set_salt,
      mysql_set_key,
      mysql_get_key,
      fmt_default_clear_keys,
      mysql_crypt_all,
      {
	fmt_default_get_hash,
	fmt_default_get_hash,
	fmt_default_get_hash
      },
      mysql_cmp_all,
      mysql_cmp_all, //should it be the same as cmp_all or same as cmp_exact?
      mysql_cmp_exact //fallthrough
    }
};




LDFLAGS = -s
OPT_NORMAL = -funroll-loops
OPT_INLINE = -finline-functions
LIBS =

JOHN_OBJS_MINIMAL = \
	DES_fmt.o DES_std.o DES_bs.o \

	BF_fmt.o BF_std.o \
	AFS_fmt.o \
	LM_fmt.o \
	des.o \
	MD5_apache_fmt.o \
	BFEgg_fmt.o \
	lotus5_fmt.o \
	md5.o \
	NSLDAP_fmt.o sha1.o base64.o \
	MYSQL_fmt.o \
	NT_fmt.o \
	md4.o smbencrypt.o \
	rawMD5_fmt.o \
	rawSHA1_fmt.o \
	mssql_fmt.o \
	hmacMD5_fmt.o \
	WPAPSK_fmt.o \
	mscash_fmt.o \
	oracle_fmt.o \
	batch.o bench.o charset.o common.o compiler.o config.o cracker.o \
	crc32.o external.o formats.o getopt.o idle.o inc.o john.o list.o \
	loader.o logger.o math.o memory.o misc.o options.o params.o path.o \
	recovery.o rpp.o rules.o signals.o single.o status.o tty.o wordlist.o \
	unshadow.o \
	unafs.o \
	undrop.o \
	unique.o

JOHN_OBJS_ORIG = \

	bench.o best.o common.o config.o formats.o math.o memory.o miscnl.o \
	params.o path.o signals.o tty.o

PROJ = ../run/john ../run/unshadow ../run/unafs ../run/unique ../run/undrop
PROJ_DOS = ../run/john.bin ../run/john.com \
	../run/unshadow.com ../run/unafs.com ../run/unique.com ../run/undrop.com
PROJ_WIN32 = ../run/john.exe \
	../run/unshadow.exe ../run/unafs.exe ../run/unique.exe ../run/undrop.exe

default:
	@echo "To build John the Ripper, type:"
	@echo "	make clean SYSTEM"
	@echo "where SYSTEM can be one of the following:"
	@echo "linux-x86-mmx            Linux, x86 with MMX (best)"
	@echo "linux-x86-sse2            Linux, x86 with SSE2, ELF binaries"
	@echo "linux-x86-any            Linux, x86"
	@echo "linux-x86-any-a.out      Linux, x86, a.out binaries (obsolete)"
	@echo "linux-x86-64             Linux, AMD x86-64, 64-bit native"

	@echo "dos-djgpp-x86-mmx        DOS, DJGPP 2.x, x86 with MMX (best)"
	@echo "dos-djgpp-x86-any        DOS, DJGPP 2.x, x86"
	@echo "win32-cygwin-x86-mmx     Win32, Cygwin, x86 with MMX (best)"
	@echo "win32-cygwin-x86-sse2     Win32, Cygwin, x86 with SSE2"
	@echo "win32-cygwin-x86-any     Win32, Cygwin, x86"
	@echo "beos-x86-mmx             BeOS, x86 with MMX"
	@echo "beos-x86-any             BeOS, x86"

linux-x86-mmx:
	$(LN) x86-mmx.h arch.h
	$(MAKE) $(PROJ) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o md5-mmx.o sha1-mmx.o"

linux-x86-sse2:
	$(LN) x86-sse2.h arch.h
	$(MAKE) $(PROJ) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-sse2.o NTmmx_fmt.o md5-mmx.o sha1-mmx.o"

linux-x86-any:
	$(LN) x86-any.h arch.h

linux-x86-64-mmx:
	$(LN) x86-mmx.h arch.h
	$(MAKE) $(PROJ) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
		CFLAGS="$(CFLAGS) -m32" \
		ASFLAGS="$(ASFLAGS) -m32" \
		LDFLAGS="$(LDFLAGS) -m32"

openbsd-x86-mmx:
	$(LN) x86-mmx.h arch.h
	$(MAKE) $(PROJ) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
		ASFLAGS="$(ASFLAGS) -DBSD"

openbsd-x86-any:

dos-djgpp-x86-mmx:
	copy x86-mmx.h arch.h
	$(MAKE) $(PROJ_DOS) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
		CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
		ASFLAGS="$(ASFLAGS) -DUNDERSCORES -DALIGN_LOG"


win32-cygwin-x86-mmx:
	$(CP) x86-mmx.h arch.h
	$(MAKE) $(PROJ_WIN32) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o md5_mmx.o sha1-mmx.o" \
		CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
		ASFLAGS="$(ASFLAGS) -DUNDERSCORES"

win32-cygwin-x86-sse2:
	$(CP) x86-sse2.h arch.h
	$(MAKE) $(PROJ_WIN32) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-sse2.o NTmmx_fmt.o md5_mmx.o sha1-mmx.o" \
		CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
		ASFLAGS="$(ASFLAGS) -DUNDERSCORES"


beos-x86-mmx:
	$(LN) x86-mmx.h arch.h
	$(MAKE) $(PROJ) \
		JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o"

beos-x86-any:
	$(LN) x86-any.h arch.h

	$(LD) $(LDFLAGS) $(BENCH_OBJS) -o bench

../run/john: $(JOHN_OBJS)
	$(LD) $(LDFLAGS) $(JOHN_OBJS) -o ../run/john ${LIBS}

../run/unshadow: ../run/john
	$(RM) ../run/unshadow

	$(RM) ../run/unafs
	ln -s john ../run/unafs

../run/undrop: ../run/john
	$(RM) ../run/undrop
	ln -s john ../run/undrop

../run/unique: ../run/john
	$(RM) ../run/unique
	ln -s john ../run/unique

../run/unafs.com: john.com
	copy john.com ..\run\unafs.com

../run/undrop.com: john.com
	copy john.com ..\run\undrop.com

../run/unique.com: john.com
	copy john.com ..\run\unique.com


	$(CC) symlink.c -o ../run/unafs.exe
	strip ../run/unafs.exe

../run/undrop.exe: symlink.c
	$(CC) symlink.c -o ../run/undrop.exe
	strip ../run/undrop.exe

../run/unique.exe: symlink.c
	$(CC) symlink.c -o ../run/unique.exe
	strip ../run/unique.exe




// Fix for john the ripper 1.6.37 by Sun-Zero, 2004. 07. 26.
/*
 * This file is part of John the Ripper password cracker,
 * Copyright (c) 1996-98 by Solar Designer
 *
 * Minor performance enhancement by bartavelle@bandecon.com
 */

#include <string.h>

#include "misc.h"
#include "formats.h"
#include "common.h"

#include "sha.h"
#include "base64.h"

#define FORMAT_LABEL			"nsldap"
#define FORMAT_NAME			"Netscape LDAP SHA"
#define SHA_TYPE                        "SHA1"

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32
#define CIPHERTEXT_LENGTH		33

#define BINARY_SIZE			20
#define SALT_SIZE			0

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + (3-((i)&3)) )
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

#define NSLDAP_MAGIC "{sha}"
#define NSLDAP_MAGIC_LENGTH 5

static struct fmt_tests tests[] = {
  {"{SHA}cMiB1KJphN3OeV9vcYF8nPRIDnk=", "aaaa"},  
  {"{SHA}iu0TIuVFC62weOH7YKgXod8loso=", "bbbb"},  
  {"{SHA}0ijZPTcJXMa+t2XnEbEwSOkvQu0=", "ccccccccc"},  
  {"{SHA}vNR9eUfJfcKmdkLDqNoKagho+qU=", "dddddddddd"},  
  {NULL}
};

#ifdef MMX_COEF
static char crypt_key[BINARY_SIZE*MMX_COEF];
static char saved_key[(PLAINTEXT_LENGTH+1)*MMX_COEF];
unsigned long total_len;
unsigned char buffer[80*4*MMX_COEF] __attribute__ ((aligned(8*MMX_COEF)));
unsigned char out[PLAINTEXT_LENGTH];
#else
static char crypt_key[BINARY_SIZE];
static char saved_key[PLAINTEXT_LENGTH + 1];
#endif

static void *
binary(char *ciphertext) {
  static char realcipher[BINARY_SIZE + 9];

  /* stupid overflows */
  memset(realcipher, 0, BINARY_SIZE + 9);
  base64_decode(NSLDAP_MAGIC_LENGTH+ciphertext, CIPHERTEXT_LENGTH, realcipher);
  return (void *)realcipher;
}

static int 
valid(char *ciphertext)
{
  if(ciphertext && strlen(ciphertext) == CIPHERTEXT_LENGTH)
    return !strncasecmp(ciphertext, NSLDAP_MAGIC, NSLDAP_MAGIC_LENGTH);
  return 0;
}

static int binary_hash_0(void *binary)
{
  return ((int *)binary)[0] & 0xF;
}

static int binary_hash_1(void *binary)
{
  return ((int *)binary)[0] & 0xFF;
}

static int binary_hash_2(void *binary)
{
  return ((int *)binary)[0] & 0xFFF;
}

static int get_hash_0(int index)
{
  return ((int *)crypt_key)[index] & 0xF;
}

static int get_hash_1(int index)
{
  return ((int *)crypt_key)[index] & 0xFF;
}

static int get_hash_2(int index)
{
  return ((int *)crypt_key)[index] & 0xFFF;
}

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, PLAINTEXT_LENGTH*MMX_COEF);
	}
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

	total_len += len << ( ( (32/MMX_COEF) * index ) );
	for(i=0;i<len;i++)
		saved_key[GETPOS(i, index)] = key[i];

	saved_key[GETPOS(i, index)] = 0x80;
#else
  strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
#endif
}

static char *get_key(int index)
{
#ifdef MMX_COEF
	unsigned int i,s;
	
	s = (total_len >> (((32/MMX_COEF)*(index)))) & 0xff;
	for(i=0;i<s;i++)
		out[i] = saved_key[ GETPOS(i, index) ];
	out[i] = 0;
	return out;
#else
  return saved_key;
#endif
}

static int 
cmp_all(void *binary, int index)
{
	int i = 0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int 
cmp_exact(char *source, int index)
{
  return 1;
}

static int cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return cmp_all(binary, index);
#endif
}

static void set_salt(void *salt) {
}

static void
crypt_all(int count) {  
#ifdef MMX_COEF
	memcpy(buffer, saved_key, 32*MMX_COEF);
	shammx(crypt_key, buffer, total_len);
#else
  static SHA_CTX ctx;
  SHA1_Init(&ctx);
  SHA1_Update(&ctx, saved_key, strlen(saved_key));
  SHA1_Final(crypt_key, &ctx);
#endif
}

struct fmt_main fmt_NSLDAP = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		SHA_TYPE,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		binary,
		fmt_default_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		fmt_default_salt_hash,
		set_salt,
		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all, 
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		cmp_all,
		cmp_one,
		cmp_exact
	}
};





/*
 * NTLM patch for john version 0.3
 *
 * (C) 2001 Olle Segerdahl <olle@nxs.se>
 *
 * license: GPL <http://www.gnu.org/licenses/gpl.html>
 *
 * This file is based on code from John the Ripper,
 * Copyright (c) 1996-99 by Solar Designer
 *
 * performance enhancements by bartavelle@bandecon.com
 */

#include <string.h>

#include "arch.h"
#include "memory.h"
#include "common.h"
#include "formats.h"

#ifndef uchar
#define uchar unsigned char
#endif

#define FORMAT_LABEL			"nt"
#define FORMAT_NAME			"NT MD4"

#define BENCHMARK_COMMENT		""
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		54
#define CIPHERTEXT_LENGTH		36


static struct fmt_tests tests[] = {
	{"$NT$b7e4b9022cd45f275334bbdb83bb5be5", "John the Ripper"},
	{"$NT$8846f7eaee8fb117ad06bdd830b7586c", "password"},
	{"$NT$0cb6948805f797bf2a82807973b89537", "test"},
	{"$NT$31d6cfe0d16ae931b73c59d7e0c089c0", ""},
	{NULL}
};

#define ALGORITHM_NAME			"TridgeMD4"

#define BINARY_SIZE			16
#define SALT_SIZE			0

#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1

uchar saved_plain[PLAINTEXT_LENGTH + 1];
uchar output[BINARY_SIZE + 1];

extern void E_md4hash(uchar *passwd, uchar *p16);


static int valid(char *ciphertext)
{
        char *pos;

	if (strncmp(ciphertext, "$NT$", 4)!=0) return 0;

        for (pos = &ciphertext[4]; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);

        if (!*pos && pos - ciphertext == CIPHERTEXT_LENGTH)
		return 1;
        else
        	return 0;

}

static void *get_binary(char *ciphertext)
{
	static uchar binary[BINARY_SIZE];
	int i;

	ciphertext+=4;
	for (i=0; i<BINARY_SIZE; i++)
	{
 		binary[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])])<<4;
 		binary[i] |= (atoi16[ARCH_INDEX(ciphertext[i*2+1])]);
	}

	return binary;
}

static int binary_hash_0(void *binary)
{
	return ((uchar *)binary)[0] & 0x0F;
}

static int binary_hash_1(void *binary)
{
	return ((uchar *)binary)[0];
}

static int binary_hash_2(void *binary)
{
	return (((uchar *)binary)[0] << 4) + (((uchar *)binary)[1] & 0x0F);
}

static int get_hash_0(int index)
{
	return output[0] & 0x0F;
}

static int get_hash_1(int index)
{
	return output[0];
}

static int get_hash_2(int index)
{
	return (output[0] << 4) + (output[1] & 0x0F);
}

static void crypt_all(int count)
{
	E_md4hash(saved_plain, output);
}

static int cmp_all(void *binary, int count)
{
	int i = 0;
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)output)[i])
			return 0;
		i++;
	}
	return 1;
}

static int cmp_exact(char *source, int index)
{
	return !memcmp(output, get_binary(source), index);
}

static void set_salt(void *salt)
{
}

static void set_key(char *key, int index)
{
	strncpy(saved_plain, key, PLAINTEXT_LENGTH);
	saved_plain[PLAINTEXT_LENGTH] = 0;
}

static char *get_key(int index)
{
	return saved_plain;
}

struct fmt_main fmt_NT = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		get_binary,
		fmt_default_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		fmt_default_salt_hash,
		set_salt,
		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all,
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		cmp_all,
		cmp_all,
		cmp_exact
	}
};




/*
 * NTLM patch for john version 0.3
 *
 * (C) 2001 Olle Segerdahl <olle@nxs.se>
 *
 * license: GPL <http://www.gnu.org/licenses/gpl.html>
 *
 * This file is based on code from John the Ripper,
 * Copyright (c) 1996-99 by Solar Designer
 *
 * performance enhancements by bartavelle@bandecon.com
 */

#include <string.h>

#include "arch.h"
#include "memory.h"
#include "common.h"
#include "formats.h"
#include "md4.h"

#ifndef uchar
#define uchar unsigned char
#endif

#define FORMAT_LABEL			"ntmmx"
#define FORMAT_NAME			"NT MD4 MMX"

#define BENCHMARK_COMMENT		MMX_TYPE
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32
#define CIPHERTEXT_LENGTH		36


static struct fmt_tests tests[] = {
	{"$NT$b7e4b9022cd45f275334bbdb83bb5be5", "John the Ripper"},
	{"$NT$8846f7eaee8fb117ad06bdd830b7586c", "password"},
	{"$NT$0cb6948805f797bf2a82807973b89537", "test"},
	{"$NT$31d6cfe0d16ae931b73c59d7e0c089c0", ""},
	{NULL}
};

#define ALGORITHM_NAME			"bartavelle"

#define BINARY_SIZE			16
#define SALT_SIZE			0


#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF

#define GETPOS(i,idx)	( ((i)&0xfffe)*MMX_COEF + ((i)&1) + ((idx)<<1) )

//uchar saved_plain[PLAINTEXT_LENGTH + 1];

static unsigned char saved_plain[64 * MMX_COEF] __attribute__ ((aligned(32)));
/*static unsigned char tmpbuf[64 * MMX_COEF] __attribute__ ((aligned(32)));*/
static unsigned char output[BINARY_SIZE*MMX_COEF + 1] __attribute__ ((aligned(32)));
static unsigned char out[32];
static unsigned long total_len;
/*static int global_watch = 0;*/

static int valid(char *ciphertext)
{
        char *pos;

	if (strncmp(ciphertext, "$NT$", 4)!=0) return 0;

        for (pos = &ciphertext[4]; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);

        if (!*pos && pos - ciphertext == CIPHERTEXT_LENGTH)
		return 1;
        else
        	return 0;

}

static void *get_binary(char *ciphertext)
{
	static uchar binary[BINARY_SIZE];
	int i;

	ciphertext+=4;
	for (i=0; i<BINARY_SIZE; i++)
	{
 		binary[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])])<<4;
 		binary[i] |= (atoi16[ARCH_INDEX(ciphertext[i*2+1])]);
	}

	return binary;
}

static int binary_hash_0(void *binary)
{
	return ((uchar *)binary)[0] & 0x0F;
}

static int binary_hash_1(void *binary)
{
	return ((uchar *)binary)[0];
}

static int binary_hash_2(void *binary)
{
	return (((uchar *)binary)[0] << 4) + (((uchar *)binary)[1] & 0x0F);
}

static int get_hash_0(int index)
{
	return output[index*4] & 0x0F;
}

static int get_hash_1(int index)
{
	return output[index*4];
}

static int get_hash_2(int index)
{
	return (output[index*4] << 4) + (output[index*4+1] & 0x0F);
}

static void crypt_all(int count)
{
#if (MMX_COEF == 2)
        mdfourmmx(output, saved_plain, total_len);
#endif
#if (MMX_COEF == 4)
        mdfoursse2(output, saved_plain, total_len);
#endif
}

static int cmp_all(void *binary, int count)
{
	int i = 0;

	while(i<(BINARY_SIZE/4))
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)output)[i*MMX_COEF])
#if (MMX_COEF > 1 )
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)output)[i*MMX_COEF+1])
#endif
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)output)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)output)[i*MMX_COEF+3])
#endif	

		)
			return 0;
		i++;
	}
	return 1;
}

static int cmp_one(void * binary, int index)
{
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)output)[i*MMX_COEF+index] )
			return 0;
	return 1;
}

static int cmp_exact(char *source, int index)
{
	return 1;
}

static void set_salt(void *salt)
{
}

static void set_key(char *key, int index)
{
	int len;
	int i;

	if(index==0)
	{
		total_len = 0;
		memset(saved_plain, 0, 64*MMX_COEF);
	}
	len = strlen(key);
	if(len > 32)
                len = 32;

	total_len += len << (1 + ( (32/MMX_COEF) * index ) );

	for(i=0;i<len;i++)
		((unsigned short *)saved_plain)[ GETPOS(i, index) ] = key[i] ;
	((unsigned short *)saved_plain)[ GETPOS(i, index) ] = 0x80;
}

static char *get_key(int index)
{
	unsigned int s, i;

#if (MMX_COEF == 4)
	s = (total_len >> (1+((32/MMX_COEF)*(index)))) & 0xff;
#else
	if(index == 0)
		s = (total_len & 0xffff) >> 1 ;
	else
		s = total_len >> 17;
#endif
	for(i=0;i<s;i++)
		out[i] = ((unsigned short *)saved_plain)[ GETPOS(i, index) ];
	out[i]=0;
	return out;
}

struct fmt_main fmt_NTmmx = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		get_binary,
		fmt_default_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		fmt_default_salt_hash,
		set_salt,
		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all,
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		cmp_all,
		cmp_one,
		cmp_exact
	}
};




/*
 * Copyright (c) 2004 bartavelle
 * bartavelle@bandecon.com
 *
 * Simple MD5 hashes cracker
 * It uses the Solar Designer's md5 implementation
 * 
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "md5.h"
#include "sha.h"

#define FORMAT_LABEL			"wpapsk"
#define FORMAT_NAME			"WPA PSK"
#ifdef MMX_COEF
#if (MMX_COEF == 2)
#define ALGORITHM_NAME			"wpa-psk MMX"
#else
#define ALGORITHM_NAME			"pwa-psk SSE2"
#endif
#else
#define ALGORITHM_NAME			"wpa-psk"
#endif

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		60
#define CIPHERTEXT_LENGTH		(128+400)

#define BINARY_SIZE			16
#define SHA_SIZE			20
#define SALT_SIZE			64

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
#define GETPOS(i, index)		( (index)*4 + ((i)& (0xffffffff-3) )*MMX_COEF + (((i)&3)) )
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

// format : essid#MIC AA SPA snonce anonce keymic eapolframe
static struct fmt_tests wpapsk_tests[] = {
	{"somethingclever#c016873ee6bb01499d77bde7c5e7a4be 00026f01b8fb000c413f313e289f35c24325dda9e773a11cd0416a880622c3589a37886e318120a7e0ad68dd8a4b70c7b368bac5b4476a9e6071270d1d5734e484cf09ddd3f29966e20136de 0103005ffe010900200000000000000001289f35c24325dda9e773a11cd0416a880622c3589a37886e318120a7e0ad68dd", "family movie night"},
	{NULL}
};

#ifdef MMX_COEF
//static char saved_key[PLAINTEXT_LENGTH*MMX_COEF*2 + 1] __attribute__ ((aligned(16)));
static char crypt_key[64*MMX_COEF] __attribute__ ((aligned(16)));
unsigned long total_len;
unsigned char opad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char ipad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char cursalt[SALT_SIZE*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char dump[80*4*MMX_COEF] __attribute__((aligned(16)));
#else
//static char saved_key[PLAINTEXT_LENGTH + 1];
static char crypt_key[BINARY_SIZE+1];
static SHA_CTX ctx;
unsigned char opad[64];
unsigned char ipad[64];
unsigned char nopad[64];
unsigned char nipad[64];
unsigned char cursalt[SALT_SIZE];
unsigned char dump[SHA_SIZE];
#endif
unsigned char out[PLAINTEXT_LENGTH];

unsigned char DATA[12+64];
unsigned char nDATA[12+64+23+1];
unsigned char EAPOL[99];

static void wpapsk_init(void)
{
#ifdef MMX_COEF
	memset(crypt_key, 0, 64*MMX_COEF);
	memset(cursalt, 0, 64*MMX_COEF);
	crypt_key[GETPOS(BINARY_SIZE,0)] = 0x80;
	crypt_key[GETPOS(BINARY_SIZE,1)] = 0x80;
#if (MMX_COEF == 4)
	crypt_key[GETPOS(BINARY_SIZE,2)] = 0x80;
	crypt_key[GETPOS(BINARY_SIZE,3)] = 0x80;
#endif
#else
	memset(nipad, 0x36, 64);
	memset(nopad, 0x5C, 64);
	memset(EAPOL, 0, sizeof(EAPOL));
	strcpy(nDATA, "Pairwise key expansion");
#endif
}

static int valid(char *ciphertext)
{
	int pos, i;

	for(i=0;(i<strlen(ciphertext)) && (ciphertext[i]!='#');i++) ;
	if(i==strlen(ciphertext))
		return 0;
	pos = i+1;
	for (i = pos; i < BINARY_SIZE*2+pos; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	return 1;
}

static void wpapsk_set_salt(void *salt) 
{
#ifdef MMX_COEF
	total_len = 0;
	while( ((unsigned char *)salt)[total_len] )
	{
		cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
#if (MMX_COEF == 4)
		cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
#endif
		total_len ++;
	}
	while( ((unsigned char *)salt)[total_len-4] )
	{
		cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
#if (MMX_COEF == 4)
		cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
#endif
		total_len ++;
	}

	cursalt[GETPOS(total_len, 0)] = 0x80;
	cursalt[GETPOS(total_len, 1)] = 0x80;
#if (MMX_COEF == 4)
	cursalt[GETPOS(total_len, 2)] = 0x80;
	cursalt[GETPOS(total_len, 3)] = 0x80;
#endif
#else
	memcpy(cursalt, salt, SALT_SIZE);
#endif
}

static void wpapsk_set_key(char *key, int index) {
	int i;
	int len;
	
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

#ifdef MMX_COEF
	if(index==0)
	{
		memset(ipad, 0x36, 64*MMX_COEF);
		memset(opad, 0x5C, 64*MMX_COEF);
	}
	
	for(i=0;i<len;i++)
	{
		ipad[GETPOS(i, index)] = 0x36 ^ key[i];
		opad[GETPOS(i, index)] = 0x5C ^ key[i];
	}

	//saved_key[GETPOS(i, index)] = 0x80;
#else
	memset(ipad, 0x36, 64);
	memset(opad, 0x5C, 64);
	for(i=0;i<len;i++)
	{
		ipad[i] ^= key[i];
		opad[i] ^= key[i];
	}
#endif
}

static char *wpapsk_get_key(int index) {
	unsigned int i;
	for(i=0;i<PLAINTEXT_LENGTH;i++)
#ifdef MMX_COEF
		out[i] = ipad[ GETPOS(i, index) ] ^ 0x36;
#else
		out[i] = ipad[ i ] ^ 0x36;
#endif
	return out;
}

static int wpapsk_cmp_all(void *binary, int index) { 
	int i=0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int wpapsk_cmp_exact(char *source, int count){
  return (1);
}

static int wpapsk_cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return wpapsk_cmp_all(binary, index);
#endif
}

/*
 * ça ne marche pas et ça m'a gonflé
 */

static void wpapsk_crypt_all(int count) {  
#ifdef MMX_COEF
	/*int i;*/
	printf("\n");
	dump_stuff_mmx(ipad, 64, 0);
	memcpy(dump, ipad, 64*MMX_COEF);
	shammx_nosizeupdate( dump, dump, 64);

	memcpy(dump, cursalt, 64*MMX_COEF);
	shammx_noinit_uniformsizeupdate(dump, dump, total_len + 64 );
	dump_stuff_mmx(dump, SHA_SIZE, 0);

	shammx_nosizeupdate( dump, opad, 64);
	shammx_noinit_uniformsizeupdate(dump, dump, SHA_SIZE + 64);
	dump_stuff_mmx(dump, SHA_SIZE, 0);

	return;
#else
	unsigned char dump[SHA_SIZE];
	unsigned char digest[SHA_SIZE];
	unsigned char ptk[20*4];
	unsigned int i,j;
	MD5_CTX md5ctx;
	
	//printf("\n");
	//first calculation - left part
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, ipad, 64 );
	SHA1_Update( &ctx, cursalt, strlen(cursalt) + 4 );
	SHA1_Final( dump, &ctx);
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, opad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( dump, &ctx);
	memcpy(digest, dump, SHA_SIZE);
	for(i=1;i<4096;i++)
	{
		SHA1_Init( &ctx );
		SHA1_Update( &ctx, ipad, 64 );
		SHA1_Update( &ctx, dump, SHA_SIZE );
		SHA1_Final( dump, &ctx);
		SHA1_Init( &ctx );
		SHA1_Update( &ctx, opad, 64 );
		SHA1_Update( &ctx, dump, SHA_SIZE);
		SHA1_Final( dump, &ctx);
		for(j=0;j<SHA_SIZE;j++)
			digest[j] ^= dump[j];
	}
	//first calculation - right part
	cursalt[ strlen(cursalt) + 3 ] = 2;
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, ipad, 64 );
	SHA1_Update( &ctx, cursalt, strlen(cursalt) + 4 );
	SHA1_Final( dump, &ctx);
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, opad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( dump, &ctx);
	memcpy(digest+SHA_SIZE, dump, 32-SHA_SIZE);
	for(i=1;i<4096;i++)
	{
		SHA1_Init( &ctx );
		SHA1_Update( &ctx, ipad, 64 );
		SHA1_Update( &ctx, dump, SHA_SIZE );
		SHA1_Final( dump, &ctx);
		SHA1_Init( &ctx );
		SHA1_Update( &ctx, opad, 64 );
		SHA1_Update( &ctx, dump, SHA_SIZE);
		SHA1_Final( dump, &ctx);
		for(j=0;j<32-SHA_SIZE;j++)
			digest[j+SHA_SIZE] ^= dump[j];
	}
	//we now got pmk in digest,32
	//dump_stuff(digest, 32 );
	for(i=0;i<32;i++)
	{
		nipad[i] = 0x36 ^ digest[i];
		nopad[i] = 0x5c ^ digest[i];
	}
	//a hmac must be done with secret key pmk/32, and text "Pairwise key expansion",0,DATA,counter
	nDATA[23+64+12] = 0;
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nipad, 64 );
	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
	SHA1_Final( dump, &ctx );
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nopad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( ptk, &ctx);

	//seems not to be used ...
	/*
	nDATA[23+64+12] = 1;
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nipad, 64 );
	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
	SHA1_Final( dump, &ctx );
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nopad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( ptk + 20, &ctx);

	nDATA[23+64+12] = 2;
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nipad, 64 );
	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
	SHA1_Final( dump, &ctx );
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nopad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( ptk + 40, &ctx);

	nDATA[23+64+12] = 3;
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nipad, 64 );
	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
	SHA1_Final( dump, &ctx );
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, nopad, 64 );
	SHA1_Update( &ctx, dump, SHA_SIZE);
	SHA1_Final( ptk + 60, &ctx);
	*/
	//we now have the ptk ...

	//now hmac md5 ...
	memset(nipad + 16, 0x36 , 16); 
	memset(nopad + 16, 0x5C , 16); 
	for(i=0;i<16;i++)
	{
		nipad[i] = 0x36 ^ ptk[i];
		nopad[i] = 0x5C ^ ptk[i];
	}
	MD5_Init( &md5ctx );
	MD5_Update( &md5ctx, nipad, 64 );
	MD5_Update( &md5ctx, EAPOL, sizeof(EAPOL) );
	MD5_Final ( dump, &md5ctx );
	MD5_Init( &md5ctx );
	MD5_Update( &md5ctx, nopad, 64 );
	MD5_Update( &md5ctx, dump, 16 );
	MD5_Final ( crypt_key, &md5ctx );
#endif
  
}

static void * wpapsk_binary(char *ciphertext) 
{
	static unsigned char realcipher[BINARY_SIZE];
	int i,pos;
	
	for(i=0;ciphertext[i]!='#';i++);
	pos=i+1;
	for(i=0;i<BINARY_SIZE;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+pos])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1+pos])];
	}
	pos += i*2+1;
	i=0;
	while(ciphertext[pos]!=' ')
	{
		DATA[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];
		i++;
		pos += 2;
	}
	memcpy(nDATA+23, DATA, 12+64);
	pos++;
	i=0;
	while(ciphertext[pos])
	{
		EAPOL[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];
		i++;
		pos += 2;
	}

	return (void *)realcipher;
}

static void * wpapsk_salt(char *ciphertext)
{
	static unsigned char salt[SALT_SIZE];
	memset(salt, 0, SALT_SIZE);
	int i=0;
	while(ciphertext[i]!='#')
	{
		salt[i] = ciphertext[i];
		i++;
	}
	salt[i]=0;
	salt[i+1]=0;
	salt[i+2]=0;
	salt[i+3]=1;
	return salt;
}

struct fmt_main fmt_WPAPSK = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		wpapsk_tests
	}, {
		wpapsk_init,
		valid,
		fmt_default_split,
		wpapsk_binary,
		wpapsk_salt,
		{
			fmt_default_binary_hash,
			fmt_default_binary_hash,
			fmt_default_binary_hash
		},
		fmt_default_salt_hash,
		wpapsk_set_salt,
		wpapsk_set_key,
		wpapsk_get_key,
		fmt_default_clear_keys,
		wpapsk_crypt_all,
		{
			fmt_default_get_hash,
			fmt_default_get_hash,
			fmt_default_get_hash
		},
		wpapsk_cmp_all,
		wpapsk_cmp_one,
		wpapsk_cmp_exact
	}
};

Lines 318-320 Link Here

(-)john-1.7.0.1/src/alpha.S (+3 lines)
318	.space 128	318	.space 128
319		319
320	.comm DES_KS_table, (8 * 128 * 16 * 8), 128	320	.comm DES_KS_table, (8 * 128 * 16 * 8), 128
		321	#ifdef __ELF__
		322	.section .note.GNU-stack,"",@progbits
		323	#endif





#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

void base64_unmap(char *in_block) {
  int i;
  unsigned char *c;
  
  for(i=0; i<4; i++) {
    c = in_block + i;
    
    if(*c>='A' && *c<='Z') {
      *c -= 'A';
      continue;
    }
    
    if(*c>='a' && *c<='z') {
      *c -= 'a';
      *c += 26;
      continue;
    }
    
    if(*c == '+') {
      *c = 62;
      continue;
    }
    
    if(*c == '/') {
      *c = 63;
      continue;
    }
    
    if(*c == '=') {
      *c = 0;
    }
    
    *c -= '0';
    *c += 52;
  }
}

int base64_decode(char *in, int inlen, char *out) {
  int i;
  char *in_block;
  char *out_block;
  char temp[4];

  out_block = out;
  in_block = in;

  for(i=0; i<inlen; i+=4) {

    if(*in_block == '=')
      return 0;

    memcpy(temp, in_block, 4);
    memset(out_block, 0, 3);
    base64_unmap(temp);

    out_block[0] = 
      ((temp[0]<<2) & 0xfc) | ((temp[1]>>4) & 3);
    out_block[1] = 
      ((temp[1]<<4) & 0xf0) | ((temp[2]>>2) & 0xf);
    out_block[2] = 
      ((temp[2]<<6) & 0xc0) | ((temp[3]   ) & 0x3f);

    out_block += 3;
    in_block += 4;
  }
  
  return 0;
}

Line 0 Link Here

(-)john-1.7.0.1/src/base64.h (+6 lines)
	1	#ifndef _BASE64_H
	2	#define _BASE64_H
	3
	4	int base64_decode(char in, int inlen, char out);
	5
	6	#endif




/* bf_tab.h: Blowfish P-box and S-box tables */
#ifndef _H_TAB_BF
#define _H_TAB_BF

static UWORD_32bits initbf_P[bf_N + 2] =
{
  0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
  0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
  0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
  0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
  0x9216d5d9, 0x8979fb1b,
};
static UWORD_32bits initbf_S[4][256] =
{
  {
    0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
    0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
    0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
    0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
    0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
    0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
    0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
    0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
    0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
    0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
    0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
    0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
    0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
    0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
    0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
    0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
    0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
    0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
    0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
    0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
    0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
    0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
    0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
    0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
    0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
    0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
    0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
    0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
    0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
    0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
    0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
    0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
    0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
    0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
    0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
    0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
    0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
    0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
    0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
    0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
    0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
    0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
    0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
    0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
    0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
    0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
    0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
    0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
    0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
    0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
    0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
    0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
    0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
    0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
    0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
    0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
    0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
    0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
    0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
    0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
    0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
    0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
    0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
    0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
  {
    0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
    0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
    0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
    0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
    0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
    0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
    0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
    0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
    0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
    0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
    0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
    0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
    0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
    0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
    0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
    0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
    0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
    0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
    0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
    0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
    0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
    0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
    0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
    0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
    0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
    0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
    0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
    0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
    0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
    0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
    0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
    0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
    0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
    0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
    0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
    0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
    0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
    0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
    0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
    0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
    0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
    0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
    0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
    0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
    0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
    0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
    0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
    0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
    0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
    0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
    0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
    0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
    0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
    0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
    0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
    0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
    0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
    0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
    0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
    0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
    0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
    0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
    0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
    0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
  {
    0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
    0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
    0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
    0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
    0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
    0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
    0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
    0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
    0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
    0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
    0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
    0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
    0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
    0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
    0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
    0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
    0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
    0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
    0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
    0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
    0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
    0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
    0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
    0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
    0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
    0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
    0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
    0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
    0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
    0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
    0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
    0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
    0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
    0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
    0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
    0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
    0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
    0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
    0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
    0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
    0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
    0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
    0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
    0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
    0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
    0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
    0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
    0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
    0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
    0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
    0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
    0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
    0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
    0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
    0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
    0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
    0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
    0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
    0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
    0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
    0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
    0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
    0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
    0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
  {
    0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
    0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
    0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
    0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
    0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
    0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
    0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
    0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
    0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
    0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
    0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
    0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
    0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
    0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
    0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
    0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
    0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
    0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
    0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
    0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
    0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
    0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
    0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
    0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
    0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
    0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
    0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
    0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
    0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
    0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
    0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
    0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
    0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
    0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
    0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
    0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
    0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
    0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
    0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
    0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
    0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
    0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
    0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
    0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
    0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
    0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
    0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
    0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
    0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
    0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
    0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
    0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
    0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
    0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
    0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
    0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
    0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
    0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
    0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
    0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
    0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
    0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
    0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
    0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
};

#endif




/* 
 * blowfish.c - part of blowfish.mod
 * handles: encryption and decryption of passwords
 */
/* 
 * The first half of this is very lightly edited from public domain
 * sourcecode.  For simplicity, this entire module will remain public
 * domain.
 */
/* 
 * This is ripped from eggdrop 1.3.28's source files (blowfish.mod)
 * Modified by Sun-Zero <sun-zero@freemail.hu>
 * 2002-04-16
*/

#include <stdlib.h>

#include "blowfish.h"
#include "bf_tab.h"		/* P-box P-array, S-box */

/* #define S(x,i) (bf_S[i][x.w.byte##i]) */
#define S0(x) (bf_S[0][x.w.byte0])
#define S1(x) (bf_S[1][x.w.byte1])
#define S2(x) (bf_S[2][x.w.byte2])
#define S3(x) (bf_S[3][x.w.byte3])
#define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x))
#define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n])

#include <time.h>

/* keep a set of rotating P & S boxes */
static struct box_t {
  UWORD_32bits *P;
  UWORD_32bits **S;
  char key[81];
  char keybytes;
} box;

//static UWORD_32bits bf_P[bf_N+2];
//static UWORD_32bits bf_S[4][256];
static UWORD_32bits *bf_P;
static UWORD_32bits **bf_S;


void blowfish_first_init(void) {
      box.P = NULL;
      box.S = NULL;
      box.key[0] = 0;
}

static void blowfish_encipher(UWORD_32bits * xl, UWORD_32bits * xr)
{
  union aword Xl;
  union aword Xr;

  Xl.word = *xl;
  Xr.word = *xr;

  Xl.word ^= bf_P[0];
  ROUND(Xr, Xl, 1);
  ROUND(Xl, Xr, 2);
  ROUND(Xr, Xl, 3);
  ROUND(Xl, Xr, 4);
  ROUND(Xr, Xl, 5);
  ROUND(Xl, Xr, 6);
  ROUND(Xr, Xl, 7);
  ROUND(Xl, Xr, 8);
  ROUND(Xr, Xl, 9);
  ROUND(Xl, Xr, 10);
  ROUND(Xr, Xl, 11);
  ROUND(Xl, Xr, 12);
  ROUND(Xr, Xl, 13);
  ROUND(Xl, Xr, 14);
  ROUND(Xr, Xl, 15);
  ROUND(Xl, Xr, 16);
  Xr.word ^= bf_P[17];

  *xr = Xl.word;
  *xl = Xr.word;
}

static void blowfish_init(UBYTE_08bits * key, short keybytes)
{
  int i, j;
  UWORD_32bits data;
  UWORD_32bits datal;
  UWORD_32bits datar;
  union aword temp;

  /* is buffer already allocated for this? */
  if (box.P != NULL) {
      if ((box.keybytes == keybytes) &&
	  (!strncmp((char *) (box.key), (char *) key, keybytes))) {
	/* match! */
	bf_P = box.P;
	bf_S = box.S;
	return;
      }
        free(box.P);
        for (i = 0; i < 4; i++)
          free(box.S[i]);
        free(box.S);
  }
  /* initialize new buffer */
  /* uh... this is over 4k */
  box.P = (UWORD_32bits *) malloc((bf_N + 2) * sizeof(UWORD_32bits));
  box.S = (UWORD_32bits **) malloc(4 * sizeof(UWORD_32bits *));
  for (i = 0; i < 4; i++)
    box.S[i] = (UWORD_32bits *) malloc(256 * sizeof(UWORD_32bits));
  bf_P = box.P;
  bf_S = box.S;
  box.keybytes = keybytes;
  strncpy(box.key, key, keybytes);
  /* robey: reset blowfish boxes to initial state */
  /* (i guess normally it just keeps scrambling them, but here it's
   * important to get the same encrypted result each time) */
  for (i = 0; i < bf_N + 2; i++)
    bf_P[i] = initbf_P[i];
  for (i = 0; i < 4; i++)
    for (j = 0; j < 256; j++)
      bf_S[i][j] = initbf_S[i][j];

  j = 0;
  for (i = 0; i < bf_N + 2; ++i) {
    temp.word = 0;
    temp.w.byte0 = key[j];
    temp.w.byte1 = key[(j + 1) % keybytes];
    temp.w.byte2 = key[(j + 2) % keybytes];
    temp.w.byte3 = key[(j + 3) % keybytes];
    data = temp.word;
    bf_P[i] = bf_P[i] ^ data;
    j = (j + 4) % keybytes;
  }
  datal = 0x00000000;
  datar = 0x00000000;
  for (i = 0; i < bf_N + 2; i += 2) {
    blowfish_encipher(&datal, &datar);
    bf_P[i] = datal;
    bf_P[i + 1] = datar;
  }
  for (i = 0; i < 4; ++i) {
    for (j = 0; j < 256; j += 2) {
      blowfish_encipher(&datal, &datar);
      bf_S[i][j] = datal;
      bf_S[i][j + 1] = datar;
    }
  }
}

/* stuff below this line was written by robey for eggdrop use */

/* of course, if you change either of these, then your userfile will
 * no longer be able to be shared. :) */
#define SALT1  0xdeadd061
#define SALT2  0x23f6b095

/* convert 64-bit encrypted password to text for userfile */
static char *base64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

static void blowfish_encrypt_pass(char *text, char *new)
{
  UWORD_32bits left, right;
  int n;
  char *p;

  blowfish_init(text, strlen(text));
  left = SALT1;
  right = SALT2;
  blowfish_encipher(&left, &right);
  p = new;
  *p++ = '+';			/* + means encrypted pass */
  n = 32;
  while (n > 0) {
    *p++ = base64[right & 0x3f];
    right = (right >> 6);
    n -= 6;
  }
  n = 32;
  while (n > 0) {
    *p++ = base64[left & 0x3f];
    left = (left >> 6);
    n -= 6;
  }
  *p = 0;
}





/* modified 19jul1996 by robey -- uses autoconf values now */
#ifndef _H_BLOWFISH
#define _H_BLOWFISH

#include "arch.h"

#define bf_N             16
#define noErr            0
#define DATAERROR        -1

#define UBYTE_08bits  unsigned char
#define UWORD_16bits  unsigned short

#define SIZEOF_INT 4

#if SIZEOF_INT==4
#define UWORD_32bits  unsigned int
#else
#if SIZEOF_LONG==4
#define UWORD_32bits  unsigned long
#endif
#endif

/* choose a byte order for your hardware */

#if !ARCH_LITTLE_ENDIAN
/* ABCD - big endian - motorola */
union aword {
  UWORD_32bits word;
  UBYTE_08bits byte[4];
  struct {
    unsigned int byte0:8;
    unsigned int byte1:8;
    unsigned int byte2:8;
    unsigned int byte3:8;
  } w;
};
#endif				/* !ARCH_LITTLE_ENDIAN */

#if ARCH_LITTLE_ENDIAN
/* DCBA - little endian - intel */
union aword {
  UWORD_32bits word;
  UBYTE_08bits byte[4];
  struct {
    unsigned int byte3:8;
    unsigned int byte2:8;
    unsigned int byte1:8;
    unsigned int byte0:8;
  } w;
};

#endif				/* ARCH_LITTLE_ENDIAN */

#endif




/* 
   Unix SMB/Netbios implementation.
   Version 1.9.
   SMB Byte handling
   Copyright (C) Andrew Tridgell 1992-1998
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef _BYTEORDER_H
#define _BYTEORDER_H

/*
   This file implements macros for machine independent short and 
   int manipulation

Here is a description of this file that I emailed to the samba list once:

> I am confused about the way that byteorder.h works in Samba. I have
> looked at it, and I would have thought that you might make a distinction
> between LE and BE machines, but you only seem to distinguish between 386
> and all other architectures.
> 
> Can you give me a clue?

sure.

The distinction between 386 and other architectures is only there as
an optimisation. You can take it out completely and it will make no
difference. The routines (macros) in byteorder.h are totally byteorder
independent. The 386 optimsation just takes advantage of the fact that
the x86 processors don't care about alignment, so we don't have to
align ints on int boundaries etc. If there are other processors out
there that aren't alignment sensitive then you could also define
CAREFUL_ALIGNMENT=0 on those processors as well.

Ok, now to the macros themselves. I'll take a simple example, say we
want to extract a 2 byte integer from a SMB packet and put it into a
type called uint16 that is in the local machines byte order, and you
want to do it with only the assumption that uint16 is _at_least_ 16
bits long (this last condition is very important for architectures
that don't have any int types that are 2 bytes long)

You do this:

#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
#define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)

then to extract a uint16 value at offset 25 in a buffer you do this:

char *buffer = foo_bar();
uint16 xx = SVAL(buffer,25);

We are using the byteoder independence of the ANSI C bitshifts to do
the work. A good optimising compiler should turn this into efficient
code, especially if it happens to have the right byteorder :-)

I know these macros can be made a bit tidier by removing some of the
casts, but you need to look at byteorder.h as a whole to see the
reasoning behind them. byteorder.h defines the following macros:

SVAL(buf,pos) - extract a 2 byte SMB value
IVAL(buf,pos) - extract a 4 byte SMB value
SVALS(buf,pos) signed version of SVAL()
IVALS(buf,pos) signed version of IVAL()

SSVAL(buf,pos,val) - put a 2 byte SMB value into a buffer
SIVAL(buf,pos,val) - put a 4 byte SMB value into a buffer
SSVALS(buf,pos,val) - signed version of SSVAL()
SIVALS(buf,pos,val) - signed version of SIVAL()

RSVAL(buf,pos) - like SVAL() but for NMB byte ordering
RSVALS(buf,pos) - like SVALS() but for NMB byte ordering
RIVAL(buf,pos) - like IVAL() but for NMB byte ordering
RIVALS(buf,pos) - like IVALS() but for NMB byte ordering
RSSVAL(buf,pos,val) - like SSVAL() but for NMB ordering
RSIVAL(buf,pos,val) - like SIVAL() but for NMB ordering
RSIVALS(buf,pos,val) - like SIVALS() but for NMB ordering

it also defines lots of intermediate macros, just ignore those :-)

*/

/* some switch macros that do both store and read to and from SMB buffers */

#define RW_PCVAL(read,inbuf,outbuf,len) \
	{ if (read) { PCVAL (inbuf,0,outbuf,len); } \
	else      { PSCVAL(inbuf,0,outbuf,len); } }

#define RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
	{ if (read) { if (big_endian) { RPIVAL(inbuf,0,outbuf,len); } else { PIVAL(inbuf,0,outbuf,len); } } \
	else      { if (big_endian) { RPSIVAL(inbuf,0,outbuf,len); } else { PSIVAL(inbuf,0,outbuf,len); } } }

#define RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
	{ if (read) { if (big_endian) { RPSVAL(inbuf,0,outbuf,len); } else { PSVAL(inbuf,0,outbuf,len); } } \
	else      { if (big_endian) { RPSSVAL(inbuf,0,outbuf,len); } else { PSSVAL(inbuf,0,outbuf,len); } } }

#define RW_CVAL(read, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = CVAL (inbuf,offset); } \
	else      { SCVAL(inbuf,offset,outbuf); } }

#define RW_IVAL(read, big_endian, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = ((big_endian) ? RIVAL(inbuf,offset) : IVAL (inbuf,offset)); } \
	else      { if (big_endian) { RSIVAL(inbuf,offset,outbuf); } else { SIVAL(inbuf,offset,outbuf); } } }

#define RW_SVAL(read, big_endian, inbuf, outbuf, offset) \
	{ if (read) { (outbuf) = ((big_endian) ? RSVAL(inbuf,offset) : SVAL (inbuf,offset)); } \
	else      { if (big_endian) { RSSVAL(inbuf,offset,outbuf); } else { SSVAL(inbuf,offset,outbuf); } } }

#undef CAREFUL_ALIGNMENT

/* we know that the 386 can handle misalignment and has the "right" 
   byteorder */
#ifdef __i386__
#define CAREFUL_ALIGNMENT 0
#endif

#ifndef CAREFUL_ALIGNMENT
#define CAREFUL_ALIGNMENT 1
#endif

#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
#define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))


#if CAREFUL_ALIGNMENT

#define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
#define IVAL(buf,pos) (SVAL(buf,pos)|SVAL(buf,(pos)+2)<<16)
#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
#define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
#define SVALS(buf,pos) ((int16)SVAL(buf,pos))
#define IVALS(buf,pos) ((int32)IVAL(buf,pos))
#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16)(val)))
#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
#define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16)(val)))
#define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32)(val)))

#else /* CAREFUL_ALIGNMENT */

/* this handles things for architectures like the 386 that can handle
   alignment errors */
/*
   WARNING: This section is dependent on the length of int16 and int32
   being correct 
*/

/* get single value from an SMB buffer */
#define SVAL(buf,pos) (*(const uint16 *)((const char *)(buf) + (pos)))
#define IVAL(buf,pos) (*(const uint32 *)((const char *)(buf) + (pos)))
#define SVALS(buf,pos) (*(const int16 *)((const char *)(buf) + (pos)))
#define IVALS(buf,pos) (*(const int32 *)((const char *)(buf) + (pos)))

/* store single value in an SMB buffer */
#define SVALMOD(buf,pos) (*(uint16 *)((char *)(buf) + (pos)))
#define IVALMOD(buf,pos) (*(uint32 *)((char *)(buf) + (pos)))
#define SVALSMOD(buf,pos) (*(int16 *)((char *)(buf) + (pos)))
#define IVALSMOD(buf,pos) (*(int32 *)((char *)(buf) + (pos)))

#define SSVAL(buf,pos,val) SVALMOD(buf,pos)=((uint16)(val))
#define SIVAL(buf,pos,val) IVALMOD(buf,pos)=((uint32)(val))
#define SSVALS(buf,pos,val) SVALSMOD(buf,pos)=((int16)(val))
#define SIVALS(buf,pos,val) IVALSMOD(buf,pos)=((int32)(val))

#endif /* CAREFUL_ALIGNMENT */

/* macros for reading / writing arrays */

#define SMBMACRO(macro,buf,pos,val,len,size) \
{ uint32 l; for (l = 0; l < (uint32)(len); l++) (val)[l] = macro((buf), (pos) + (size)*l); }

#define SSMBMACRO(macro,buf,pos,val,len,size) \
{ uint32 l; for (l = 0; l < (uint32)(len); l++) macro((buf), (pos) + (size)*l, (val)[l]); }

/* reads multiple data from an SMB buffer */
#define PCVAL(buf,pos,val,len) SMBMACRO(CVAL,buf,pos,val,len,1)
#define PSVAL(buf,pos,val,len) SMBMACRO(SVAL,buf,pos,val,len,2)
#define PIVAL(buf,pos,val,len) SMBMACRO(IVAL,buf,pos,val,len,4)
#define PCVALS(buf,pos,val,len) SMBMACRO(CVALS,buf,pos,val,len,1)
#define PSVALS(buf,pos,val,len) SMBMACRO(SVALS,buf,pos,val,len,2)
#define PIVALS(buf,pos,val,len) SMBMACRO(IVALS,buf,pos,val,len,4)

/* stores multiple data in an SMB buffer */
#define PSCVAL(buf,pos,val,len) SSMBMACRO(SCVAL,buf,pos,val,len,1)
#define PSSVAL(buf,pos,val,len) SSMBMACRO(SSVAL,buf,pos,val,len,2)
#define PSIVAL(buf,pos,val,len) SSMBMACRO(SIVAL,buf,pos,val,len,4)
#define PSCVALS(buf,pos,val,len) SSMBMACRO(SCVALS,buf,pos,val,len,1)
#define PSSVALS(buf,pos,val,len) SSMBMACRO(SSVALS,buf,pos,val,len,2)
#define PSIVALS(buf,pos,val,len) SSMBMACRO(SIVALS,buf,pos,val,len,4)


/* now the reverse routines - these are used in nmb packets (mostly) */
#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))

#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))

/* reads multiple data from an SMB buffer (big-endian) */
#define RPSVAL(buf,pos,val,len) SMBMACRO(RSVAL,buf,pos,val,len,2)
#define RPIVAL(buf,pos,val,len) SMBMACRO(RIVAL,buf,pos,val,len,4)
#define RPSVALS(buf,pos,val,len) SMBMACRO(RSVALS,buf,pos,val,len,2)
#define RPIVALS(buf,pos,val,len) SMBMACRO(RIVALS,buf,pos,val,len,4)

/* stores multiple data in an SMB buffer (big-endian) */
#define RPSSVAL(buf,pos,val,len) SSMBMACRO(RSSVAL,buf,pos,val,len,2)
#define RPSIVAL(buf,pos,val,len) SSMBMACRO(RSIVAL,buf,pos,val,len,4)
#define RPSSVALS(buf,pos,val,len) SSMBMACRO(RSSVALS,buf,pos,val,len,2)
#define RPSIVALS(buf,pos,val,len) SSMBMACRO(RSIVALS,buf,pos,val,len,4)

#define DBG_RW_PCVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
	{ RW_PCVAL(read,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), (len)); else \
	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%02x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); } 

#define DBG_RW_PSVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
	{ RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), 2*(len)); else \
	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%04x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); }

#define DBG_RW_PIVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
	{ RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
	DEBUG(5,("%s%04x %s: ", \
             tab_depth(depth), base,string)); \
    if (charmode) print_asc(5, (unsigned char*)(outbuf), 4*(len)); else \
	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%08x ", (outbuf)[idx])); } } \
	DEBUG(5,("\n")); }

#define DBG_RW_CVAL(string,depth,base,read,inbuf,outbuf) \
	{ RW_CVAL(read,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %02x\n", \
             tab_depth(depth), base, string, outbuf)); }

#define DBG_RW_SVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
	{ RW_SVAL(read,big_endian,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %04x\n", \
             tab_depth(depth), base, string, outbuf)); }

#define DBG_RW_IVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
	{ RW_IVAL(read,big_endian,inbuf,outbuf,0) \
	DEBUG(5,("%s%04x %s: %08x\n", \
             tab_depth(depth), base, string, outbuf)); }

/* Alignment macros. */
#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))

#endif /* _BYTEORDER_H */




#include "des.h"

static const DES_LONG DES_SPtrans[8][64]={
{
/* nibble 0 */
0x02080800L, 0x00080000L, 0x02000002L, 0x02080802L,
0x02000000L, 0x00080802L, 0x00080002L, 0x02000002L,
0x00080802L, 0x02080800L, 0x02080000L, 0x00000802L,
0x02000802L, 0x02000000L, 0x00000000L, 0x00080002L,
0x00080000L, 0x00000002L, 0x02000800L, 0x00080800L,
0x02080802L, 0x02080000L, 0x00000802L, 0x02000800L,
0x00000002L, 0x00000800L, 0x00080800L, 0x02080002L,
0x00000800L, 0x02000802L, 0x02080002L, 0x00000000L,
0x00000000L, 0x02080802L, 0x02000800L, 0x00080002L,
0x02080800L, 0x00080000L, 0x00000802L, 0x02000800L,
0x02080002L, 0x00000800L, 0x00080800L, 0x02000002L,
0x00080802L, 0x00000002L, 0x02000002L, 0x02080000L,
0x02080802L, 0x00080800L, 0x02080000L, 0x02000802L,
0x02000000L, 0x00000802L, 0x00080002L, 0x00000000L,
0x00080000L, 0x02000000L, 0x02000802L, 0x02080800L,
0x00000002L, 0x02080002L, 0x00000800L, 0x00080802L,
},{
/* nibble 1 */
0x40108010L, 0x00000000L, 0x00108000L, 0x40100000L,
0x40000010L, 0x00008010L, 0x40008000L, 0x00108000L,
0x00008000L, 0x40100010L, 0x00000010L, 0x40008000L,
0x00100010L, 0x40108000L, 0x40100000L, 0x00000010L,
0x00100000L, 0x40008010L, 0x40100010L, 0x00008000L,
0x00108010L, 0x40000000L, 0x00000000L, 0x00100010L,
0x40008010L, 0x00108010L, 0x40108000L, 0x40000010L,
0x40000000L, 0x00100000L, 0x00008010L, 0x40108010L,
0x00100010L, 0x40108000L, 0x40008000L, 0x00108010L,
0x40108010L, 0x00100010L, 0x40000010L, 0x00000000L,
0x40000000L, 0x00008010L, 0x00100000L, 0x40100010L,
0x00008000L, 0x40000000L, 0x00108010L, 0x40008010L,
0x40108000L, 0x00008000L, 0x00000000L, 0x40000010L,
0x00000010L, 0x40108010L, 0x00108000L, 0x40100000L,
0x40100010L, 0x00100000L, 0x00008010L, 0x40008000L,
0x40008010L, 0x00000010L, 0x40100000L, 0x00108000L,
},{
/* nibble 2 */
0x04000001L, 0x04040100L, 0x00000100L, 0x04000101L,
0x00040001L, 0x04000000L, 0x04000101L, 0x00040100L,
0x04000100L, 0x00040000L, 0x04040000L, 0x00000001L,
0x04040101L, 0x00000101L, 0x00000001L, 0x04040001L,
0x00000000L, 0x00040001L, 0x04040100L, 0x00000100L,
0x00000101L, 0x04040101L, 0x00040000L, 0x04000001L,
0x04040001L, 0x04000100L, 0x00040101L, 0x04040000L,
0x00040100L, 0x00000000L, 0x04000000L, 0x00040101L,
0x04040100L, 0x00000100L, 0x00000001L, 0x00040000L,
0x00000101L, 0x00040001L, 0x04040000L, 0x04000101L,
0x00000000L, 0x04040100L, 0x00040100L, 0x04040001L,
0x00040001L, 0x04000000L, 0x04040101L, 0x00000001L,
0x00040101L, 0x04000001L, 0x04000000L, 0x04040101L,
0x00040000L, 0x04000100L, 0x04000101L, 0x00040100L,
0x04000100L, 0x00000000L, 0x04040001L, 0x00000101L,
0x04000001L, 0x00040101L, 0x00000100L, 0x04040000L,
},{
/* nibble 3 */
0x00401008L, 0x10001000L, 0x00000008L, 0x10401008L,
0x00000000L, 0x10400000L, 0x10001008L, 0x00400008L,
0x10401000L, 0x10000008L, 0x10000000L, 0x00001008L,
0x10000008L, 0x00401008L, 0x00400000L, 0x10000000L,
0x10400008L, 0x00401000L, 0x00001000L, 0x00000008L,
0x00401000L, 0x10001008L, 0x10400000L, 0x00001000L,
0x00001008L, 0x00000000L, 0x00400008L, 0x10401000L,
0x10001000L, 0x10400008L, 0x10401008L, 0x00400000L,
0x10400008L, 0x00001008L, 0x00400000L, 0x10000008L,
0x00401000L, 0x10001000L, 0x00000008L, 0x10400000L,
0x10001008L, 0x00000000L, 0x00001000L, 0x00400008L,
0x00000000L, 0x10400008L, 0x10401000L, 0x00001000L,
0x10000000L, 0x10401008L, 0x00401008L, 0x00400000L,
0x10401008L, 0x00000008L, 0x10001000L, 0x00401008L,
0x00400008L, 0x00401000L, 0x10400000L, 0x10001008L,
0x00001008L, 0x10000000L, 0x10000008L, 0x10401000L,
},{
/* nibble 4 */
0x08000000L, 0x00010000L, 0x00000400L, 0x08010420L,
0x08010020L, 0x08000400L, 0x00010420L, 0x08010000L,
0x00010000L, 0x00000020L, 0x08000020L, 0x00010400L,
0x08000420L, 0x08010020L, 0x08010400L, 0x00000000L,
0x00010400L, 0x08000000L, 0x00010020L, 0x00000420L,
0x08000400L, 0x00010420L, 0x00000000L, 0x08000020L,
0x00000020L, 0x08000420L, 0x08010420L, 0x00010020L,
0x08010000L, 0x00000400L, 0x00000420L, 0x08010400L,
0x08010400L, 0x08000420L, 0x00010020L, 0x08010000L,
0x00010000L, 0x00000020L, 0x08000020L, 0x08000400L,
0x08000000L, 0x00010400L, 0x08010420L, 0x00000000L,
0x00010420L, 0x08000000L, 0x00000400L, 0x00010020L,
0x08000420L, 0x00000400L, 0x00000000L, 0x08010420L,
0x08010020L, 0x08010400L, 0x00000420L, 0x00010000L,
0x00010400L, 0x08010020L, 0x08000400L, 0x00000420L,
0x00000020L, 0x00010420L, 0x08010000L, 0x08000020L,
},{
/* nibble 5 */
0x80000040L, 0x00200040L, 0x00000000L, 0x80202000L,
0x00200040L, 0x00002000L, 0x80002040L, 0x00200000L,
0x00002040L, 0x80202040L, 0x00202000L, 0x80000000L,
0x80002000L, 0x80000040L, 0x80200000L, 0x00202040L,
0x00200000L, 0x80002040L, 0x80200040L, 0x00000000L,
0x00002000L, 0x00000040L, 0x80202000L, 0x80200040L,
0x80202040L, 0x80200000L, 0x80000000L, 0x00002040L,
0x00000040L, 0x00202000L, 0x00202040L, 0x80002000L,
0x00002040L, 0x80000000L, 0x80002000L, 0x00202040L,
0x80202000L, 0x00200040L, 0x00000000L, 0x80002000L,
0x80000000L, 0x00002000L, 0x80200040L, 0x00200000L,
0x00200040L, 0x80202040L, 0x00202000L, 0x00000040L,
0x80202040L, 0x00202000L, 0x00200000L, 0x80002040L,
0x80000040L, 0x80200000L, 0x00202040L, 0x00000000L,
0x00002000L, 0x80000040L, 0x80002040L, 0x80202000L,
0x80200000L, 0x00002040L, 0x00000040L, 0x80200040L,
},{
/* nibble 6 */
0x00004000L, 0x00000200L, 0x01000200L, 0x01000004L,
0x01004204L, 0x00004004L, 0x00004200L, 0x00000000L,
0x01000000L, 0x01000204L, 0x00000204L, 0x01004000L,
0x00000004L, 0x01004200L, 0x01004000L, 0x00000204L,
0x01000204L, 0x00004000L, 0x00004004L, 0x01004204L,
0x00000000L, 0x01000200L, 0x01000004L, 0x00004200L,
0x01004004L, 0x00004204L, 0x01004200L, 0x00000004L,
0x00004204L, 0x01004004L, 0x00000200L, 0x01000000L,
0x00004204L, 0x01004000L, 0x01004004L, 0x00000204L,
0x00004000L, 0x00000200L, 0x01000000L, 0x01004004L,
0x01000204L, 0x00004204L, 0x00004200L, 0x00000000L,
0x00000200L, 0x01000004L, 0x00000004L, 0x01000200L,
0x00000000L, 0x01000204L, 0x01000200L, 0x00004200L,
0x00000204L, 0x00004000L, 0x01004204L, 0x01000000L,
0x01004200L, 0x00000004L, 0x00004004L, 0x01004204L,
0x01000004L, 0x01004200L, 0x01004000L, 0x00004004L,
},{
/* nibble 7 */
0x20800080L, 0x20820000L, 0x00020080L, 0x00000000L,
0x20020000L, 0x00800080L, 0x20800000L, 0x20820080L,
0x00000080L, 0x20000000L, 0x00820000L, 0x00020080L,
0x00820080L, 0x20020080L, 0x20000080L, 0x20800000L,
0x00020000L, 0x00820080L, 0x00800080L, 0x20020000L,
0x20820080L, 0x20000080L, 0x00000000L, 0x00820000L,
0x20000000L, 0x00800000L, 0x20020080L, 0x20800080L,
0x00800000L, 0x00020000L, 0x20820000L, 0x00000080L,
0x00800000L, 0x00020000L, 0x20000080L, 0x20820080L,
0x00020080L, 0x20000000L, 0x00000000L, 0x00820000L,
0x20800080L, 0x20020080L, 0x20020000L, 0x00800080L,
0x20820000L, 0x00000080L, 0x00800080L, 0x20020000L,
0x20820080L, 0x00800000L, 0x20800000L, 0x20000080L,
0x00820000L, 0x00020080L, 0x20020080L, 0x20800000L,
0x00000080L, 0x20820000L, 0x00820080L, 0x00000000L,
0x20000000L, 0x20800080L, 0x00020000L, 0x00820080L,
}};

static const DES_LONG des_skb[8][64]={
	{
	/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
	0x00000000L,0x00000010L,0x20000000L,0x20000010L,
	0x00010000L,0x00010010L,0x20010000L,0x20010010L,
	0x00000800L,0x00000810L,0x20000800L,0x20000810L,
	0x00010800L,0x00010810L,0x20010800L,0x20010810L,
	0x00000020L,0x00000030L,0x20000020L,0x20000030L,
	0x00010020L,0x00010030L,0x20010020L,0x20010030L,
	0x00000820L,0x00000830L,0x20000820L,0x20000830L,
	0x00010820L,0x00010830L,0x20010820L,0x20010830L,
	0x00080000L,0x00080010L,0x20080000L,0x20080010L,
	0x00090000L,0x00090010L,0x20090000L,0x20090010L,
	0x00080800L,0x00080810L,0x20080800L,0x20080810L,
	0x00090800L,0x00090810L,0x20090800L,0x20090810L,
	0x00080020L,0x00080030L,0x20080020L,0x20080030L,
	0x00090020L,0x00090030L,0x20090020L,0x20090030L,
	0x00080820L,0x00080830L,0x20080820L,0x20080830L,
	0x00090820L,0x00090830L,0x20090820L,0x20090830L,
	},{
	/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
	0x00000000L,0x02000000L,0x00002000L,0x02002000L,
	0x00200000L,0x02200000L,0x00202000L,0x02202000L,
	0x00000004L,0x02000004L,0x00002004L,0x02002004L,
	0x00200004L,0x02200004L,0x00202004L,0x02202004L,
	0x00000400L,0x02000400L,0x00002400L,0x02002400L,
	0x00200400L,0x02200400L,0x00202400L,0x02202400L,
	0x00000404L,0x02000404L,0x00002404L,0x02002404L,
	0x00200404L,0x02200404L,0x00202404L,0x02202404L,
	0x10000000L,0x12000000L,0x10002000L,0x12002000L,
	0x10200000L,0x12200000L,0x10202000L,0x12202000L,
	0x10000004L,0x12000004L,0x10002004L,0x12002004L,
	0x10200004L,0x12200004L,0x10202004L,0x12202004L,
	0x10000400L,0x12000400L,0x10002400L,0x12002400L,
	0x10200400L,0x12200400L,0x10202400L,0x12202400L,
	0x10000404L,0x12000404L,0x10002404L,0x12002404L,
	0x10200404L,0x12200404L,0x10202404L,0x12202404L,
	},{
	/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
	0x00000000L,0x00000001L,0x00040000L,0x00040001L,
	0x01000000L,0x01000001L,0x01040000L,0x01040001L,
	0x00000002L,0x00000003L,0x00040002L,0x00040003L,
	0x01000002L,0x01000003L,0x01040002L,0x01040003L,
	0x00000200L,0x00000201L,0x00040200L,0x00040201L,
	0x01000200L,0x01000201L,0x01040200L,0x01040201L,
	0x00000202L,0x00000203L,0x00040202L,0x00040203L,
	0x01000202L,0x01000203L,0x01040202L,0x01040203L,
	0x08000000L,0x08000001L,0x08040000L,0x08040001L,
	0x09000000L,0x09000001L,0x09040000L,0x09040001L,
	0x08000002L,0x08000003L,0x08040002L,0x08040003L,
	0x09000002L,0x09000003L,0x09040002L,0x09040003L,
	0x08000200L,0x08000201L,0x08040200L,0x08040201L,
	0x09000200L,0x09000201L,0x09040200L,0x09040201L,
	0x08000202L,0x08000203L,0x08040202L,0x08040203L,
	0x09000202L,0x09000203L,0x09040202L,0x09040203L,
	},{
	/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
	0x00000000L,0x00100000L,0x00000100L,0x00100100L,
	0x00000008L,0x00100008L,0x00000108L,0x00100108L,
	0x00001000L,0x00101000L,0x00001100L,0x00101100L,
	0x00001008L,0x00101008L,0x00001108L,0x00101108L,
	0x04000000L,0x04100000L,0x04000100L,0x04100100L,
	0x04000008L,0x04100008L,0x04000108L,0x04100108L,
	0x04001000L,0x04101000L,0x04001100L,0x04101100L,
	0x04001008L,0x04101008L,0x04001108L,0x04101108L,
	0x00020000L,0x00120000L,0x00020100L,0x00120100L,
	0x00020008L,0x00120008L,0x00020108L,0x00120108L,
	0x00021000L,0x00121000L,0x00021100L,0x00121100L,
	0x00021008L,0x00121008L,0x00021108L,0x00121108L,
	0x04020000L,0x04120000L,0x04020100L,0x04120100L,
	0x04020008L,0x04120008L,0x04020108L,0x04120108L,
	0x04021000L,0x04121000L,0x04021100L,0x04121100L,
	0x04021008L,0x04121008L,0x04021108L,0x04121108L,
	},{
	/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
	0x00000000L,0x10000000L,0x00010000L,0x10010000L,
	0x00000004L,0x10000004L,0x00010004L,0x10010004L,
	0x20000000L,0x30000000L,0x20010000L,0x30010000L,
	0x20000004L,0x30000004L,0x20010004L,0x30010004L,
	0x00100000L,0x10100000L,0x00110000L,0x10110000L,
	0x00100004L,0x10100004L,0x00110004L,0x10110004L,
	0x20100000L,0x30100000L,0x20110000L,0x30110000L,
	0x20100004L,0x30100004L,0x20110004L,0x30110004L,
	0x00001000L,0x10001000L,0x00011000L,0x10011000L,
	0x00001004L,0x10001004L,0x00011004L,0x10011004L,
	0x20001000L,0x30001000L,0x20011000L,0x30011000L,
	0x20001004L,0x30001004L,0x20011004L,0x30011004L,
	0x00101000L,0x10101000L,0x00111000L,0x10111000L,
	0x00101004L,0x10101004L,0x00111004L,0x10111004L,
	0x20101000L,0x30101000L,0x20111000L,0x30111000L,
	0x20101004L,0x30101004L,0x20111004L,0x30111004L,
	},{
	/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
	0x00000000L,0x08000000L,0x00000008L,0x08000008L,
	0x00000400L,0x08000400L,0x00000408L,0x08000408L,
	0x00020000L,0x08020000L,0x00020008L,0x08020008L,
	0x00020400L,0x08020400L,0x00020408L,0x08020408L,
	0x00000001L,0x08000001L,0x00000009L,0x08000009L,
	0x00000401L,0x08000401L,0x00000409L,0x08000409L,
	0x00020001L,0x08020001L,0x00020009L,0x08020009L,
	0x00020401L,0x08020401L,0x00020409L,0x08020409L,
	0x02000000L,0x0A000000L,0x02000008L,0x0A000008L,
	0x02000400L,0x0A000400L,0x02000408L,0x0A000408L,
	0x02020000L,0x0A020000L,0x02020008L,0x0A020008L,
	0x02020400L,0x0A020400L,0x02020408L,0x0A020408L,
	0x02000001L,0x0A000001L,0x02000009L,0x0A000009L,
	0x02000401L,0x0A000401L,0x02000409L,0x0A000409L,
	0x02020001L,0x0A020001L,0x02020009L,0x0A020009L,
	0x02020401L,0x0A020401L,0x02020409L,0x0A020409L,
	},{
	/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
	0x00000000L,0x00000100L,0x00080000L,0x00080100L,
	0x01000000L,0x01000100L,0x01080000L,0x01080100L,
	0x00000010L,0x00000110L,0x00080010L,0x00080110L,
	0x01000010L,0x01000110L,0x01080010L,0x01080110L,
	0x00200000L,0x00200100L,0x00280000L,0x00280100L,
	0x01200000L,0x01200100L,0x01280000L,0x01280100L,
	0x00200010L,0x00200110L,0x00280010L,0x00280110L,
	0x01200010L,0x01200110L,0x01280010L,0x01280110L,
	0x00000200L,0x00000300L,0x00080200L,0x00080300L,
	0x01000200L,0x01000300L,0x01080200L,0x01080300L,
	0x00000210L,0x00000310L,0x00080210L,0x00080310L,
	0x01000210L,0x01000310L,0x01080210L,0x01080310L,
	0x00200200L,0x00200300L,0x00280200L,0x00280300L,
	0x01200200L,0x01200300L,0x01280200L,0x01280300L,
	0x00200210L,0x00200310L,0x00280210L,0x00280310L,
	0x01200210L,0x01200310L,0x01280210L,0x01280310L,
	},{
	/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
	0x00000000L,0x04000000L,0x00040000L,0x04040000L,
	0x00000002L,0x04000002L,0x00040002L,0x04040002L,
	0x00002000L,0x04002000L,0x00042000L,0x04042000L,
	0x00002002L,0x04002002L,0x00042002L,0x04042002L,
	0x00000020L,0x04000020L,0x00040020L,0x04040020L,
	0x00000022L,0x04000022L,0x00040022L,0x04040022L,
	0x00002020L,0x04002020L,0x00042020L,0x04042020L,
	0x00002022L,0x04002022L,0x00042022L,0x04042022L,
	0x00000800L,0x04000800L,0x00040800L,0x04040800L,
	0x00000802L,0x04000802L,0x00040802L,0x04040802L,
	0x00002800L,0x04002800L,0x00042800L,0x04042800L,
	0x00002802L,0x04002802L,0x00042802L,0x04042802L,
	0x00000820L,0x04000820L,0x00040820L,0x04040820L,
	0x00000822L,0x04000822L,0x00040822L,0x04040822L,
	0x00002820L,0x04002820L,0x00042820L,0x04042820L,
	0x00002822L,0x04002822L,0x00042822L,0x04042822L,
	}};

#define c2l(c,l)        (l =((DES_LONG)(*((c)++)))    , \
                         l|=((DES_LONG)(*((c)++)))<< 8L, \
                         l|=((DES_LONG)(*((c)++)))<<16L, \
                         l|=((DES_LONG)(*((c)++)))<<24L)

#define l2c(l,c)        (*((c)++)=(unsigned char)(((l)     )&0xff), \
                         *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
                         *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
                         *((c)++)=(unsigned char)(((l)>>24L)&0xff))
#define c2ln(c,l1,l2,n) { \
                        c+=n; \
                        l1=l2=0; \
                        switch (n) { \
                        case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \
                        case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \
                        case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \
                        case 5: l2|=((DES_LONG)(*(--(c))));     \
                        case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \
                        case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \
                        case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \
                        case 1: l1|=((DES_LONG)(*(--(c))));     \
                                } \
                        }

#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
	(a)=(a)^(t)^(t>>(16-(n))))

#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 	(b)^=(t),\
 	(a)=((a)^((t)<<(n))))

#define ROTATE(a,n)     (((a)>>(n))+((a)<<(32-(n))))

#define IP(l,r) \
	{ \
	register DES_LONG tt; \
	PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
	PERM_OP(l,r,tt,16,0x0000ffffL); \
	PERM_OP(r,l,tt, 2,0x33333333L); \
	PERM_OP(l,r,tt, 8,0x00ff00ffL); \
	PERM_OP(r,l,tt, 1,0x55555555L); \
	}

#define FP(l,r) \
	{ \
	register DES_LONG tt; \
	PERM_OP(l,r,tt, 1,0x55555555L); \
	PERM_OP(r,l,tt, 8,0x00ff00ffL); \
	PERM_OP(l,r,tt, 2,0x33333333L); \
	PERM_OP(r,l,tt,16,0x0000ffffL); \
	PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
	}
#define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
	u=R^s[S  ]; \
	t=R^s[S+1]
#define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)

#define D_ENCRYPT(LL,R,S) { \
	LOAD_DATA_tmp(R,S,u,t,E0,E1); \
	t=ROTATE(t,4); \
	LL^= \
	*(const DES_LONG *)(des_SP      +((u     )&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x200+((u>> 8L)&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x400+((u>>16L)&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x600+((u>>24L)&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x100+((t     )&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x300+((t>> 8L)&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x500+((t>>16L)&0xfc))^ \
	*(const DES_LONG *)(des_SP+0x700+((t>>24L)&0xfc)); }

void my_des_set_key(DES_cblock *key, DES_key_schedule *schedule)
{
	//DES_set_key_unchecked(key, schedule);
	static int shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
	register DES_LONG c,d,t,s,t2;
	register const unsigned char *in;
	register DES_LONG *k;
	register int i;

	k = &schedule->ks->deslong[0];
	in = &(*key)[0];

	c2l(in,c);
	c2l(in,d);

	/* do PC1 in 47 simple operations :-)
	 * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
	 * for the inspiration. :-) */
	PERM_OP (d,c,t,4,0x0f0f0f0fL);
	HPERM_OP(c,t,-2,0xcccc0000L);
	HPERM_OP(d,t,-2,0xcccc0000L);
	PERM_OP (d,c,t,1,0x55555555L);
	PERM_OP (c,d,t,8,0x00ff00ffL);
	PERM_OP (d,c,t,1,0x55555555L);
	d=	(((d&0x000000ffL)<<16L)| (d&0x0000ff00L)     |
			((d&0x00ff0000L)>>16L)|((c&0xf0000000L)>>4L));
	c&=0x0fffffffL;

	for (i=0; i<16; i++)
	{
		if (shifts2[i])
		{ 
			c=((c>>2L)|(c<<26L));
			d=((d>>2L)|(d<<26L)); 
		}
		else
		{ 
			c=((c>>1L)|(c<<27L));
			d=((d>>1L)|(d<<27L));
		}
		c&=0x0fffffffL;
		d&=0x0fffffffL;
		/* could be a few less shifts but I am to lazy at this
		 * point in time to investigate */
		s=	des_skb[0][ (c    )&0x3f                ]|
			des_skb[1][((c>> 6L)&0x03)|((c>> 7L)&0x3c)]|
			des_skb[2][((c>>13L)&0x0f)|((c>>14L)&0x30)]|
			des_skb[3][((c>>20L)&0x01)|((c>>21L)&0x06) |
			((c>>22L)&0x38)];
		t=	des_skb[4][ (d    )&0x3f                ]|
			des_skb[5][((d>> 7L)&0x03)|((d>> 8L)&0x3c)]|
			des_skb[6][ (d>>15L)&0x3f                ]|
			des_skb[7][((d>>21L)&0x0f)|((d>>22L)&0x30)];

		/* table contained 0213 4657 */
		t2=((t<<16L)|(s&0x0000ffffL))&0xffffffffL;
		*(k++)=ROTATE(t2,30)&0xffffffffL;

		t2=((s>>16L)|(t&0xffff0000L));
		*(k++)=ROTATE(t2,26)&0xffffffffL;
	}
}

static void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks)
{
	register DES_LONG l,r,t,u;
	register DES_LONG *s;
	register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;

	r=data[0];
	l=data[1];

	IP(r,l);
	/* Things have been modified so that the initial rotate is
	 * done outside the loop.  This required the
	 * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
	 * One perl script later and things have a 5% speed up on a sparc2.
	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
	 * for pointing this out. */
	/* clear the top bits on machines with 8byte longs */
	/* shift left by 2 */
	r=ROTATE(r,29)&0xffffffffL;
	l=ROTATE(l,29)&0xffffffffL;

	s=ks->ks->deslong;
	/* I don't know if it is worth the effort of loop unrolling the
	 * inner loop */
	D_ENCRYPT(l,r, 0); /*  1 */
	D_ENCRYPT(r,l, 2); /*  2 */
	D_ENCRYPT(l,r, 4); /*  3 */
	D_ENCRYPT(r,l, 6); /*  4 */
	D_ENCRYPT(l,r, 8); /*  5 */
	D_ENCRYPT(r,l,10); /*  6 */
	D_ENCRYPT(l,r,12); /*  7 */
	D_ENCRYPT(r,l,14); /*  8 */
	D_ENCRYPT(l,r,16); /*  9 */
	D_ENCRYPT(r,l,18); /*  10 */
	D_ENCRYPT(l,r,20); /*  11 */
	D_ENCRYPT(r,l,22); /*  12 */
	D_ENCRYPT(l,r,24); /*  13 */
	D_ENCRYPT(r,l,26); /*  14 */
	D_ENCRYPT(l,r,28); /*  15 */
	D_ENCRYPT(r,l,30); /*  16 */
	
	/* rotate and clear the top bits on machines with 8byte longs */
	l=ROTATE(l,3)&0xffffffffL;
	r=ROTATE(r,3)&0xffffffffL;

	FP(r,l);
	data[0]=l;
	data[1]=r;
	//l=r=t=u=0;
}

void my_des_ncbc_encrypt(const unsigned char *in,
		long length, DES_key_schedule *schedule, DES_cblock *ivec)
{
	register DES_LONG tin0,tin1;
	register DES_LONG tout0,tout1;
	register long l=length;
	DES_LONG tin[2];
	unsigned char *iv;

	iv = &(*ivec)[0];
	c2l(iv,tout0);
	c2l(iv,tout1);

	for (l-=8; l>=0; l-=8)
	{
		c2l(in,tin0);
		c2l(in,tin1);
		tin0^=tout0; tin[0]=tin0;
		tin1^=tout1; tin[1]=tin1;
		DES_encrypt1((DES_LONG *)tin,schedule);
		tout0=tin[0];
		tout1=tin[1];
	}
	if (l != -8)
	{
		c2ln(in,tin0,tin1,l+8);
		tin0^=tout0; tin[0]=tin0;
		tin1^=tout1; tin[1]=tin1;
		DES_encrypt1((DES_LONG *)tin,schedule);
		tout0=tin[0];
		tout1=tin[1];
	}

	iv = &(*ivec)[0];
	l2c(tout0,iv);
	l2c(tout1,iv);
}




#ifndef _DES_H
#define _DES_H

//#include <openssl/des.h>
typedef unsigned long DES_LONG;

typedef unsigned char DES_cblock[8];

typedef struct DES_ks
    {
    union
	{
	DES_cblock cblock;
	/* make sure things are correct size on machines with
	 * 8 byte longs */
	DES_LONG deslong[2];
	} ks[16];
    } DES_key_schedule;



void my_des_ncbc_encrypt(const unsigned char *input,
               long length, DES_key_schedule *schedule, DES_cblock *ivec);
void my_des_set_key(DES_cblock *key, DES_key_schedule *schedule);


#endif




/*
 * Copyright (c) 2004 bartavelle
 * bartavelle@bandecon.com
 *
 * Simple MD5 hashes cracker
 * It uses the Solar Designer's md5 implementation
 * 
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "md5.h"

#define FORMAT_LABEL			"hmac-md5"
#define FORMAT_NAME			"HMAC MD5"
#ifdef MMX_COEF
#if (MMX_COEF == 2)
#define ALGORITHM_NAME			"hmac-md5 MMX"
#else
#define ALGORITHM_NAME			"hmac-md5 SSE2"
#endif
#else
#define ALGORITHM_NAME			"hmac-md5"
#endif

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		64
#define CIPHERTEXT_LENGTH		128

#define BINARY_SIZE			16
#define SALT_SIZE			64

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + ((i)&3) )
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

static struct fmt_tests hmacmd5_tests[] = {
	{"what do ya want for nothing?#750c783e6ab0b503eaa86e310a5db738", "Jefe"},
	{NULL}
};

#ifdef MMX_COEF
//static char saved_key[PLAINTEXT_LENGTH*MMX_COEF*2 + 1] __attribute__ ((aligned(16)));
static char crypt_key[64*MMX_COEF] __attribute__ ((aligned(16)));
unsigned long total_len;
unsigned char opad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char ipad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char cursalt[SALT_SIZE*MMX_COEF] __attribute__ ((aligned(16)));
unsigned char dump[BINARY_SIZE*MMX_COEF] __attribute__((aligned(16)));
#else
//static char saved_key[PLAINTEXT_LENGTH + 1];
static char crypt_key[BINARY_SIZE+1];
static MD5_CTX ctx;
unsigned char opad[PLAINTEXT_LENGTH];
unsigned char ipad[PLAINTEXT_LENGTH];
unsigned char cursalt[SALT_SIZE];
#endif
unsigned char out[PLAINTEXT_LENGTH];

static void hmacmd5_init(void)
{
#ifdef MMX_COEF
	memset(crypt_key, 0, 64*MMX_COEF);
	crypt_key[GETPOS(BINARY_SIZE,0)] = 0x80;
	crypt_key[GETPOS(BINARY_SIZE,1)] = 0x80;
#if (MMX_COEF == 4)
	crypt_key[GETPOS(BINARY_SIZE,2)] = 0x80;
	crypt_key[GETPOS(BINARY_SIZE,3)] = 0x80;
#endif
#endif
}

static int valid(char *ciphertext)
{
	int pos, i;

	for(i=0;(i<strlen(ciphertext)) && (ciphertext[i]!='#');i++) ;
	if(i==strlen(ciphertext))
		return 0;
	pos = i+1;
	if (strlen(ciphertext+pos) != BINARY_SIZE*2) return 0;
	for (i = pos; i < BINARY_SIZE*2+pos; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	return 1;
}

static void hmacmd5_set_salt(void *salt) 
{
#ifdef MMX_COEF
	total_len = 0;
	while(((unsigned char *)salt)[total_len])
	{
		cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
#if (MMX_COEF == 4)
		cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
		cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
#endif
		total_len ++;
	}
	cursalt[GETPOS(total_len, 0)] = 0x80;
	cursalt[GETPOS(total_len, 1)] = 0x80;
#if (MMX_COEF == 4)
	cursalt[GETPOS(total_len, 2)] = 0x80;
	cursalt[GETPOS(total_len, 3)] = 0x80;
#endif
	//total_len += 64;
	//total_len += (total_len<<16);
#else
	memcpy(cursalt, salt, SALT_SIZE);
#endif
}

static void hmacmd5_set_key(char *key, int index) {
	int i;
	int len;
	
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

#ifdef MMX_COEF
	if(index==0)
	{
		memset(ipad, 0x36, PLAINTEXT_LENGTH*MMX_COEF);
		memset(opad, 0x5C, PLAINTEXT_LENGTH*MMX_COEF);
	}
	
	for(i=0;i<len;i++)
	{
		ipad[GETPOS(i, index)] ^= key[i];
		opad[GETPOS(i, index)] ^= key[i];
	}

	//saved_key[GETPOS(i, index)] = 0x80;
#else
	memset(ipad, 0x36, PLAINTEXT_LENGTH);
	memset(opad, 0x5C, PLAINTEXT_LENGTH);
	for(i=0;i<len;i++)
	{
		ipad[i] ^= key[i];
		opad[i] ^= key[i];
	}
#endif
}

static char *hmacmd5_get_key(int index) {
	unsigned int i;
	for(i=0;i<PLAINTEXT_LENGTH;i++)
#ifdef MMX_COEF
		out[i] = ipad[ GETPOS(i, index) ] ^ 0x36;
#else
		out[i] = ipad[ i ] ^ 0x36;
#endif
	return out;
}

static int hmacmd5_cmp_all(void *binary, int index) { 
	int i=0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int hmacmd5_cmp_exact(char *source, int count){
  return (1);
}

static int hmacmd5_cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return hmacmd5_cmp_all(binary, index);
#endif
}

static void hmacmd5_crypt_all(int count) {  

#ifdef MMX_COEF
	int i;
	i = mdfivemmx_nosizeupdate( dump, ipad, 64);
	i = mdfivemmx_noinit_uniformsizeupdate(crypt_key, cursalt, total_len + 64);
	i = mdfivemmx_nosizeupdate( dump, opad, 64);
	i = mdfivemmx_noinit_uniformsizeupdate(crypt_key, crypt_key, BINARY_SIZE + 64);
#else
	MD5_Init( &ctx );
	MD5_Update( &ctx, ipad, 64 );
	MD5_Update( &ctx, cursalt, strlen(cursalt) );
	MD5_Final( crypt_key, &ctx);
	MD5_Init( &ctx );
	MD5_Update( &ctx, opad, 64 );
	MD5_Update( &ctx, crypt_key, BINARY_SIZE);
	MD5_Final( crypt_key, &ctx);
#endif
  
}

static void * hmacmd5_binary(char *ciphertext) 
{
	static unsigned char realcipher[BINARY_SIZE];
	int i,pos;
	
	for(i=0;ciphertext[i]!='#';i++);
	pos=i+1;
	for(i=0;i<BINARY_SIZE;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+pos])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1+pos])];
	}
	return (void *)realcipher;
}

static void * hmacmd5_salt(char *ciphertext)
{
	static unsigned char salt[SALT_SIZE];
	memset(salt, 0, SALT_SIZE);
	int i=0;
	while(ciphertext[i]!='#')
	{
		salt[i] = ciphertext[i];
		i++;
	}
	salt[i]=0;
	return salt;
}

struct fmt_main fmt_hmacMD5 = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		hmacmd5_tests
	}, {
		hmacmd5_init,
		valid,
		fmt_default_split,
		hmacmd5_binary,
		hmacmd5_salt,
		{
			fmt_default_binary_hash,
			fmt_default_binary_hash,
			fmt_default_binary_hash
		},
		fmt_default_salt_hash,
		hmacmd5_set_salt,
		hmacmd5_set_key,
		hmacmd5_get_key,
		fmt_default_clear_keys,
		hmacmd5_crypt_all,
		{
			fmt_default_get_hash,
			fmt_default_get_hash,
			fmt_default_get_hash
		},
		hmacmd5_cmp_all,
		hmacmd5_cmp_one,
		hmacmd5_cmp_exact
	}
};




#endif

extern struct fmt_main fmt_DES, fmt_BSDI, fmt_MD5, fmt_BF;
extern struct fmt_main fmt_AFS, fmt_LM, fmt_rawMD5, fmt_NT;
extern struct fmt_main fmt_MD5_apache;
extern struct fmt_main fmt_BFEgg;
extern struct fmt_main fmt_MYSQL;
extern struct fmt_main fmt_NSLDAP;
extern struct fmt_main fmt_lotus5;
extern struct fmt_main fmt_mscash;
extern struct fmt_main fmt_rawSHA1;
extern struct fmt_main fmt_mssql;
extern struct fmt_main fmt_hmacMD5;
extern struct fmt_main fmt_WPAPSK;
extern struct fmt_main fmt_oracle;
#ifdef MMX_COEF
extern struct fmt_main fmt_NTmmx;
#endif

extern int unshadow(int argc, char **argv);
extern int unafs(int argc, char **argv);
extern int unique(int argc, char **argv);
extern int undrop(int argc, char **argv);

static struct db_main database;
static struct fmt_main dummy_format;

	john_register_one(&fmt_AFS);
	john_register_one(&fmt_LM);

	/* new ciphers */
	john_register_one(&fmt_MD5_apache);
	john_register_one(&fmt_MYSQL);
	john_register_one(&fmt_NSLDAP);
	john_register_one(&fmt_NT);
	john_register_one(&fmt_lotus5);
	john_register_one(&fmt_mscash);
	john_register_one(&fmt_rawMD5);
	john_register_one(&fmt_BFEgg);
	john_register_one(&fmt_rawSHA1);
	john_register_one(&fmt_mssql);
	john_register_one(&fmt_hmacMD5);
	john_register_one(&fmt_WPAPSK);
	john_register_one(&fmt_oracle);
	#ifdef MMX_COEF
		john_register_one(&fmt_NTmmx);
	#endif

	if (!fmt_list) {
		fprintf(stderr, "Unknown ciphertext format name requested\n");
		error();

	if (!strcmp(name, "unique"))
		return unique(argc, argv);

	if (!strcmp(name, "undrop"))
		return undrop(argc, argv);

	john_init(name, argc, argv);
	john_run();
	john_done();




		if (!strncmp(*ciphertext, "NO PASSWORD", 11))
			*ciphertext = "";

		/* NT loader hack starts here ! */
		extern struct fmt_main fmt_NT;

		/* TODO test !!! */
		if (&fmt_NT == *format) {

			/*
				tmp = ldr_get_field(&line);
				*ciphertext = tmp;
			*/

			if (!strncmp(*ciphertext, "NO PASSWORD", 11))
				*ciphertext = "";
			else {
				*ciphertext -= 4;
				strncpy(*ciphertext,"$NT$",4);
			}
		}

		/* NT loader hack ends here ! */

		if (source) sprintf(source, "%s:%s", uid, line);
	}


	struct list_main *words;
	size_t pw_size, salt_size;

	extern struct fmt_main fmt_mscash;
	extern struct fmt_main fmt_oracle;

	count = ldr_split_line(&login, &ciphertext, &gecos, &home,
		NULL, &db->format, db->options, line);
	if (count <= 0) return;

	}

	for (index = 0; index < count; index++) {
		if (db->format == &fmt_mscash) {
			piece = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
			sprintf(piece, "M$%s#%s", login, ciphertext);
		} else if (db->format == &fmt_oracle) {
			piece = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
			sprintf(piece, "O$%s#%s", login, ciphertext);
		} else
			piece = format->methods.split(ciphertext, index);

		binary = format->methods.binary(piece);
		pw_hash = LDR_HASH_FUNC(binary);

	int hash;
	struct db_cracked *current;

	extern struct fmt_main fmt_mscash;
	extern struct fmt_main fmt_oracle;

	format = NULL;
	count = ldr_split_line(&login, &ciphertext, &gecos, &home,
		source, &format, db->options, line);


	if (format) {
		split = format->methods.split;
 		if (format == &fmt_mscash) {
 			char * ciphertext2 = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
 			sprintf(ciphertext2, "M$%s#%s", login, ciphertext);
 			ciphertext = ciphertext2;
 		}
 		if (format == &fmt_oracle) {
 			char * ciphertext2 = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
 			sprintf(ciphertext2, "O$%s#%s", login, ciphertext);
 			ciphertext = ciphertext2;
 		}
		unify = format->params.flags & FMT_SPLIT_UNIFIES_CASE;
	} else {
		split = fmt_default_split;

			MEM_FREE(piece);

		if (pass) {
 			/* modification by bartavelle, catches the no format bug */
 			/*
	 			if(format)
 					chars = format->params.plaintext_length;
 				else
 					chars = 0;
 
	 			if (current && show && index < count - 1)
	 			if ((int)strlen(current->plaintext) != chars)
 					current = NULL;
 			*/

			chars = 0;
			if (show) {
				if (format)


				db->guess_count++;
			} else
			/*
				if (show)
				do {
					putchar('?');
				} while (--chars);
			*/

			while (chars--)
				putchar('?');
		} else




//original work by Jeff Fay
//some optimisations by bartavelle@bandecon.com

#include <stdio.h>
#include <string.h>
#include "misc.h"
#include "formats.h"
#include "common.h"

/*preprocessor constants that John The Ripper likes*/
#define FORMAT_LABEL                   "lotus5"
#define FORMAT_NAME                    "Lotus5"
#define ALGORITHM_NAME			"Lotus v5 Proprietary"
#define BENCHMARK_COMMENT              ""
#define BENCHMARK_LENGTH               -1
#define PLAINTEXT_LENGTH               16
#define CIPHERTEXT_LENGTH              32
#define BINARY_SIZE                    16
#define SALT_SIZE                      0
#define MIN_KEYS_PER_CRYPT             1
#define MAX_KEYS_PER_CRYPT             1

/*A struct used for JTR's benchmarks*/
static struct fmt_tests tests[] = {
  {"06E0A50B579AD2CD5FFDC48564627EE7", "secret"},
  {"355E98E7C7B59BD810ED845AD0FD2FC4", "password"},
  {"CD2D90E8E00D8A2A63A81F531EA8A9A3", "lotus"},
  {"69D90B46B1AC0912E5CCF858094BBBFC", "dirtydog"},
  {NULL}
};

static const char lotus_magic_table[256] = {
  0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a,
  0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0,
  0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b,
  0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a,
  0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda,
  0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36,
  0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8,
  0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c,
  0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17,
  0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60,
  0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72,
  0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa,
  0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd,
  0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e,
  0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b,
  0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf,
  0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77,
  0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6,
  0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3,
  0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3,
  0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e,
  0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c,
  0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d,
  0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2,
  0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46,
  0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5,
  0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97,
  0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5,
  0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef,
  0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f,
  0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf,
  0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab,
};

/*Some more JTR variables*/
static char crypt_key[BINARY_SIZE+1];
static char saved_key[PLAINTEXT_LENGTH + 1];

/*Utility function to convert hex to bin */
static void * binary (char *ciphertext)
{
  static char realcipher[BINARY_SIZE];
  int i;
  for (i = 0; i < BINARY_SIZE; i++)
      realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
  return ((void *) realcipher);
}

/*Another function required by JTR: decides whether we have a valid
 * ciphertext */
static int
valid (char *ciphertext)
{
  int i;
  
  for (i = 0; i < CIPHERTEXT_LENGTH; i++)
	  if (!(((ciphertext[i] >= '0') && (ciphertext[i] <= '9'))
				  || ((ciphertext[i] >= 'a') && (ciphertext[i] <= 'f'))
				  || ((ciphertext[i] >= 'A') && (ciphertext[i] <= 'F'))))
	  {
		  return 0;
	  }
  return 1;
}

/*sets the value of saved_key so we can play with it*/
static void set_key (char *key, int index)
{
  strnzcpy (saved_key, key, PLAINTEXT_LENGTH + 1);
}

/*retrieves the saved key; used by JTR*/
static char * get_key (int index)
{
  return saved_key;
}
static int
cmp_all (void *binary, int index)
{
	int i = 0;
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
	return 1;
}
static int cmp_exact (char *source, int index) 
{
  return 1;
}

static void set_salt (void *salt) { }


/*Beginning of private functions*/
/* Takes the plaintext password and generates the second row of our
 * working matrix for the final call to the mixing function*/
void
lotus_transform_password (unsigned char *inpass, unsigned char *outh)
{
  unsigned char prevbyte;
  int i;

  prevbyte = 0x00;
  for (i = 0; i < 16; i++)
    {
      *outh = lotus_magic_table[ARCH_INDEX((*inpass) ^ prevbyte)];
      prevbyte = *outh;
      ++outh;
      ++inpass;
    }
}

/* The mixing function: perturbs the first three rows of the matrix*/
void lotus_mix (unsigned char *lotus_matrix)
{
  int i, j;
  unsigned char prevbyte;
  unsigned char *temp;

  prevbyte = 0x00;

  for (i = 18; i > 0; i--)
    {
      temp = lotus_matrix;
      for (j = 48; j > 0; j--)
	{
	  *temp = *temp ^ lotus_magic_table[ARCH_INDEX((j + prevbyte) & 0xff)];
	  prevbyte = *temp;
	  temp++;
	}
    }
}


/*the last public function; generates ciphertext*/
static void crypt_all (int count)
{
  unsigned char password[PLAINTEXT_LENGTH];
  unsigned char lotus_matrix[64], *lotus_matrix1, *lotus_matrix2, *lotus_matrix3, *lotus_matrix4;
  int i;
  int password_length;

  password_length = strlen (saved_key);
  memset (password, (PLAINTEXT_LENGTH - password_length), PLAINTEXT_LENGTH);
  lotus_matrix1 = lotus_matrix;
  lotus_matrix2 = lotus_matrix1 + 16;
  lotus_matrix3 = lotus_matrix2 + 16;
  lotus_matrix4 = lotus_matrix3 + 16;
  memcpy (password, saved_key, password_length);

  memset (lotus_matrix1, 0, 16);
  memcpy (lotus_matrix2, password, 16);
  memcpy (lotus_matrix3, password, 16);
  lotus_transform_password (lotus_matrix2, lotus_matrix4);
  lotus_mix (lotus_matrix);
  memcpy (lotus_matrix2, lotus_matrix4, 16);
  for (i = 0; i < 16; i++)
    {
      lotus_matrix3[i] = lotus_matrix1[i] ^ lotus_matrix2[i];
    }
  lotus_mix (lotus_matrix);
  memcpy (crypt_key, lotus_matrix1, BINARY_SIZE);
}

static int get_hash1(int index) { return (((unsigned int *)crypt_key)[0] & 0xf); }
static int get_hash2(int index) { return (((unsigned int *)crypt_key)[0] & 0xff); }
static int get_hash3(int index) { return (((unsigned int *)crypt_key)[0] & 0xfff); }
static int binary_hash1(void * binary) { return (((unsigned int *)binary)[0] & 0xf); }
static int binary_hash2(void * binary) { return (((unsigned int *)binary)[0] & 0xff); }
static int binary_hash3(void * binary) { return (((unsigned int *)binary)[0] & 0xfff); }

/* C's version of a class specifier */
struct fmt_main fmt_lotus5 = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		binary,
		fmt_default_salt,
		{
			binary_hash1,
                        binary_hash2,
                        binary_hash3
		},
		fmt_default_salt_hash,
		set_salt,
		set_key,
		get_key,
		fmt_default_clear_keys,
		crypt_all,
		{
			get_hash1,
                        get_hash2,
                        get_hash3
		},
		cmp_all,
		cmp_all,
		cmp_exact}
};





// extern int mdfourmmx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));

#ifdef UNDERSCORES
#define mdfourmmx	_mdfourmmx
#endif

.globl mdfourmmx

.data
.align(16)
const_init_a:
.long 0x67452301
.long 0x67452301
const_init_b:
.long 0xefcdab89
.long 0xefcdab89
const_init_c:
.long 0x98badcfe
.long 0x98badcfe
const_init_d:
.long 0x10325476
.long 0x10325476

const_stage2:
.long 0x5a827999
.long 0x5a827999
const_stage3:
.long 0x6ed9eba1
.long 0x6ed9eba1

.align(16)
buffer:
.zero(64*2)

#define ctxa %mm0
#define ctxb %mm1
#define ctxc %mm2
#define ctxd %mm3
#define tmp1 %mm4
#define tmp2 %mm5
#define tmp3 %mm6
#define tmp4 %mm7


//#define F_MMX(x, y, z)			(z ^ (x & (y ^ z)))

#define F(x,y,z) \
	movq y, tmp1; \
	pxor z, tmp1; \
	pand x, tmp1; \
	pxor z, tmp1

//#define G_MMX(x, y, z)			((x & (y | z)) | (y & z))

#define G(x,y,z) \
	movq y, tmp1; \
	movq y, tmp2; \
	por z, tmp1; \
	pand z, tmp2; \
	pand x, tmp1; \
	por tmp2, tmp1

//#define H_MMX(x, y, z)			(x ^ y ^ z)
#define H(x,y,z) \
	movq x, tmp1; \
	pxor y, tmp1; \
	pxor z, tmp1

//#define STEP_MMX(f, a, b, c, d, x, s) \
//	(a) += f((b), (c), (d)) + (x); \
//	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));

#define STEP1(f, a, b, c, d, x, s) \
	f(b, c, d); \
	paddd (x*8)(%edx), tmp1; \
	paddd tmp1, a; \
	movq a, tmp3; \
	pslld $s, a; \
	psrld $(32-s), tmp3; \
	por tmp3, a

#define STEP2(f, a, b, c, d, x, s) \
	f(b, c, d); \
	paddd (x*8)(%edx), tmp1; \
	paddd tmp4, tmp1; \
	paddd tmp1, a; \
	movq a, tmp3; \
	pslld $s, a; \
	psrld $(32-s), tmp3; \
	por tmp3, a


.text
/*
 * Try to do some asm md4 w/ mmx
 * %eax ptr -> out
 * %edx ptr -> in
 * %ecx n
 */

mdfourmmx:
	 //MD4 Init
	 pusha
	
	shl $3, %ecx
	mov %ecx, %ebx
	and $0xffff, %ecx
	shrl $16,  %ebx
	// %ecx contient la taille du premier mdp
	// %edx celle du second
	mov %ecx, (14*8)(%edx)
	mov %ebx, (14*8+4)(%edx)

	movq const_init_a, ctxa
	movq const_init_b, ctxb
	movq const_init_c, ctxc
	movq const_init_d, ctxd

	STEP1(F, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 1, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 2, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 3, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 4, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 5, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 6, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 7, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 8, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 9, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 10, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 11, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 12, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 13, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 14, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 15, 19)

	movq const_stage2, tmp4

	STEP2(G, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 4, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 8, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 12, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 1, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 5, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 9, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 13, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 2, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 6, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 10, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 14, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 3, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 7, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 11, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 15, 13)

	movq const_stage3, tmp4

	STEP2(H, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 8, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 4, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 12, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 2, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 10, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 6, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 14, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 1, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 9, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 5, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 13, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 3, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 11, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 7, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 15, 15)

	paddd const_init_a, ctxa
	paddd const_init_b, ctxb
	paddd const_init_c, ctxc
	paddd const_init_d, ctxd


	movq ctxa, 0(%eax)
	movq ctxb, 8(%eax)
	movq ctxc, 16(%eax)
	movq ctxd, 24(%eax)

	popa
	movd ctxa, %eax
	emms
	
	ret

#ifdef __ELF__
.section .note.GNU-stack,"",@progbits
#endif





// extern int mdfoursse2(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));

#ifdef UNDERSCORES
#define mdfoursse2	_mdfoursse2
#endif

.globl mdfoursse2

.data
.align(16)
const_init_a:
.long 0x67452301
.long 0x67452301
.long 0x67452301
.long 0x67452301
const_init_b:
.long 0xefcdab89
.long 0xefcdab89
.long 0xefcdab89
.long 0xefcdab89
const_init_c:
.long 0x98badcfe
.long 0x98badcfe
.long 0x98badcfe
.long 0x98badcfe
const_init_d:
.long 0x10325476
.long 0x10325476
.long 0x10325476
.long 0x10325476

const_stage2:
.long 0x5a827999
.long 0x5a827999
.long 0x5a827999
.long 0x5a827999
const_stage3:
.long 0x6ed9eba1
.long 0x6ed9eba1
.long 0x6ed9eba1
.long 0x6ed9eba1

.align(16)
buffer:
.zero(64*4)

#define ctxa %xmm0
#define ctxb %xmm1
#define ctxc %xmm2
#define ctxd %xmm3
#define tmp1 %xmm4
#define tmp2 %xmm5
#define tmp3 %xmm6
#define tmp4 %xmm7


//#define F_MMX(x, y, z)			(z ^ (x & (y ^ z)))

#define F(x,y,z) \
	movapd y, tmp1; \
	pxor z, tmp1; \
	pand x, tmp1; \
	pxor z, tmp1

//#define G_MMX(x, y, z)			((x & (y | z)) | (y & z))

#define G(x,y,z) \
	movapd y, tmp1; \
	movapd y, tmp2; \
	por z, tmp1; \
	pand z, tmp2; \
	pand x, tmp1; \
	por tmp2, tmp1

//#define H_MMX(x, y, z)			(x ^ y ^ z)
#define H(x,y,z) \
	movapd x, tmp1; \
	pxor y, tmp1; \
	pxor z, tmp1

//#define STEP_MMX(f, a, b, c, d, x, s) \
//	(a) += f((b), (c), (d)) + (x); \
//	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));

#define STEP1(f, a, b, c, d, x, s) \
	f(b, c, d); \
	paddd (x*16)(%edx), tmp1; \
	paddd tmp1, a; \
	movapd a, tmp3; \
	pslld $s, a; \
	psrld $(32-s), tmp3; \
	por tmp3, a

#define STEP2(f, a, b, c, d, x, s) \
	f(b, c, d); \
	paddd (x*16)(%edx), tmp1; \
	paddd tmp4, tmp1; \
	paddd tmp1, a; \
	movapd a, tmp3; \
	pslld $s, a; \
	psrld $(32-s), tmp3; \
	por tmp3, a


.text
/*
 * Try to do some asm md4 w/ sse2
 * %eax ptr -> out
 * %edx ptr -> in
 * %ecx n
 */

mdfoursse2:
	 //MD4 Init
	 pusha
	
	//mov %edx, %eax
	//ret

//	shl $3, %ecx
	mov %ecx, %ebx
	shr $8, %ecx
	and $0xff, %ebx
	shl $3, %ebx
	mov %ebx, (14*16)(%edx)
	
	mov %ecx, %ebx
	shr $8, %ecx
	and $0xff, %ebx
	shl $3, %ebx
	mov %ebx, (14*16+4)(%edx)

	mov %ecx, %ebx
	shr $8, %ecx
	and $0xff, %ebx
	shl $3, %ebx
	mov %ebx, (14*16+8)(%edx)

	and $0xff, %ecx
	shl $3, %ecx
	mov %ecx, (14*16+12)(%edx)

	movapd const_init_a, ctxa
	movapd const_init_b, ctxb
	movapd const_init_c, ctxc
	movapd const_init_d, ctxd

	STEP1(F, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 1, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 2, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 3, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 4, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 5, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 6, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 7, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 8, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 9, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 10, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 11, 19)
	STEP1(F, ctxa, ctxb, ctxc, ctxd, 12, 3)
	STEP1(F, ctxd, ctxa, ctxb, ctxc, 13, 7)
	STEP1(F, ctxc, ctxd, ctxa, ctxb, 14, 11)
	STEP1(F, ctxb, ctxc, ctxd, ctxa, 15, 19)

	movapd const_stage2, tmp4

	STEP2(G, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 4, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 8, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 12, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 1, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 5, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 9, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 13, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 2, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 6, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 10, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 14, 13)
	STEP2(G, ctxa, ctxb, ctxc, ctxd, 3, 3)
	STEP2(G, ctxd, ctxa, ctxb, ctxc, 7, 5)
	STEP2(G, ctxc, ctxd, ctxa, ctxb, 11, 9)
	STEP2(G, ctxb, ctxc, ctxd, ctxa, 15, 13)

	movapd const_stage3, tmp4

	STEP2(H, ctxa, ctxb, ctxc, ctxd, 0, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 8, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 4, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 12, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 2, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 10, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 6, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 14, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 1, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 9, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 5, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 13, 15)
	STEP2(H, ctxa, ctxb, ctxc, ctxd, 3, 3)
	STEP2(H, ctxd, ctxa, ctxb, ctxc, 11, 9)
	STEP2(H, ctxc, ctxd, ctxa, ctxb, 7, 11)
	STEP2(H, ctxb, ctxc, ctxd, ctxa, 15, 15)

	paddd const_init_a, ctxa
	paddd const_init_b, ctxb
	paddd const_init_c, ctxc
	paddd const_init_d, ctxd


	movapd ctxa, 0(%eax)
	movapd ctxb, 16(%eax)
	movapd ctxc, 32(%eax)
	movapd ctxd, 48(%eax)

	popa
	movd ctxa, %eax
	emms
	
	ret

#ifdef __ELF__
.section .note.GNU-stack,"",@progbits
#endif




/*
 * This is an OpenSSL-compatible implementation of the RSA Data Security,
 * Inc. MD4 Message-Digest Algorithm (RFC 1320).
 *
 * Written by Solar Designer <solar at openwall.com> in 2005, and placed
 * in the public domain.  There's absolutely no warranty.
 *
 * This differs from Colin Plumb's older public domain implementation in
 * that no 32-bit integer data type is required, there's no compile-time
 * endianness configuration, and the function prototypes match OpenSSL's.
 * The primary goals are portability and ease of use.
 *
 * This implementation is meant to be fast, but not as fast as possible.
 * Some known optimizations are not included to reduce source code size
 * and avoid compile-time configuration.
 */

#ifndef HAVE_OPENSSL

#include <string.h>
#include "md4.h"

/*
 * The basic MD4 functions.
 *
 * F and G are optimized compared to their RFC 1320 definitions, with the
 * optimization for F borrowed from Colin Plumb's MD5 implementation.
 */
#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z)			(((x) & ((y) | (z))) | ((y) & (z)))
#define H(x, y, z)			((x) ^ (y) ^ (z))

/*
 * The MD4 transformation for all three rounds.
 */
#define STEP(f, a, b, c, d, x, s) \
	(a) += f((b), (c), (d)) + (x); \
	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));

/*
 * SET reads 4 input bytes in little-endian byte order and stores them
 * in a properly aligned word in host byte order.
 *
 * The check for little-endian architectures which tolerate unaligned
 * memory accesses is just an optimization.  Nothing will break if it
 * doesn't work.
 */
#if defined(__i386__) || defined(__vax__)
#define SET(n) \
	(*(MD4_u32plus *)&ptr[(n) * 4])
#define GET(n) \
	SET(n)
#else
#define SET(n) \
	(ctx->block[(n)] = \
	(MD4_u32plus)ptr[(n) * 4] | \
	((MD4_u32plus)ptr[(n) * 4 + 1] << 8) | \
	((MD4_u32plus)ptr[(n) * 4 + 2] << 16) | \
	((MD4_u32plus)ptr[(n) * 4 + 3] << 24))
#define GET(n) \
	(ctx->block[(n)])
#endif

/*
 * This processes one or more 64-byte data blocks, but does NOT update
 * the bit counters.  There're no alignment requirements.
 */
static void *body(MD4_CTX *ctx, void *data, unsigned long size)
{
	unsigned char *ptr;
	MD4_u32plus a, b, c, d;
	MD4_u32plus saved_a, saved_b, saved_c, saved_d;

	ptr = data;

	a = ctx->a;
	b = ctx->b;
	c = ctx->c;
	d = ctx->d;

	do {
		saved_a = a;
		saved_b = b;
		saved_c = c;
		saved_d = d;

/* Round 1 */
		STEP(F, a, b, c, d, SET(0), 3)
		STEP(F, d, a, b, c, SET(1), 7)
		STEP(F, c, d, a, b, SET(2), 11)
		STEP(F, b, c, d, a, SET(3), 19)
		STEP(F, a, b, c, d, SET(4), 3)
		STEP(F, d, a, b, c, SET(5), 7)
		STEP(F, c, d, a, b, SET(6), 11)
		STEP(F, b, c, d, a, SET(7), 19)
		STEP(F, a, b, c, d, SET(8), 3)
		STEP(F, d, a, b, c, SET(9), 7)
		STEP(F, c, d, a, b, SET(10), 11)
		STEP(F, b, c, d, a, SET(11), 19)
		STEP(F, a, b, c, d, SET(12), 3)
		STEP(F, d, a, b, c, SET(13), 7)
		STEP(F, c, d, a, b, SET(14), 11)
		STEP(F, b, c, d, a, SET(15), 19)

/* Round 2 */
		STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
		STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
		STEP(G, c, d, a, b, GET(8) + 0x5a827999, 9)
		STEP(G, b, c, d, a, GET(12) + 0x5a827999, 13)
		STEP(G, a, b, c, d, GET(1) + 0x5a827999, 3)
		STEP(G, d, a, b, c, GET(5) + 0x5a827999, 5)
		STEP(G, c, d, a, b, GET(9) + 0x5a827999, 9)
		STEP(G, b, c, d, a, GET(13) + 0x5a827999, 13)
		STEP(G, a, b, c, d, GET(2) + 0x5a827999, 3)
		STEP(G, d, a, b, c, GET(6) + 0x5a827999, 5)
		STEP(G, c, d, a, b, GET(10) + 0x5a827999, 9)
		STEP(G, b, c, d, a, GET(14) + 0x5a827999, 13)
		STEP(G, a, b, c, d, GET(3) + 0x5a827999, 3)
		STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
		STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
		STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)

/* Round 3 */
		STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
		STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
		STEP(H, c, d, a, b, GET(4) + 0x6ed9eba1, 11)
		STEP(H, b, c, d, a, GET(12) + 0x6ed9eba1, 15)
		STEP(H, a, b, c, d, GET(2) + 0x6ed9eba1, 3)
		STEP(H, d, a, b, c, GET(10) + 0x6ed9eba1, 9)
		STEP(H, c, d, a, b, GET(6) + 0x6ed9eba1, 11)
		STEP(H, b, c, d, a, GET(14) + 0x6ed9eba1, 15)
		STEP(H, a, b, c, d, GET(1) + 0x6ed9eba1, 3)
		STEP(H, d, a, b, c, GET(9) + 0x6ed9eba1, 9)
		STEP(H, c, d, a, b, GET(5) + 0x6ed9eba1, 11)
		STEP(H, b, c, d, a, GET(13) + 0x6ed9eba1, 15)
		STEP(H, a, b, c, d, GET(3) + 0x6ed9eba1, 3)
		STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
		STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
		STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)

		a += saved_a;
		b += saved_b;
		c += saved_c;
		d += saved_d;

		ptr += 64;
	} while (size -= 64);

	ctx->a = a;
	ctx->b = b;
	ctx->c = c;
	ctx->d = d;

	return ptr;
}

void MD4_Init(MD4_CTX *ctx)
{
	ctx->a = 0x67452301;
	ctx->b = 0xefcdab89;
	ctx->c = 0x98badcfe;
	ctx->d = 0x10325476;

	ctx->lo = 0;
	ctx->hi = 0;
}

void MD4_Update(MD4_CTX *ctx, void *data, unsigned long size)
{
	MD4_u32plus saved_lo;
	unsigned long used, free;

	saved_lo = ctx->lo;
	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
		ctx->hi++;
	ctx->hi += size >> 29;

	used = saved_lo & 0x3f;

	if (used) {
		free = 64 - used;

		if (size < free) {
			memcpy(&ctx->buffer[used], data, size);
			return;
		}
		
		memcpy(&ctx->buffer[used], data, free);

		data = (unsigned char *)data + free;
		size -= free;
		body(ctx, ctx->buffer, 64);
	}

	if (size >= 64) {
		data = body(ctx, data, size & ~(unsigned long)0x3f);
		size &= 0x3f;
	}

	memcpy(ctx->buffer, data, size);
}

void MD4_Final(unsigned char *result, MD4_CTX *ctx)
{
	unsigned long used, free;

	used = ctx->lo & 0x3f;

	ctx->buffer[used++] = 0x80;

	free = 64 - used;

	if (free < 8) {
		memset(&ctx->buffer[used], 0, free);
		body(ctx, ctx->buffer, 64);
		used = 0;
		free = 64;
	}

	memset(&ctx->buffer[used], 0, free - 8);


	ctx->lo <<= 3;
#ifndef ARCH_LITTLE_ENDIAN
	ctx->buffer[56] = ctx->lo;
	ctx->buffer[57] = ctx->lo >> 8;
	ctx->buffer[58] = ctx->lo >> 16;
	ctx->buffer[59] = ctx->lo >> 24;
	ctx->buffer[60] = ctx->hi;
	ctx->buffer[61] = ctx->hi >> 8;
	ctx->buffer[62] = ctx->hi >> 16;
	ctx->buffer[63] = ctx->hi >> 24;
#else
	((unsigned long *)ctx->buffer)[14] = ctx->lo;
	((unsigned long *)ctx->buffer)[15] = ctx->hi;
#endif

	body(ctx, ctx->buffer, 64);

#ifndef ARCH_LITTLE_ENDIAN
	result[0] = ctx->a;
	result[1] = ctx->a >> 8;
	result[2] = ctx->a >> 16;
	result[3] = ctx->a >> 24;
	result[4] = ctx->b;
	result[5] = ctx->b >> 8;
	result[6] = ctx->b >> 16;
	result[7] = ctx->b >> 24;
	result[8] = ctx->c;
	result[9] = ctx->c >> 8;
	result[10] = ctx->c >> 16;
	result[11] = ctx->c >> 24;
	result[12] = ctx->d;
	result[13] = ctx->d >> 8;
	result[14] = ctx->d >> 16;
	result[15] = ctx->d >> 24;
#else
	((unsigned long *)result)[0] = ctx->a;
	((unsigned long *)result)[1] = ctx->b;
	((unsigned long *)result)[2] = ctx->c;
	((unsigned long *)result)[3] = ctx->d;
#endif

	memset(ctx, 0, sizeof(*ctx));
}

//this function has been added by bartavelle at bandecon.com
void mdfour(unsigned char *out, unsigned char *in, int n)
{
	MD4_CTX ctx;
	MD4_Init(&ctx);
	MD4_Update(&ctx, in, n);
	MD4_Final(out, &ctx);
}

#endif




/*
 * This is an OpenSSL-compatible implementation of the RSA Data Security,
 * Inc. MD4 Message-Digest Algorithm (RFC 1320).
 *
 * Written by Solar Designer <solar at openwall.com> in 2005, and placed
 * in the public domain.  See md4.c for more information.
 */

#ifdef HAVE_OPENSSL
#include <openssl/md4.h>
#elif !defined(_MD4_H)
#define _MD4_H

/* Any 32-bit or wider unsigned integer data type will do */
typedef unsigned long MD4_u32plus;

typedef struct {
	MD4_u32plus lo, hi;
	MD4_u32plus a, b, c, d;
	unsigned char buffer[64];
	MD4_u32plus block[16];
} MD4_CTX;

extern void MD4_Init(MD4_CTX *ctx);
extern void MD4_Update(MD4_CTX *ctx, void *data, unsigned long size);
extern void MD4_Final(unsigned char *result, MD4_CTX *ctx);

//added by bartavelle
extern void mdfour(unsigned char *out, unsigned char *in, int n);

#if (MMX_COEF == 2)
extern int mdfourmmx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
#endif

#if (MMX_COEF == 4)
extern int mdfoursse2(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
#endif

#endif




#include "arch.h"

// extern int mdfourmmx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));

#ifdef UNDERSCORES
#define mdfivemmx	_mdfivemmx
#endif
.globl mdfivemmx
.globl mdfivemmx_noinit_sizeupdate
.globl mdfivemmx_noinit_uniformsizeupdate
.globl mdfivemmx_nosizeupdate

.data
.align(16)
#if (MMX_COEF == 2)
const_init_a: ; .long 0x67452301 ; .long 0x67452301
const_init_b: ; .long 0xefcdab89 ; .long 0xefcdab89
const_init_c: ; .long 0x98badcfe ; .long 0x98badcfe
const_init_d: ; .long 0x10325476 ; .long 0x10325476
storea: ; .long 0 ; .long 0
storeb: ; .long 0 ; .long 0
storec: ; .long 0 ; .long 0
stored: ; .long 0 ; .long 0
#define REGMM0 %mm0
#define REGMM1 %mm1
#define REGMM2 %mm2
#define REGMM3 %mm3
#define REGMM4 %mm4
#define REGMM5 %mm5
#define REGMM6 %mm6
#define REGMM7 %mm7
#define MMXMOVE movq
#include "stages_mmx_md5.S"
#else
const_init_a: ; .long 0x67452301 ; .long 0x67452301 ; .long 0x67452301 ; .long 0x67452301
const_init_b: ; .long 0xefcdab89 ; .long 0xefcdab89 ; .long 0xefcdab89 ; .long 0xefcdab89
const_init_c: ; .long 0x98badcfe ; .long 0x98badcfe ; .long 0x98badcfe ; .long 0x98badcfe
const_init_d: ; .long 0x10325476 ; .long 0x10325476 ; .long 0x10325476 ; .long 0x10325476
storea: ; .long 0 ; .long 0 ; .long 0 ; .long 0
storeb: ; .long 0 ; .long 0 ; .long 0 ; .long 0
storec: ; .long 0 ; .long 0 ; .long 0 ; .long 0
stored: ; .long 0 ; .long 0 ; .long 0 ; .long 0
#define REGMM0 %xmm0
#define REGMM1 %xmm1
#define REGMM2 %xmm2
#define REGMM3 %xmm3
#define REGMM4 %xmm4
#define REGMM5 %xmm5
#define REGMM6 %xmm6
#define REGMM7 %xmm7
#define MMXMOVE movapd
#include "stages_sse2_md5.S"
#endif


#define ctxa REGMM0
#define ctxb REGMM1
#define ctxc REGMM2
#define ctxd REGMM3
#define tmp1 REGMM4
#define tmp2 REGMM5
#define tmp3 REGMM6
#define tmp4 REGMM7


//#define F_MMX(x, y, z)			(z ^ (x & (y ^ z)))

#define F(x,y,z) \
	MMXMOVE y, tmp1; \
	pxor z, tmp1; \
	pand x, tmp1; \
	pxor z, tmp1

//#define G_MMX(x, y, z)			(y ^ (z & (x ^ y)))

#define G(x,y,z) \
	MMXMOVE y, tmp1; \
	pxor x, tmp1; \
	pand z, tmp1; \
	pxor y, tmp1

//#define H_MMX(x, y, z)			(x ^ y ^ z)
#define H(x,y,z) \
	MMXMOVE x, tmp1; \
	pxor y, tmp1; \
	pxor z, tmp1

//#define I(x, y, z)			(y ^ (x | ~z))
#define I(x, y, z) \
	MMXMOVE z, tmp1; \
	pandn tmp4, tmp1; \
	por x, tmp1; \
	pxor y, tmp1;


//#define STEP_MMX(f, a, b, c, d, x, s) \
//	(a) += f((b), (c), (d)) + (x); \
//	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));

//#define STEP(f, a, b, c, d, x, t, s) \
//	(a) += f((b), (c), (d)) + (x) + (t); \
//	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
//	(a) += (b);


#define STEP(f, a, b, c, d, x, t, s) \
	f(b, c, d); \
	paddd (x*4*MMX_COEF)(%edx), tmp1; \
	paddd t, a; \
	paddd tmp1, a; \
	MMXMOVE a, tmp3; \
	psrld $(32-s), tmp3; \
	pslld $s, a; \
	por tmp3, a; \
	paddd b, a

#define STEPD(f, a, b, c, d, x, t, s) \
	f(b, c, d); \
	paddd (x*4*MMX_COEF)(%edx), tmp1; \
	paddd t, a; \
	paddd tmp1, a; \
	MMXMOVE a, tmp3; \
	psrld $(32-s), tmp3; \
	pslld $s, a; \
	por tmp3, a; \
	paddd b, a


.text
/*
 * Try to do some asm md4 w/ mmx
 * %eax ptr -> out
 * %edx ptr -> in
 * %ecx n
 */

init:
	MMXMOVE const_init_a, ctxa
	MMXMOVE const_init_b, ctxb
	MMXMOVE const_init_c, ctxc
	MMXMOVE const_init_d, ctxd
	ret;

sizeupdate:
#if (MMX_COEF == 2)
	shl $3, %ecx
	mov %ecx, %ebx
	and $0xffff, %ecx
	shrl $16,  %ebx
	mov %ecx, (14*4*MMX_COEF)(%edx)
	mov %ebx, (14*4*MMX_COEF+4)(%edx)
#else
	mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (14*16)(%edx)
        
        mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (14*16+4)(%edx)

        mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (14*16+8)(%edx)

        and $0xff, %ecx
        shl $3, %ecx
        mov %ecx, (14*16+12)(%edx)
#endif
	ret

uniformsizeupdate:
	shl $3, %ecx
	mov %ecx, (14*4*MMX_COEF)(%edx)
	mov %ecx, (14*4*MMX_COEF+4)(%edx)
#if (MMX_COEF == 4)
	mov %ecx, (14*4*MMX_COEF+8)(%edx)
	mov %ecx, (14*4*MMX_COEF+12)(%edx)
#endif
	ret

//entry points
mdfivemmx_noinit_sizeupdate:
	pusha
	call sizeupdate
	jmp mdfivemmx_noinit

mdfivemmx_noinit_uniformsizeupdate:
	pusha
	call uniformsizeupdate
	jmp mdfivemmx_noinit

mdfivemmx:
	pusha
	call sizeupdate
	call init
	jmp mdfivemmx_noinit

mdfivemmx_nosizeupdate:
	pusha
	call init
	jmp mdfivemmx_noinit
//end entry points

mdfivemmx_noinit:
	pcmpeqd tmp4, tmp4;
	MMXMOVE ctxa, storea
	MMXMOVE ctxb, storeb
	MMXMOVE ctxc, storec
	MMXMOVE ctxd, stored

	STEP(F, ctxa, ctxb, ctxc, ctxd, 0, const_stage_1, 7)
	STEP(F, ctxd, ctxa, ctxb, ctxc, 1, const_stage_2, 12)
	STEP(F, ctxc, ctxd, ctxa, ctxb, 2, const_stage_3, 17)
	STEP(F, ctxb, ctxc, ctxd, ctxa, 3, const_stage_4, 22)
	STEP(F, ctxa, ctxb, ctxc, ctxd, 4, const_stage_5, 7)
	STEP(F, ctxd, ctxa, ctxb, ctxc, 5, const_stage_6, 12)
	STEP(F, ctxc, ctxd, ctxa, ctxb, 6, const_stage_7, 17)
	STEP(F, ctxb, ctxc, ctxd, ctxa, 7, const_stage_8, 22)
	STEP(F, ctxa, ctxb, ctxc, ctxd, 8, const_stage_9, 7)
	STEP(F, ctxd, ctxa, ctxb, ctxc, 9, const_stage_10, 12)
	STEP(F, ctxc, ctxd, ctxa, ctxb, 10, const_stage_11, 17)
	STEP(F, ctxb, ctxc, ctxd, ctxa, 11, const_stage_12, 22)
	STEP(F, ctxa, ctxb, ctxc, ctxd, 12, const_stage_13, 7)
	STEP(F, ctxd, ctxa, ctxb, ctxc, 13, const_stage_14, 12)
	STEP(F, ctxc, ctxd, ctxa, ctxb, 14, const_stage_15, 17)
	STEP(F, ctxb, ctxc, ctxd, ctxa, 15, const_stage_16, 22)

	STEP(G, ctxa, ctxb, ctxc, ctxd, 1, const_stage_17, 5)
	STEP(G, ctxd, ctxa, ctxb, ctxc, 6, const_stage_18, 9)
	STEP(G, ctxc, ctxd, ctxa, ctxb, 11, const_stage_19, 14)
	STEP(G, ctxb, ctxc, ctxd, ctxa, 0, const_stage_20, 20)
	STEP(G, ctxa, ctxb, ctxc, ctxd, 5, const_stage_21, 5)
	STEP(G, ctxd, ctxa, ctxb, ctxc, 10, const_stage_22, 9)
	STEP(G, ctxc, ctxd, ctxa, ctxb, 15, const_stage_23, 14)
	STEP(G, ctxb, ctxc, ctxd, ctxa, 4, const_stage_24, 20)
	STEP(G, ctxa, ctxb, ctxc, ctxd, 9, const_stage_25, 5)
	STEP(G, ctxd, ctxa, ctxb, ctxc, 14, const_stage_26, 9)
	STEP(G, ctxc, ctxd, ctxa, ctxb, 3, const_stage_27, 14)
	STEP(G, ctxb, ctxc, ctxd, ctxa, 8, const_stage_28, 20)
	STEP(G, ctxa, ctxb, ctxc, ctxd, 13, const_stage_29, 5)
	STEP(G, ctxd, ctxa, ctxb, ctxc, 2, const_stage_30, 9)
	STEP(G, ctxc, ctxd, ctxa, ctxb, 7, const_stage_31, 14)
	STEP(G, ctxb, ctxc, ctxd, ctxa, 12, const_stage_32, 20)

	STEP(H, ctxa, ctxb, ctxc, ctxd, 5, const_stage_33, 4)
	STEP(H, ctxd, ctxa, ctxb, ctxc, 8, const_stage_34, 11)
	STEP(H, ctxc, ctxd, ctxa, ctxb, 11, const_stage_35, 16)
	STEP(H, ctxb, ctxc, ctxd, ctxa, 14, const_stage_36, 23)
	STEP(H, ctxa, ctxb, ctxc, ctxd, 1, const_stage_37, 4)
	STEP(H, ctxd, ctxa, ctxb, ctxc, 4, const_stage_38, 11)
	STEP(H, ctxc, ctxd, ctxa, ctxb, 7, const_stage_39, 16)
	STEP(H, ctxb, ctxc, ctxd, ctxa, 10, const_stage_40, 23)
	STEP(H, ctxa, ctxb, ctxc, ctxd, 13, const_stage_41, 4)
	STEP(H, ctxd, ctxa, ctxb, ctxc, 0, const_stage_42, 11)
	STEP(H, ctxc, ctxd, ctxa, ctxb, 3, const_stage_43, 16)
	STEP(H, ctxb, ctxc, ctxd, ctxa, 6, const_stage_44, 23)
	STEP(H, ctxa, ctxb, ctxc, ctxd, 9, const_stage_45, 4)
	STEP(H, ctxd, ctxa, ctxb, ctxc, 12, const_stage_46, 11)
	STEP(H, ctxc, ctxd, ctxa, ctxb, 15, const_stage_47, 16)
	STEP(H, ctxb, ctxc, ctxd, ctxa, 2, const_stage_48, 23)

	STEP(I, ctxa, ctxb, ctxc, ctxd, 0, const_stage_49, 6)
	STEP(I, ctxd, ctxa, ctxb, ctxc, 7, const_stage_50, 10)
	STEP(I, ctxc, ctxd, ctxa, ctxb, 14, const_stage_51, 15)
	STEP(I, ctxb, ctxc, ctxd, ctxa, 5, const_stage_52, 21)
	STEP(I, ctxa, ctxb, ctxc, ctxd, 12, const_stage_53, 6)
	STEP(I, ctxd, ctxa, ctxb, ctxc, 3, const_stage_54, 10)
	STEP(I, ctxc, ctxd, ctxa, ctxb, 10, const_stage_55, 15)
	STEP(I, ctxb, ctxc, ctxd, ctxa, 1, const_stage_56, 21)
	STEP(I, ctxa, ctxb, ctxc, ctxd, 8, const_stage_57, 6)
	STEP(I, ctxd, ctxa, ctxb, ctxc, 15, const_stage_58, 10)
	STEP(I, ctxc, ctxd, ctxa, ctxb, 6, const_stage_59, 15)
	STEP(I, ctxb, ctxc, ctxd, ctxa, 13, const_stage_60, 21)
	STEP(I, ctxa, ctxb, ctxc, ctxd, 4, const_stage_61, 6)
	STEP(I, ctxd, ctxa, ctxb, ctxc, 11, const_stage_62, 10)
	STEP(I, ctxc, ctxd, ctxa, ctxb, 2, const_stage_63, 15)
	STEP(I, ctxb, ctxc, ctxd, ctxa, 9, const_stage_64, 21)

	paddd storea, ctxa
	paddd storeb, ctxb
	paddd storec, ctxc
	paddd stored, ctxd

	MMXMOVE ctxa, 0(%eax)
	MMXMOVE ctxa, storea
	MMXMOVE ctxb, (4*MMX_COEF)(%eax)
	MMXMOVE ctxb, storeb
	MMXMOVE ctxc, (8*MMX_COEF)(%eax)
	MMXMOVE ctxc, storec
	MMXMOVE ctxd, (12*MMX_COEF)(%eax)
	MMXMOVE ctxd, stored

	popa

	emms
	
	ret

#ifdef __ELF__
.section .note.GNU-stack,"",@progbits
#endif




/*
 * This is an OpenSSL-compatible implementation of the RSA Data Security,
 * Inc. MD5 Message-Digest Algorithm.
 *
 * Written by Solar Designer <solar@openwall.com> in 2001, and placed in
 * the public domain.  There's absolutely no warranty.
 *
 * This differs from Colin Plumb's older public domain implementation in
 * that no 32-bit integer data type is required, there's no compile-time
 * endianness configuration, and the function prototypes match OpenSSL's.
 * The primary goals are portability and ease of use.
 *
 * This implementation is meant to be fast, but not as fast as possible.
 * Some known optimizations are not included to reduce source code size
 * and avoid compile-time configuration.
 */

#ifndef HAVE_OPENSSL

#include <string.h>

#include "md5.h"

/*
 * The basic MD5 functions.
 *
 * F is optimized compared to its RFC 1321 definition just like in Colin
 * Plumb's implementation.
 */
#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
#define H(x, y, z)			((x) ^ (y) ^ (z))
#define I(x, y, z)			((y) ^ ((x) | ~(z)))

/*
 * The MD5 transformation for all four rounds.
 */
#define STEP(f, a, b, c, d, x, t, s) \
	(a) += f((b), (c), (d)) + (x) + (t); \
	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
	(a) += (b);

/*
 * SET reads 4 input bytes in little-endian byte order and stores them
 * in a properly aligned word in host byte order.
 *
 * The check for little-endian architectures which tolerate unaligned
 * memory accesses is just an optimization.  Nothing will break if it
 * doesn't work.
 */
#if defined(__i386__) || defined(__vax__)
#define SET(n) \
	(*(MD5_u32plus *)&ptr[(n) * 4])
#define GET(n) \
	SET(n)
#else
#define SET(n) \
	(ctx->block[(n)] = \
	(MD5_u32plus)ptr[(n) * 4] | \
	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
#define GET(n) \
	(ctx->block[(n)])
#endif

/*
 * This processes one or more 64-byte data blocks, but does NOT update
 * the bit counters.  There're no alignment requirements.
 */
static void *body(MD5_CTX *ctx, void *data, unsigned long size)
{
	unsigned char *ptr;
	MD5_u32plus a, b, c, d;
	MD5_u32plus saved_a, saved_b, saved_c, saved_d;

	ptr = data;

	a = ctx->a;
	b = ctx->b;
	c = ctx->c;
	d = ctx->d;

	do {
		saved_a = a;
		saved_b = b;
		saved_c = c;
		saved_d = d;

/* Round 1 */
		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)

/* Round 2 */
		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)

/* Round 3 */
		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
		STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
		STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
		STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
		STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
		STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
		STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
		STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
		STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)

/* Round 4 */
		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)

		a += saved_a;
		b += saved_b;
		c += saved_c;
		d += saved_d;

		ptr += 64;
	} while (size -= 64);

	ctx->a = a;
	ctx->b = b;
	ctx->c = c;
	ctx->d = d;

	return ptr;
}

void MD5_Init(MD5_CTX *ctx)
{
	ctx->a = 0x67452301;
	ctx->b = 0xefcdab89;
	ctx->c = 0x98badcfe;
	ctx->d = 0x10325476;

	ctx->lo = 0;
	ctx->hi = 0;
}

void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
{
	MD5_u32plus saved_lo;
	unsigned long used, free;

	saved_lo = ctx->lo;
	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
		ctx->hi++;
	ctx->hi += size >> 29;

	used = saved_lo & 0x3f;

	if (used) {
		free = 64 - used;

		if (size < free) {
			memcpy(&ctx->buffer[used], data, size);
			return;
		}

		memcpy(&ctx->buffer[used], data, free);
		data = (unsigned char *)data + free;
		size -= free;
		body(ctx, ctx->buffer, 64);
	}

	if (size >= 64) {
		data = body(ctx, data, size & ~(unsigned long)0x3f);
		size &= 0x3f;
	}

	memcpy(ctx->buffer, data, size);
}

void MD5_Final(unsigned char *result, MD5_CTX *ctx)
{
	unsigned long used, free;

	used = ctx->lo & 0x3f;

	ctx->buffer[used++] = 0x80;

	free = 64 - used;

	if (free < 8) {
		memset(&ctx->buffer[used], 0, free);
		body(ctx, ctx->buffer, 64);
		used = 0;
		free = 64;
	}

	memset(&ctx->buffer[used], 0, free - 8);

	ctx->lo <<= 3;
	ctx->buffer[56] = ctx->lo;
	ctx->buffer[57] = ctx->lo >> 8;
	ctx->buffer[58] = ctx->lo >> 16;
	ctx->buffer[59] = ctx->lo >> 24;
	ctx->buffer[60] = ctx->hi;
	ctx->buffer[61] = ctx->hi >> 8;
	ctx->buffer[62] = ctx->hi >> 16;
	ctx->buffer[63] = ctx->hi >> 24;

	body(ctx, ctx->buffer, 64);

	result[0] = ctx->a;
	result[1] = ctx->a >> 8;
	result[2] = ctx->a >> 16;
	result[3] = ctx->a >> 24;
	result[4] = ctx->b;
	result[5] = ctx->b >> 8;
	result[6] = ctx->b >> 16;
	result[7] = ctx->b >> 24;
	result[8] = ctx->c;
	result[9] = ctx->c >> 8;
	result[10] = ctx->c >> 16;
	result[11] = ctx->c >> 24;
	result[12] = ctx->d;
	result[13] = ctx->d >> 8;
	result[14] = ctx->d >> 16;
	result[15] = ctx->d >> 24;

	memset(ctx, 0, sizeof(*ctx));
}

#endif




/*
 * This is an OpenSSL-compatible implementation of the RSA Data Security,
 * Inc. MD5 Message-Digest Algorithm.
 *
 * Written by Solar Designer <solar@openwall.com> in 2001, and placed in
 * the public domain.  See md5.c for more information.
 */

#ifdef HAVE_OPENSSL
#include <openssl/md5.h>
#elif !defined(_MD5_H)
#define _MD5_H

/* Any 32-bit or wider unsigned integer data type will do */
typedef unsigned long MD5_u32plus;

typedef struct {
	MD5_u32plus lo, hi;
	MD5_u32plus a, b, c, d;
	unsigned char buffer[64];
	MD5_u32plus block[16];
} MD5_CTX;

extern void MD5_Init(MD5_CTX *ctx);
extern void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size);
extern void MD5_Final(unsigned char *result, MD5_CTX *ctx);

#ifdef MMX_COEF
extern int mdfivemmx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
extern int mdfivemmx_nosizeupdate(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
extern int mdfivemmx_noinit_sizeupdate(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
extern int mdfivemmx_noinit_uniformsizeupdate(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
#endif

#endif




	size = strlen(src) + 1;
	return (char *)memcpy(mem_alloc_tiny(size, MEM_ALIGN_NONE), src, size);
}

void dump_stuff(unsigned char * x, unsigned int size)
{
	while(size--)
	{
		printf("%.2x", *x);
		x++;
	}
	printf("\n");
}

#ifdef MMX_COEF
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + ((i)&3) )

void dump_stuff_mmx(unsigned char * buf, unsigned int size, unsigned int index)
{
	int i;
	for(i=0;i<size;i++)
	{
		if(!(i%4))
			printf(" ");
		printf("%.2x", buf[GETPOS(i, index)]);
	}
	printf("\n");
}
#endif

Lines 73-76 Link Here

(-)john-1.7.0.1/src/memory.h (+5 lines)
73	*/	73	*/
74	extern char str_alloc_copy(char src);	74	extern char str_alloc_copy(char src);
75		75
		76	void dump_stuff(unsigned char * x, unsigned int size);
		77	#ifdef MMX_COEF
		78	void dump_stuff_mmx(unsigned char * x, unsigned int size, unsigned int index);
		79	#endif
		80
76	#endif	81	#endif




/*
 * Copyright (c) 2004 Simon Marechal
 * bartavelle@bandecon.com
 *
 * This is a plugin that adds Microsoft credential's cache hashing algorithm,
 * MS Cache Hash, a.k.a. MS Cash. This patch is invasive because john doesn't
 * support the use of the username easily within the current framework.
 * In order to get those hashes, use the CacheDump utility :
 *
 * http://www.cr0.net:8040/misc/cachedump.html
 *
 * It uses 
 * - smbencrypt.c Copyright (C) Andrew Tridgell 1997-1998
 * - md4.c, md4.h by Solar Designer
 *  
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "md4.h"

#define FORMAT_LABEL			"mscash"
#define FORMAT_NAME			"M$ Cache Hash"
#define ALGORITHM_NAME			"mscash"

#define BENCHMARK_COMMENT		""
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32

#define BINARY_SIZE			16
//max username size is 64, double for unicode "optimization"
#define SALT_SIZE			(64*2)
#define CIPHERTEXT_LENGTH		(BINARY_SIZE*2 + SALT_SIZE)

#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1

static struct fmt_tests mscash_tests[] = {
	{"M$test1#64cd29e36a8431a2b111378564a10631", "test1" },
	{"M$test2#ab60bdb4493822b175486810ac2abe63", "test2" },
	{"M$test3#14dd041848e12fc48c0aa7a416a4a00c", "test3" },
	{"M$test4#b945d24866af4b01a6d89b9d932a153c", "test4" },
	{NULL}
};

static char saved_key[PLAINTEXT_LENGTH + 1];
//stores the ciphertext for value currently being tested
static char crypt_key[BINARY_SIZE+1];

static int salt_length; //the length of the current username
static unsigned short cur_salt[SALT_SIZE/2]; //current salt

extern void E_md4hash(unsigned char *passwd, unsigned char *p16);

static int valid(char *ciphertext)
{
	int i;
	int l;

	/*
	 * 2 cases
	 * 1 - it comes from the disk, and does not have M$ + salt
	 * 2 - it comes from memory, and has got M$ + salt + # + blah
	 */

	if (!memcmp(ciphertext, "M$", 2))
	{
		l = strlen(ciphertext) - PLAINTEXT_LENGTH;
		if(ciphertext[l-1]!='#')
			return 0;
	}
	else
	{
		if(strlen(ciphertext)!=PLAINTEXT_LENGTH)
			return 0;
		l = 0;
	}
	for (i = l; i < l + PLAINTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	
	return 1;
}

//salt is unicode, so let's say it's unsigned short
static void mscash_set_salt(void *salt) {
	salt_length = 0;
	while( ((unsigned char *)salt)[salt_length]!='#' )
	{
#if ARCH_LITTLE_ENDIAN
		cur_salt[salt_length] = ((unsigned char *)salt)[salt_length];
#else
		cur_salt[salt_length] = ((unsigned char *)salt)[salt_length] << 8;
#endif
		salt_length ++;
	}
	cur_salt[salt_length] = 0;
}

static void mscash_set_key(char *key, int index) {
	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
}

static char *mscash_get_key(int index) {
    return saved_key;
}

static int mscash_cmp_all(void *binary, int index) { 
	int i=0;
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
	return 1;
}

static void mscash_crypt_all(int count) {  
	unsigned char buffer[BINARY_SIZE+SALT_SIZE];
	// get plaintext input in saved_key put it into ciphertext crypt_key
	
	//stage 1 : build nt hash of password
	E_md4hash(saved_key, buffer);

	//stage 2 : append cleartext to buffer
	memcpy(buffer+BINARY_SIZE, cur_salt, salt_length*2);

	//stage 3 : generate final hash and put it in crypt_key
	mdfour(crypt_key, buffer, BINARY_SIZE+salt_length*2);
}

static void * mscash_binary(char *ciphertext) 
{
	static unsigned char realcipher[BINARY_SIZE];
	int i;
	
	int l = strlen(ciphertext);
	for(i=0; i<BINARY_SIZE ;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+l-BINARY_SIZE*2])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+l-BINARY_SIZE*2+1])];
	}
	return (void *)realcipher;
}

static void * mscash_get_salt(char * ciphertext)
{
	static unsigned char out[SALT_SIZE];
	int l;

	l = strlen(ciphertext);
	strncpy(out, ciphertext + 2, l - PLAINTEXT_LENGTH + 1);
	return out;
}

static int mscash_cmp_one(void *binary, int count){
	return (1);
}

static int mscash_cmp_exact(char *source, int count){
	return 1;
	//return (!memcmp(mscash_binary(source), crypt_key, BINARY_SIZE));
}

struct fmt_main fmt_mscash = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		mscash_tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		mscash_binary,
		mscash_get_salt,
		{
			fmt_default_binary_hash,
			fmt_default_binary_hash,
			fmt_default_binary_hash
		},
		fmt_default_salt_hash,
		mscash_set_salt,
		mscash_set_key,
		mscash_get_key,
		fmt_default_clear_keys,
		mscash_crypt_all,
		{
			fmt_default_get_hash,
			fmt_default_get_hash,
			fmt_default_get_hash
		},
		mscash_cmp_all,
		mscash_cmp_one,
		mscash_cmp_exact
	}
};




/*
 * Copyright (c) 2004 Simon Marechal
 * bartavelle@bandecon.com
 *
 * This is a plugin that adds Microsoft credential's cache hashing algorithm,
 * MS Cache Hash, a.k.a. MS Cash. This patch is invasive because john doesn't
 * support the use of the username easily within the current framework.
 * In order to get those hashes, use the CacheDump utility :
 *
 * http://www.cr0.net:8040/misc/cachedump.html
 *
 * It uses 
 * - smbencrypt.c Copyright (C) Andrew Tridgell 1997-1998
 * - md4.c, md4.h by Solar Designer
 *  
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "md4.h"

#define FORMAT_LABEL			"mscashmmx"
#define FORMAT_NAME			"M$ Cache Hash MMX"
#define ALGORITHM_NAME			"mscash"

#define BENCHMARK_COMMENT		MMX_TYPE
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32

#define BINARY_SIZE			16
//max username size is 64, double for unicode "optimization"
#define SALT_SIZE			(64*2*MMX_COEF)
#define CIPHERTEXT_LENGTH		(BINARY_SIZE*2 + SALT_SIZE)

#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF

#define GETPOS(i,idx)	( ((i)&0xfffe)*MMX_COEF + ((i)&1) + ((idx)<<1) )

static struct fmt_tests mscash_tests[] = {
	{"M$test1#64cd29e36a8431a2b111378564a10631", "test1" },
	{"M$test2#ab60bdb4493822b175486810ac2abe63", "test2" },
	{"M$test3#14dd041848e12fc48c0aa7a416a4a00c", "test3" },
	{"M$test4#b945d24866af4b01a6d89b9d932a153c", "test4" },
	{NULL}
};

static char saved_key[PLAINTEXT_LENGTH*MMX_COEF + 1];
//stores the ciphertext for value currently being tested
static char crypt_key[BINARY_SIZE*MMX_COEF+1];

static int salt_length; //the length of the current username
static int total_len;
static unsigned short cur_salt[MMX_COEF*SALT_SIZE/2]; //current salt

//extern void E_md4hash(unsigned char *passwd, unsigned char *p16);

static int valid(char *ciphertext)
{
	int i;
	int l;

	/*
	 * 2 cases
	 * 1 - it comes from the disk, and does not have M$ + salt
	 * 2 - it comes from memory, and has got M$ + salt + # + blah
	 */

	if (!memcmp(ciphertext, "M$", 2))
	{
		l = strlen(ciphertext) - PLAINTEXT_LENGTH;
		if(ciphertext[l-1]!='#')
			return 0;
	}
	else
	{
		if(strlen(ciphertext)!=PLAINTEXT_LENGTH)
			return 0;
		l = 0;
	}
	for (i = l; i < l + PLAINTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	
	return 1;
}

//salt is unicode, so let's say it's unsigned short
static void mscash_set_salt(void *salt) {
	unsigned int curlen;
	salt_length = 0;
	while( ((unsigned char *)salt)[salt_length]!='#' )
	{
#if ARCH_LITTLE_ENDIAN
		cur_salt[salt_length] = ((unsigned char *)salt)[salt_length];
#else
		cur_salt[salt_length] = ((unsigned char *)salt)[salt_length] << 8;
#endif
		salt_length ++;
	}
	cur_salt[salt_length] = 0;
	salt_length = curlen;
}

static void mscash_set_key(char *key, int index) {
	int len;
	int i;

	if(index==0)
	{
		total_len = 0;
		memset(saved_key, 0, 64*MMX_COEF);
	}
	len = strlen(key);
	if(len > 32)
                len = 32;

	total_len += len << (1 + ( (32/MMX_COEF) * index ) );

	for(i=0;i<len;i++)
		((unsigned short *)saved_key)[ GETPOS(i, index) ] = key[i] ;
	((unsigned short *)saved_key)[ GETPOS(i, index) ] = 0x80;
}

static char *mscash_get_key(int index) {
    return saved_key;
}

static int mscash_cmp_all(void *binary, int index) { 
	int i=0;
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
	return 1;
}

static void mscash_crypt_all(int count) {  
	unsigned char buffer[BINARY_SIZE+SALT_SIZE];
	// get plaintext input in saved_key put it into ciphertext crypt_key
	
	//stage 1 : build nt hash of password
	//E_md4hash(saved_key, buffer);

	//stage 2 : append cleartext to buffer
	//memcpy(buffer+BINARY_SIZE, cur_salt, salt_length*2);

	//stage 3 : generate final hash and put it in crypt_key
	//mdfour(crypt_key, buffer, BINARY_SIZE+salt_length*2);
}

static void * mscash_binary(char *ciphertext) 
{
	static unsigned char realcipher[BINARY_SIZE];
	int i;
	
	int l = strlen(ciphertext);
	for(i=0; i<BINARY_SIZE ;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+l-BINARY_SIZE*2])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+l-BINARY_SIZE*2+1])];
	}
	return (void *)realcipher;
}

static void * mscash_get_salt(char * ciphertext)
{
	static unsigned char out[SALT_SIZE];
	int l;

	l = strlen(ciphertext);
	strncpy(out, ciphertext + 2, l - PLAINTEXT_LENGTH + 1);
	return out;
}

static int mscash_cmp_one(void *binary, int count){
	return (1);
}

static int mscash_cmp_exact(char *source, int count){
	return 1;
	//return (!memcmp(mscash_binary(source), crypt_key, BINARY_SIZE));
}

struct fmt_main fmt_mscash_mmx = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		mscash_tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		mscash_binary,
		mscash_get_salt,
		{
			fmt_default_binary_hash,
			fmt_default_binary_hash,
			fmt_default_binary_hash
		},
		fmt_default_salt_hash,
		mscash_set_salt,
		mscash_set_key,
		mscash_get_key,
		fmt_default_clear_keys,
		mscash_crypt_all,
		{
			fmt_default_get_hash,
			fmt_default_get_hash,
			fmt_default_get_hash
		},
		mscash_cmp_all,
		mscash_cmp_one,
		mscash_cmp_exact
	}
};




/*
 * Copyright (c) 2004 bartavelle
 * bartavelle@bandecon.com
 *
 * microsoft MS SQL cracker
 * 
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "sha.h"

//remove this line at your own risks!
//seems to work sometimes ...
#undef MMX_COEF

#define FORMAT_LABEL			"mssql"
#define FORMAT_NAME			"MS-SQL"
#ifdef MMX_COEF
#if (MMX_COEF == 2)
#define ALGORITHM_NAME			"ms-sql MMX"
#else
#define ALGORITHM_NAME			"ms-sql SSE2"
#endif
#else
#define ALGORITHM_NAME			"ms-sql"
#endif

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		20
#define CIPHERTEXT_LENGTH		94

#define BINARY_SIZE			20
#define SALT_SIZE			4

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
//#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + ((i)&3) ) //std getpos
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + (3-((i)&3)) ) //for endianity conversion
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

//microsoft unicode ...
#if ARCH_BIG_ENDIAN
#define ENDIAN_SHIFT_L  << 8
#define ENDIAN_SHIFT_R  >> 8
#else
#define ENDIAN_SHIFT_L
#define ENDIAN_SHIFT_R
#endif

static struct fmt_tests mssql_tests[] = {
	{"0x0100A607BA7C54A24D17B565C59F1743776A10250F581D482DA8B6D6261460D3F53B279CC6913CE747006A2E3254", "FOO"},
	{"0x01000508513EADDF6DB7DDD270CCA288BF097F2FF69CC2DB74FBB9644D6901764F999BAB9ECB80DE578D92E3F80D", "BAR"},
	{"0x01008408C523CF06DCB237835D701C165E68F9460580132E28ED8BC558D22CEDF8801F4503468A80F9C52A12C0A3", "CANARD"},
	{"0x0100BF088517935FC9183FE39FDEC77539FD5CB52BA5F5761881E5B9638641A79DBF0F1501647EC941F3355440A2", "LAPIN"},
	{NULL}
};

static unsigned char cursalt[SALT_SIZE];

#ifdef MMX_COEF
static char saved_key[64*MMX_COEF*2 + 1] __attribute__ ((aligned(16)));
static char crypt_key[80*4*MMX_COEF+1] __attribute__ ((aligned(16))); //wtf
unsigned long total_len;
unsigned char out[PLAINTEXT_LENGTH];
#else
static unsigned char saved_key[PLAINTEXT_LENGTH*2 + 1];
static unsigned char crypt_key[BINARY_SIZE+1];
static SHA_CTX ctx;
unsigned int key_length;
#endif

static int valid(char *ciphertext)
{
	int i;

	if (strlen(ciphertext) != CIPHERTEXT_LENGTH) return 0;
	if(memcmp(ciphertext, "0x0100", 6))
		return 0;
	for (i = 6; i < CIPHERTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	return 1;
}

static void mssql_set_salt(void *salt)
{
	memcpy(cursalt, salt, SALT_SIZE);
}

static void * mssql_get_salt(char * ciphertext)
{
	static unsigned char out2[SALT_SIZE];
	int l;

	for(l=0;l<SALT_SIZE;l++)
	{
		out2[l] = atoi16[ARCH_INDEX(ciphertext[l*2+6])]*16 
			+ atoi16[ARCH_INDEX(ciphertext[l*2+7])];
	}

	return out2;
}

static inline unsigned char upper(unsigned char c)
{
	if( (c>='a') && (c<='z'))
		return c+'A'-'a';
	return c;
}

static void mssql_init(void)
{
#ifdef MMX_COEF
	memset(saved_key, 0, 64*MMX_COEF);
#endif
}

static void mssql_set_key(char *key, int index) {
#ifdef MMX_COEF
	int len;
	int i;
	
	if(index==0)
	{
		total_len = 0;
		memset(saved_key, 0, 64*MMX_COEF);
	}
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

	total_len += (len*2+SALT_SIZE ) << ( ( (32/MMX_COEF) * index ) );
	for(i=0;i<len;i++)
	{
		saved_key[GETPOS((i*2), index)] = upper(key[i]);
		saved_key[GETPOS((i*2+1), index)] = 0;
	}
	for(i=0;i<4;i++)
		saved_key[GETPOS( (len*2+i), index)] = cursalt[i];
	saved_key[GETPOS( (len*2+SALT_SIZE) , index)] = 0x80;
#else
	key_length = 0;
	while( (((unsigned short *)saved_key)[key_length] = upper(key[key_length]) ENDIAN_SHIFT_L ))
		key_length++;
#endif
}

static char *mssql_get_key(int index) {
#ifdef MMX_COEF
	unsigned int i,s;
	
	s = (total_len >> (((32/MMX_COEF)*(index)))) & 0xff;
	s = (s-4)/2;
	for(i=0;i<s;i++)
		out[i] = saved_key[ GETPOS(i*2, index) ];
	out[i] = 0;
	return out;
#else
	static unsigned char retkey[PLAINTEXT_LENGTH];
	int i;
	
	memset(retkey, 0, PLAINTEXT_LENGTH);
	for(i=0;i<key_length;i++)
		retkey[i] = ((unsigned short *)saved_key)[i];
	return retkey;
#endif
}

static int mssql_cmp_all(void *binary, int index) { 
	int i=0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int mssql_cmp_exact(char *source, int count){
  return (1);
}

static int mssql_cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return mssql_cmp_all(binary, index);
#endif
}

static void mssql_crypt_all(int count) {
  // get plaintext input in saved_key put it into ciphertext crypt_key
#ifdef MMX_COEF
	shammx(crypt_key, saved_key, total_len);
#else
	memcpy(saved_key+key_length*2, cursalt, SALT_SIZE);
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, saved_key, key_length*2+SALT_SIZE );
	SHA1_Final( crypt_key, &ctx);
#endif
  
}

static void * mssql_binary(char *ciphertext) 
{
	static char realcipher[BINARY_SIZE];
	int i;
	
	for(i=0;i<BINARY_SIZE;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2+54])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+55])];
	}
	return (void *)realcipher;
}

static int binary_hash_0(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xF;
}

static int binary_hash_1(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xFF;
}

static int binary_hash_2(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xFFF;
}

static int get_hash_0(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xF;
}

static int get_hash_1(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xFF;
}

static int get_hash_2(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xFFF;
}

struct fmt_main fmt_mssql = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_8_BIT,
		mssql_tests
	}, {
		mssql_init,
		valid,
		fmt_default_split,
		mssql_binary,
		mssql_get_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		fmt_default_salt_hash,
		mssql_set_salt,
		mssql_set_key,
		mssql_get_key,
		fmt_default_clear_keys,
		mssql_crypt_all,
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		mssql_cmp_all,
		mssql_cmp_one,
		mssql_cmp_exact
	}
};

Lines 102-107 Link Here

(-)john-1.7.0.1/src/options.c (+4 lines)
102	"only\n" \	102	"only\n" \
103	"--format=NAME force ciphertext format NAME: " \	103	"--format=NAME force ciphertext format NAME: " \
104	"DES/BSDI/MD5/BF/AFS/LM\n" \	104	"DES/BSDI/MD5/BF/AFS/LM\n" \
		105	" raw-md5/MYSQL/NT/lotus5/mscash/md5a/nsldap\n" \
		106	" bfegg/mssql/\n" \
		107	" NTmmx (will not work for passwords more\n" \
		108	" than 32 characters, use NT instead)\n" \
105	"--save-memory=LEVEL enable memory saving, at LEVEL 1..3\n"	109	"--save-memory=LEVEL enable memory saving, at LEVEL 1..3\n"
106		110
107	void opt_init(char name, int argc, char *argv)	111	void opt_init(char name, int argc, char *argv)




/*
 * Copyright (c) 2004 Simon Marechal
 * simon.marechal@thales-security.com
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "des.h"

#define FORMAT_LABEL			"oracle"
#define FORMAT_NAME			"Oracle"
#define ALGORITHM_NAME			"oracle"

#define BENCHMARK_COMMENT		""
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		16

#define BINARY_SIZE			8
#define SALT_SIZE			32
#define CIPHERTEXT_LENGTH		(BINARY_SIZE + SALT_SIZE)

#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1

static struct fmt_tests oracle_tests[] = {
	{"O$SIMON#4F8BC1809CB2AF77", "A"},
	{"O$SIMON#183D72325548EF11", "THALES2" },
	{"O$SIMON#C4EB3152E17F24A4", "TST" },
	{"O$SYSTEM#9EEDFA0AD26C6D52", "THALES" },
	{NULL}
};

#if ARCH_LITTLE_ENDIAN
#define ENDIAN_SHIFT_L  << 8
#define ENDIAN_SHIFT_R  >> 8
#else
#define ENDIAN_SHIFT_L
#define ENDIAN_SHIFT_R
#endif

//stores the ciphertext for value currently being tested
static char crypt_key[BINARY_SIZE+1];

static unsigned char cur_salt[128 + 1]; //current salt
static unsigned char cur_key[128 + 1]; //current salt

static unsigned char deskey[8];
static unsigned char salt_iv[8];
static DES_key_schedule desschedule1;
static DES_key_schedule desschedule2;

static int salt_length;
static int key_length;

static int valid(char *ciphertext)
{
	int i;
	int l;

	/*
	 * 2 cases
	 * 1 - it comes from the disk, and does not have O$ + salt
	 * 2 - it comes from memory, and has got O$ + salt + # + blah
	 */

	if (!memcmp(ciphertext, "O$", 2))
	{
		l = strlen(ciphertext) - PLAINTEXT_LENGTH;
		if(ciphertext[l-1]!='#')
			return 0;
	}
	else
	{
		if(strlen(ciphertext)!=PLAINTEXT_LENGTH)
			return 0;
		l = 0;
	}
	for (i = l; i < l + PLAINTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
			(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
			|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	
	return 1;
}

static void oracle_init(void)
{
	deskey[0] = 0x01;
	deskey[1] = 0x23;
	deskey[2] = 0x45;
	deskey[3] = 0x67;
	deskey[4] = 0x89;
	deskey[5] = 0xab;
	deskey[6] = 0xcd;
	deskey[7] = 0xef;

	my_des_set_key(&deskey, &desschedule1);
}

static inline unsigned char upper(unsigned char c)
{
	if( (c>='a') && (c<='z'))
		return c+'A'-'a';
	return c;
}

static void oracle_set_salt(void *salt, int count) {
	salt_length = 0;

	memset(salt_iv, 0, 8);
	while ( (((unsigned short *)cur_salt)[salt_length] = upper(((unsigned char *)salt)[salt_length]) ENDIAN_SHIFT_L ))
		salt_length++;
}

static void oracle_set_key(char *key, int index) {
	key_length = 0;
	while( (((unsigned short *)cur_key)[key_length] = upper(key[key_length]) ENDIAN_SHIFT_L ))
		key_length++;
}

static char *oracle_get_key(int index) {
	static unsigned char out[PLAINTEXT_LENGTH];
	unsigned int i;
	for(i=0;i<key_length;i++)
		out[i] = ((unsigned short *)cur_key)[i] ENDIAN_SHIFT_R;
	out[i] = 0;
	return out;
}

static int oracle_cmp_all(void *binary, int index) { 
	int i=0;
	while(i<(BINARY_SIZE/sizeof(int)))
	{
		if(((int *)binary)[i]!=((int *)crypt_key)[i])
			return 0;
		i++;
	}
	return 1;
}

static void oracle_crypt_all(int count)  
{
	unsigned int l;

	
	l = (salt_length + key_length)*2;
	memcpy(crypt_key, salt_iv, 8);
	//that's the way john works ...
	memcpy(cur_salt + salt_length*2, cur_key, key_length * 2);
	my_des_ncbc_encrypt(cur_salt ,l , &desschedule1,(DES_cblock *) crypt_key);
	my_des_set_key((DES_cblock *)crypt_key, &desschedule2);
	memset(crypt_key, 0, 8);
	my_des_ncbc_encrypt(cur_salt, l , &desschedule2, (DES_cblock *)crypt_key);
}

static void * oracle_binary(char *ciphertext) 
{
	static unsigned char out3[BINARY_SIZE];
	int l;
	int i;
	l = strlen(ciphertext) - PLAINTEXT_LENGTH;
	for(i=0;i<BINARY_SIZE;i++) 
	{
		out3[i] = atoi16[ARCH_INDEX(ciphertext[i*2+l])]*16 
			+ atoi16[ARCH_INDEX(ciphertext[i*2+l+1])];
	}
	return out3;
}

static void * oracle_get_salt(char * ciphertext)
{
	static unsigned char out2[SALT_SIZE];
	int l;

	l = 2;
	while( ciphertext[l] && (ciphertext[l]!='#') )
	{
		out2[l-2] = ciphertext[l];
		l++;
	}
	out2[l-2] = 0;
	return out2;
}

static int oracle_cmp_one(void *binary, int count){
	return (1);
}

static int oracle_cmp_exact(char *source, int count){
	return 1;
}

static int binary_hash1(void * binary) { return (((unsigned int *)binary)[0] & 0xf); }
static int binary_hash2(void * binary) { return (((unsigned int *)binary)[0] & 0xff); }
static int binary_hash3(void * binary) { return (((unsigned int *)binary)[0] & 0xfff); }

static int get_hash1(int index) { return (((unsigned int *)crypt_key)[0] & 0xf); }
static int get_hash2(int index) { return (((unsigned int *)crypt_key)[0] & 0xff); }
static int get_hash3(int index) { return (((unsigned int *)crypt_key)[0] & 0xfff); }

struct fmt_main fmt_oracle = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_8_BIT,
		oracle_tests
	}, {
		oracle_init,
		valid,
		fmt_default_split,
		oracle_binary,
		oracle_get_salt,
		{
			binary_hash1,
			binary_hash2,
			binary_hash3
		},
		fmt_default_salt_hash,
		oracle_set_salt,
		oracle_set_key,
		oracle_get_key,
		fmt_default_clear_keys,
		oracle_crypt_all,
		{
			get_hash1,
			get_hash2,
			get_hash3
		},
		oracle_cmp_all,
		oracle_cmp_one,
		oracle_cmp_exact
	}
};

Lines 178-183 Link Here

(-)john-1.7.0.1/src/ppc-alti.c (+3 lines)
178	ARCH_WORD **k;	178	ARCH_WORD **k;
179	#endif	179	#endif
180	int iterations, rounds_and_swapped;	180	int iterations, rounds_and_swapped;
		181	#if DES_BS_VECTOR
		182	int depth;
		183	#endif
181		184
182	DES_bs_clear_block();	185	DES_bs_clear_block();
183		186




/*
 * This file is part of John the Ripper password cracker,
 * Copyright (c) 1996-2000 by Solar Designer
 */

/*
 * Architecture specific parameters for PowerPC.
 */

#ifndef _JOHN_ARCH_H
#define _JOHN_ARCH_H

#define ARCH_WORD			long
#define ARCH_SIZE			4
#define ARCH_BITS			32
#define ARCH_BITS_LOG			5
#define ARCH_BITS_STR			"32"
#define ARCH_LITTLE_ENDIAN		0
#define ARCH_INT_GT_32			0
#define ARCH_ALLOWS_UNALIGNED		0
#define ARCH_INDEX(x)			((unsigned int)(unsigned char)(x))

#define OS_TIMER			1
#define OS_FLOCK			1

#define CPU_DETECT			0

#define DES_ASM				0
#define DES_128K			0
#define DES_X2				0
#define DES_MASK			1
#define DES_SCALE			0
#define DES_EXTB			1
#define DES_COPY			0
#define DES_BS_ASM			0
#define DES_BS				1
#define DES_BS_VECTOR			0
#define DES_BS_EXPAND			1

#define MD5_ASM				0
#define MD5_X2				1
#define MD5_IMM				0

#define BF_ASM				0
#define BF_SCALE			0

#endif

Lines 10-16 Link Here

(-)john-1.7.0.1/src/ppc64.h (-1 / +1 lines)
10	#ifndef _JOHN_ARCH_H	10	#ifndef _JOHN_ARCH_H
11	#define _JOHN_ARCH_H	11	#define _JOHN_ARCH_H
12		12
13	#define ARCH_WORD long	13	#define ARCH_WORD long long
14	#define ARCH_SIZE 8	14	#define ARCH_SIZE 8
15	#define ARCH_BITS 64	15	#define ARCH_BITS 64
16	#define ARCH_BITS_LOG 6	16	#define ARCH_BITS_LOG 6

Lines 10-16 Link Here

(-)john-1.7.0.1/src/ppc64alt.h (-1 / +1 lines)
10	#ifndef _JOHN_ARCH_H	10	#ifndef _JOHN_ARCH_H
11	#define _JOHN_ARCH_H	11	#define _JOHN_ARCH_H
12		12
13	#define ARCH_WORD long	13	#define ARCH_WORD long long
14	#define ARCH_SIZE 8	14	#define ARCH_SIZE 8
15	#define ARCH_BITS 64	15	#define ARCH_BITS 64
16	#define ARCH_BITS_LOG 6	16	#define ARCH_BITS_LOG 6




/*
 * Copyright (c) 2004 bartavelle
 * bartavelle@bandecon.com
 *
 * Simple MD5 hashes cracker
 * It uses the Solar Designer's md5 implementation
 * 
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "md5.h"

#define FORMAT_LABEL			"raw-md5"
#define FORMAT_NAME			"Raw MD5"
#ifdef MMX_COEF
#if (MMX_COEF == 2)
#define ALGORITHM_NAME			"raw-md5 MMX"
#else
#define ALGORITHM_NAME			"raw-md5 SSE2"
#endif
#else
#define ALGORITHM_NAME			"raw-md5"
#endif

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32
#define CIPHERTEXT_LENGTH		32

#define BINARY_SIZE			16
#define SALT_SIZE			0

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + ((i)&3) )
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

static struct fmt_tests rawmd5_tests[] = {
	{"5a105e8b9d40e1329780d62ea2265d8a", "test1"},
	{"ad0234829205b9033196ba818f7a872b", "test2"},
	{"8ad8757baa8564dc136c1e07507f4a98", "test3"},
	{"86985e105f79b95d6bc918fb45ec7727", "test4"},
	{NULL}
};

#ifdef MMX_COEF
static char saved_key[PLAINTEXT_LENGTH*MMX_COEF*2 + 1] __attribute__ ((aligned(16)));
static char crypt_key[BINARY_SIZE*MMX_COEF+1] __attribute__ ((aligned(16)));
unsigned long total_len;
unsigned char out[PLAINTEXT_LENGTH];
#else
static char saved_key[PLAINTEXT_LENGTH + 1];
static char crypt_key[BINARY_SIZE+1];
static MD5_CTX ctx;
#endif

static int valid(char *ciphertext)
{
	int i;

	if (strlen(ciphertext) != CIPHERTEXT_LENGTH) return 0;
	for (i = 0; i < CIPHERTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	return 1;
}

static void rawmd5_set_salt(void *salt) { }

static void rawmd5_set_key(char *key, int index) {
#ifdef MMX_COEF
	int len;
	int i;
	
	if(index==0)
	{
		total_len = 0;
		memset(saved_key, 0, PLAINTEXT_LENGTH*MMX_COEF);
	}
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

	total_len += len << ( ( (32/MMX_COEF) * index ) );
	for(i=0;i<len;i++)
		saved_key[GETPOS(i, index)] = key[i];

	saved_key[GETPOS(i, index)] = 0x80;
#else
	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
#endif
}

static char *rawmd5_get_key(int index) {
#ifdef MMX_COEF
	unsigned int i,s;
	
	s = (total_len >> (((32/MMX_COEF)*(index)))) & 0xff;
	for(i=0;i<s;i++)
		out[i] = saved_key[ GETPOS(i, index) ];
	out[i] = 0;
	return out;
#else
	return saved_key;
#endif
}

static int rawmd5_cmp_all(void *binary, int index) { 
	int i=0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int rawmd5_cmp_exact(char *source, int count){
  return (1);
}

static int rawmd5_cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return rawmd5_cmp_all(binary, index);
#endif
}

static void rawmd5_crypt_all(int count) {  
  // get plaintext input in saved_key put it into ciphertext crypt_key
#ifdef MMX_COEF
	mdfivemmx(crypt_key, saved_key, total_len);
#else
	MD5_Init( &ctx );
	MD5_Update( &ctx, saved_key, strlen( saved_key ) );
	MD5_Final( crypt_key, &ctx);
#endif
  
}

static void * rawmd5_binary(char *ciphertext) 
{
	static char realcipher[BINARY_SIZE];
	int i;
	
	for(i=0;i<BINARY_SIZE;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
	}
	return (void *)realcipher;
}

static int get_hash1(int index)
{
#ifdef MMX_COEF
	return (((unsigned long *)crypt_key)[index] & 0xf);
#else
	return (((unsigned int *)crypt_key)[0] & 0xf);
#endif
}
static int get_hash2(int index)
{
#ifdef MMX_COEF
	return (((unsigned long *)crypt_key)[index] & 0xff);
#else
	return (((unsigned int *)crypt_key)[0] & 0xff);
#endif
}
static int get_hash3(int index)
{
#ifdef MMX_COEF
	return (((unsigned long *)crypt_key)[index] & 0xfff);
#else
	return (((unsigned int *)crypt_key)[0] & 0xfff);
#endif
}

static int binary_hash1(void * binary) { return (((unsigned int *)binary)[0] & 0xf); }
static int binary_hash2(void * binary) { return (((unsigned int *)binary)[0] & 0xff); }
static int binary_hash3(void * binary) { return (((unsigned int *)binary)[0] & 0xfff); }

struct fmt_main fmt_rawMD5 = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		rawmd5_tests
	}, {
		fmt_default_init,
		valid,
		fmt_default_split,
		rawmd5_binary,
		fmt_default_salt,
		{
			binary_hash1,
			binary_hash2,
			binary_hash3
		},
		fmt_default_salt_hash,
		rawmd5_set_salt,
		rawmd5_set_key,
		rawmd5_get_key,
		fmt_default_clear_keys,
		rawmd5_crypt_all,
		{
			get_hash1,
			get_hash2,
			get_hash3
		},
		rawmd5_cmp_all,
		rawmd5_cmp_one,
		rawmd5_cmp_exact
	}
};




/*
 * Copyright (c) 2004 bartavelle
 * bartavelle@bandecon.com
 *
 * Simple MD5 hashes cracker
 * It uses the Solar Designer's md5 implementation
 * 
 */

#include <string.h>

#include "arch.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "sha.h"

#define FORMAT_LABEL			"raw-sha1"
#define FORMAT_NAME			"Raw SHA1"
#ifdef MMX_COEF
#if (MMX_COEF == 2)
#define ALGORITHM_NAME			"raw-sha1 MMX"
#else
#define ALGORITHM_NAME			"raw-sha1 SSE2"
#endif
#else
#define ALGORITHM_NAME			"raw-sha1"
#endif

#ifdef MMX_TYPE
#define BENCHMARK_COMMENT		MMX_TYPE
#else
#define BENCHMARK_COMMENT		""
#endif
#define BENCHMARK_LENGTH		-1

#define PLAINTEXT_LENGTH		32
#define CIPHERTEXT_LENGTH		40

#define BINARY_SIZE			20
#define SALT_SIZE			0

#ifdef MMX_COEF
#define MIN_KEYS_PER_CRYPT		MMX_COEF
#define MAX_KEYS_PER_CRYPT		MMX_COEF
//#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + ((i)&3) ) //std getpos
#define GETPOS(i, index)		( (index)*4 + (i& (0xffffffff-3) )*MMX_COEF + (3-((i)&3)) ) //for endianity conversion
#else
#define MIN_KEYS_PER_CRYPT		1
#define MAX_KEYS_PER_CRYPT		1
#endif

static struct fmt_tests rawsha1_tests[] = {
	{"A9993E364706816ABA3E25717850C26C9CD0D89D", "abc"},
	{"2fbf0eba37de1d1d633bc1ed943b907f9b360d4c", "azertyuiop1"},
	{"f879f8090e92232ed07092ebed6dc6170457a21d", "azertyuiop2"},
	{"1813c12f25e64931f3833b26e999e26e81f9ad24", "azertyuiop3"},
	{NULL}
};

#ifdef MMX_COEF
static char saved_key[PLAINTEXT_LENGTH*MMX_COEF*2 + 1] __attribute__ ((aligned(16)));
static char crypt_key[80*4*MMX_COEF+1] __attribute__ ((aligned(16)));
unsigned long total_len;
unsigned char out[PLAINTEXT_LENGTH];
#else
static char saved_key[PLAINTEXT_LENGTH + 1];
static char crypt_key[BINARY_SIZE+1];
static SHA_CTX ctx;
#endif

static int valid(char *ciphertext)
{
	int i;

	if (strlen(ciphertext) != CIPHERTEXT_LENGTH) return 0;
	for (i = 0; i < CIPHERTEXT_LENGTH; i++){
		if (!(  (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) ||
					(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))  
					|| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
			return 0;
	}
	return 1;
}

static void rawsha1_set_salt(void *salt) { }

static void rawsha1_init(void)
{
#ifdef MMX_COEF
	memset(saved_key, 0, PLAINTEXT_LENGTH*MMX_COEF*2 + 1);
#endif
}

static void rawsha1_set_key(char *key, int index) {
#ifdef MMX_COEF
	int len;
	int i;
	
	if(index==0)
	{
		total_len = 0;
		memset(saved_key, 0, PLAINTEXT_LENGTH*MMX_COEF);
	}
	len = strlen(key);
	if(len>PLAINTEXT_LENGTH)
		len = PLAINTEXT_LENGTH;

	total_len += len << ( ( (32/MMX_COEF) * index ) );
	for(i=0;i<len;i++)
		saved_key[GETPOS(i, index)] = key[i];

	saved_key[GETPOS(i, index)] = 0x80;
#else
	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
#endif
}

static char *rawsha1_get_key(int index) {
#ifdef MMX_COEF
	unsigned int i,s;
	
	s = (total_len >> (((32/MMX_COEF)*(index)))) & 0xff;
	for(i=0;i<s;i++)
		out[i] = saved_key[ GETPOS(i, index) ];
	out[i] = 0;
	return out;
#else
	return saved_key;
#endif
}

static int rawsha1_cmp_all(void *binary, int index) { 
	int i=0;
#ifdef MMX_COEF
	while(i< (BINARY_SIZE/4) )
	{
		if (
			( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+1])
#if (MMX_COEF > 3)
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+2])
			&& ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+3])
#endif
		)
			return 0;
		i++;
	}
#else
	while(i<BINARY_SIZE)
	{
		if(((char *)binary)[i]!=((char *)crypt_key)[i])
			return 0;
		i++;
	}
#endif
	return 1;
}

static int rawsha1_cmp_exact(char *source, int count){
  return (1);
}

static int rawsha1_cmp_one(void * binary, int index)
{
#ifdef MMX_COEF
	int i = 0;
	for(i=0;i<(BINARY_SIZE/4);i++)
		if ( ((unsigned long *)binary)[i] != ((unsigned long *)crypt_key)[i*MMX_COEF+index] )
			return 0;
	return 1;
#else
	return rawsha1_cmp_all(binary, index);
#endif
}

static void rawsha1_crypt_all(int count) {  
  // get plaintext input in saved_key put it into ciphertext crypt_key
#ifdef MMX_COEF
	shammx(crypt_key, saved_key, total_len);
#else
	SHA1_Init( &ctx );
	SHA1_Update( &ctx, saved_key, strlen( saved_key ) );
	SHA1_Final( crypt_key, &ctx);
#endif
  
}

static void * rawsha1_binary(char *ciphertext) 
{
	static char realcipher[BINARY_SIZE];
	int i;
	
	for(i=0;i<BINARY_SIZE;i++)
	{
		realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i*2])]*16 + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
	}
	return (void *)realcipher;
}

static int binary_hash_0(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xF;
}

static int binary_hash_1(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xFF;
}

static int binary_hash_2(void *binary)
{
  return ((unsigned int *)binary)[0] & 0xFFF;
}

static int get_hash_0(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xF;
}

static int get_hash_1(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xFF;
}

static int get_hash_2(int index)
{
  return ((unsigned long *)crypt_key)[index] & 0xFFF;
}

struct fmt_main fmt_rawSHA1 = {
	{
		FORMAT_LABEL,
		FORMAT_NAME,
		ALGORITHM_NAME,
		BENCHMARK_COMMENT,
		BENCHMARK_LENGTH,
		PLAINTEXT_LENGTH,
		BINARY_SIZE,
		SALT_SIZE,
		MIN_KEYS_PER_CRYPT,
		MAX_KEYS_PER_CRYPT,
		FMT_CASE | FMT_8_BIT,
		rawsha1_tests
	}, {
		rawsha1_init,
		valid,
		fmt_default_split,
		rawsha1_binary,
		fmt_default_salt,
		{
			binary_hash_0,
			binary_hash_1,
			binary_hash_2
		},
		fmt_default_salt_hash,
		rawsha1_set_salt,
		rawsha1_set_key,
		rawsha1_get_key,
		fmt_default_clear_keys,
		rawsha1_crypt_all,
		{
			get_hash_0,
			get_hash_1,
			get_hash_2
		},
		rawsha1_cmp_all,
		rawsha1_cmp_one,
		rawsha1_cmp_exact
	}
};




/* crypto/sha/sha.h */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#ifndef HEADER_SHA_H
#define HEADER_SHA_H

#ifdef  __cplusplus
extern "C" {
#endif

#define SHA_CBLOCK	64
#define SHA_LBLOCK	16
#define SHA_BLOCK	16
#define SHA_LAST_BLOCK  56
#define SHA_LENGTH_BLOCK 8
#define SHA_DIGEST_LENGTH 20

typedef struct SHAstate_st
	{
	unsigned long h0,h1,h2,h3,h4;
	unsigned long Nl,Nh;
	unsigned long data[SHA_LBLOCK];
	int num;
	} SHA_CTX;

#ifndef NOPROTO
void SHA_Init(SHA_CTX *c);
void SHA_Update(SHA_CTX *c, unsigned char *data, unsigned long len);
void SHA_Final(unsigned char *md, SHA_CTX *c);
unsigned char *SHA(unsigned char *d, unsigned long n,unsigned char *md);
void SHA_Transform(SHA_CTX *c, unsigned char *data);
void SHA1_Init(SHA_CTX *c);
void SHA1_Update(SHA_CTX *c, unsigned char *data, unsigned long len);
void SHA1_Final(unsigned char *md, SHA_CTX *c);
unsigned char *SHA1(unsigned char *d, unsigned long n,unsigned char *md);
void SHA1_Transform(SHA_CTX *c, unsigned char *data);
#else
void SHA_Init();
void SHA_Update();
void SHA_Final();
unsigned char *SHA();
void SHA_Transform();
void SHA1_Init();
void SHA1_Update();
void SHA1_Final();
unsigned char *SHA1();
void SHA1_Transform();
#endif

#ifdef MMX_COEF
extern int shammx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
extern int shammx_nosizeupdate(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
extern int shammx_noinit_uniformsizeupdate(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));
#endif

#ifdef  __cplusplus
}
#endif

#endif





// extern int mdfourmmx(unsigned char *out, unsigned char *in, int n) __attribute__((regparm(3)));

#include "arch.h"
#ifdef UNDERSCORES
#define shammx	_shammx
#endif

.globl shammx;
.globl shammx_nosizeupdate;
.globl shammx_noinit_uniformsizeupdate;

.data
.align(8*MMX_COEF)
const_init_a:
.long 0x67452301
.long 0x67452301
#if (MMX_COEF>=4)
.long 0x67452301
.long 0x67452301
#endif
const_init_b:
.long 0xefcdab89
.long 0xefcdab89
#if (MMX_COEF>=4)
.long 0xefcdab89
.long 0xefcdab89
#endif
const_init_c:
.long 0x98badcfe
.long 0x98badcfe
#if (MMX_COEF>=4)
.long 0x98badcfe
.long 0x98badcfe
#endif
const_init_d:
.long 0x10325476
.long 0x10325476
#if (MMX_COEF>=4)
.long 0x10325476
.long 0x10325476
#endif
const_init_e:
.long 0xc3d2e1f0
.long 0xc3d2e1f0
#if (MMX_COEF>=4)
.long 0xc3d2e1f0
.long 0xc3d2e1f0
#endif

.align(8*MMX_COEF)
const_stage0:
.long 0x5a827999
.long 0x5a827999
#if (MMX_COEF>=4)
.long 0x5a827999
.long 0x5a827999
#endif
const_stage1:
.long 0x6ed9eba1
.long 0x6ed9eba1
#if (MMX_COEF>=4)
.long 0x6ed9eba1
.long 0x6ed9eba1
#endif
const_stage2:
.long 0x8f1bbcdc
.long 0x8f1bbcdc
#if (MMX_COEF>=4)
.long 0x8f1bbcdc
.long 0x8f1bbcdc
#endif
const_stage3:
.long 0xca62c1d6
.long 0xca62c1d6
#if (MMX_COEF>=4)
.long 0xca62c1d6
.long 0xca62c1d6
#endif

.align(8*MMX_COEF)
mask0f0f:
.long 0x00ff00ff
.long 0x00ff00ff
#if (MMX_COEF>=4)
.long 0x00ff00ff
.long 0x00ff00ff
#endif
maskf0f0:
.long 0xff00ff00
.long 0xff00ff00
#if (MMX_COEF>=4)
.long 0xff00ff00
.long 0xff00ff00
#endif

#if (MMX_COEF == 2)
#define MMXMOVE movq
#define REGMM0 %mm0
#define REGMM1 %mm1
#define REGMM2 %mm2
#define REGMM3 %mm3
#define REGMM4 %mm4
#define REGMM5 %mm5
#define REGMM6 %mm6
#define REGMM7 %mm7
storea: ; .long 0 ; .long 0
storeb: ; .long 0 ; .long 0
storec: ; .long 0 ; .long 0
stored: ; .long 0 ; .long 0
storee: ; .long 0 ; .long 0
#else
#define MMXMOVE movapd
#define REGMM0 %xmm0
#define REGMM1 %xmm1
#define REGMM2 %xmm2
#define REGMM3 %xmm3
#define REGMM4 %xmm4
#define REGMM5 %xmm5
#define REGMM6 %xmm6
#define REGMM7 %xmm7
storea: ; .long 0 ; .long 0 ; .long 0 ; .long 0
storeb: ; .long 0 ; .long 0 ; .long 0 ; .long 0
storec: ; .long 0 ; .long 0 ; .long 0 ; .long 0
stored: ; .long 0 ; .long 0 ; .long 0 ; .long 0
storee: ; .long 0 ; .long 0 ; .long 0 ; .long 0
#endif

#define ctxa REGMM0
#define ctxb REGMM1
#define ctxc REGMM2
#define ctxd REGMM3
#define ctxe REGMM4
#define tmp1 REGMM5
#define tmp2 REGMM6
#define tmp3 REGMM7

//ft(x,y,z) = (x AND y) OR ((NOT x) AND z) ( 0 <= t <= 19) 
#define F0(x,y,z) \
	MMXMOVE x, tmp2; \
	MMXMOVE x, tmp1; \
	pand y, tmp2; \
	pandn z, tmp1; \
	por tmp2, tmp1; 

//ft(x,y,z) = x XOR y XOR z (20 <= t <= 39)
#define F1(x,y,z) \
	MMXMOVE z, tmp1; \
	pxor y, tmp1; \
	pxor x, tmp1

//ft(x,y,z) = (x AND y) OR (x AND z) OR (y AND z) (40 <= t <= 59)
//ft(x,y,z) = (x AND y) | ((x OR y) AND z) (40 <= t <= 59)
#define F2(x,y,z) \
	MMXMOVE x, tmp1; \
	MMXMOVE x, tmp2; \
	pand y, tmp1; \
	por y, tmp2; \
	pand z, tmp2; \
	por tmp2, tmp1;
	
//ft(x,y,z) = x XOR y XOR z (60 <= t <= 79).  = la seconde


#define expand(t) \
	MMXMOVE ((t-3)*4*MMX_COEF)(%edx), tmp1; \
	pxor ((t-8)*4*MMX_COEF)(%edx), tmp1; \
	pxor ((t-14)*4*MMX_COEF)(%edx), tmp1; \
	pxor ((t-16)*4*MMX_COEF)(%edx), tmp1; \
	MMXMOVE tmp1, tmp2; \
	pslld $1, tmp1; \
	psrld $31, tmp2; \
	por tmp2, tmp1; \
	MMXMOVE tmp1, (t*4*MMX_COEF)(%edx)

#define subRound(a, b, c, d, e, f, k, data) \
	f(b,c,d); \
	MMXMOVE a, tmp2; \
	MMXMOVE a, tmp3; \
	paddd tmp1, e; \
	pslld $5, tmp2; \
	psrld $27, tmp3; \
	por tmp3, tmp2; \
	paddd tmp2, e; \
	MMXMOVE b, tmp2; \
	pslld $30, b; \
	paddd k, e; \
	paddd (data*4*MMX_COEF)(%edx), e; \
	psrld $2, tmp2; \
	por tmp2, b;

#define subRoundu(a, b, c, d, e, f, k, data) \
	expand(data); \
	paddd tmp1, e; \
	f(b,c,d); \
	MMXMOVE a, tmp2; \
	MMXMOVE a, tmp3; \
	paddd tmp1, e; \
	pslld $5, tmp2; \
	psrld $27, tmp3; \
	por tmp3, tmp2; \
	paddd tmp2, e; \
	MMXMOVE b, tmp2; \
	pslld $30, b; \
	paddd k, e; \
	psrld $2, tmp2; \
	por tmp2, b;

.text
/*
 * Try to do some asm md4 w/ mmx
 * %eax ptr -> out
 * %edx ptr -> in (80*MMX_WIDTH mots)
 * %ecx n
 */

init_ctx:
	MMXMOVE const_init_a, ctxa
	MMXMOVE const_init_b, ctxb
	MMXMOVE const_init_c, ctxc
	MMXMOVE const_init_d, ctxd
	MMXMOVE const_init_e, ctxe
	ret

sizeupdate:
	 //MD4 Init
#if (MMX_COEF == 2)	
	shl $3, %ecx
	mov %ecx, %ebx
	and $0xffff, %ecx
	shrl $16,  %ebx
	// %ecx contient la taille du premier mdp
	// %edx celle du second
	mov %ecx, (15*4*MMX_COEF)(%edx)
	mov %ebx, (15*4*MMX_COEF+4)(%edx)
#else
	mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (15*16)(%edx)
        
        mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (15*16+4)(%edx)

        mov %ecx, %ebx
        shr $8, %ecx
        and $0xff, %ebx
        shl $3, %ebx
        mov %ebx, (15*16+8)(%edx)

        and $0xff, %ecx
        shl $3, %ecx
        mov %ecx, (15*16+12)(%edx)
#endif
	ret


uniformsizeupdate:
	shl $3, %ecx
	mov %ecx, (14*4*MMX_COEF)(%edx)
	mov %ecx, (14*4*MMX_COEF+4)(%edx)
#if (MMX_COEF == 4)
	mov %ecx, (14*4*MMX_COEF+8)(%edx)
	mov %ecx, (14*4*MMX_COEF+12)(%edx)
#endif
	ret


shammx_noinit_sizeupdate:
	pusha
	call sizeupdate
	jmp shammx_noinit

shammx_noinit_uniformsizeupdate:
	pusha
	call uniformsizeupdate
	jmp shammx_noinit

shammx:
	pusha
	call sizeupdate
	call init_ctx
	jmp shammx_noinit

shammx_nosizeupdate:
	pusha
	call init_ctx
	jmp shammx_noinit

shammx_noinit:
	MMXMOVE ctxa, storea
	MMXMOVE ctxb, storeb
	MMXMOVE ctxc, storec
	MMXMOVE ctxd, stored
	MMXMOVE ctxe, storee

round0:
	prefetchnta (%edx)
	subRound( ctxa, ctxb, ctxc, ctxd, ctxe, F0, const_stage0,  0 );
	subRound( ctxe, ctxa, ctxb, ctxc, ctxd, F0, const_stage0,  1 );
	subRound( ctxd, ctxe, ctxa, ctxb, ctxc, F0, const_stage0,  2 );
	subRound( ctxc, ctxd, ctxe, ctxa, ctxb, F0, const_stage0,  3 );
	subRound( ctxb, ctxc, ctxd, ctxe, ctxa, F0, const_stage0,  4 );
	subRound( ctxa, ctxb, ctxc, ctxd, ctxe, F0, const_stage0,  5 );
	subRound( ctxe, ctxa, ctxb, ctxc, ctxd, F0, const_stage0,  6 );
	subRound( ctxd, ctxe, ctxa, ctxb, ctxc, F0, const_stage0,  7 );
	subRound( ctxc, ctxd, ctxe, ctxa, ctxb, F0, const_stage0,  8 );
	subRound( ctxb, ctxc, ctxd, ctxe, ctxa, F0, const_stage0,  9 );
	subRound( ctxa, ctxb, ctxc, ctxd, ctxe, F0, const_stage0, 10 );
	subRound( ctxe, ctxa, ctxb, ctxc, ctxd, F0, const_stage0, 11 );
	subRound( ctxd, ctxe, ctxa, ctxb, ctxc, F0, const_stage0, 12 );
	subRound( ctxc, ctxd, ctxe, ctxa, ctxb, F0, const_stage0, 13 );
	subRound( ctxb, ctxc, ctxd, ctxe, ctxa, F0, const_stage0, 14 );
	subRound( ctxa, ctxb, ctxc, ctxd, ctxe, F0, const_stage0, 15 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F0, const_stage0, 16 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F0, const_stage0, 17 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F0, const_stage0, 18 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F0, const_stage0, 19 );

round1:
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage1, 20 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage1, 21 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage1, 22 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage1, 23 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage1, 24 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage1, 25 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage1, 26 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage1, 27 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage1, 28 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage1, 29 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage1, 30 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage1, 31 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage1, 32 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage1, 33 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage1, 34 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage1, 35 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage1, 36 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage1, 37 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage1, 38 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage1, 39 );

round2:
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F2, const_stage2, 40 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F2, const_stage2, 41 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F2, const_stage2, 42 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F2, const_stage2, 43 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F2, const_stage2, 44 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F2, const_stage2, 45 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F2, const_stage2, 46 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F2, const_stage2, 47 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F2, const_stage2, 48 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F2, const_stage2, 49 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F2, const_stage2, 50 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F2, const_stage2, 51 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F2, const_stage2, 52 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F2, const_stage2, 53 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F2, const_stage2, 54 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F2, const_stage2, 55 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F2, const_stage2, 56 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F2, const_stage2, 57 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F2, const_stage2, 58 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F2, const_stage2, 59 );

round3:
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage3, 60 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage3, 61 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage3, 62 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage3, 63 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage3, 64 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage3, 65 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage3, 66 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage3, 67 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage3, 68 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage3, 69 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage3, 70 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage3, 71 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage3, 72 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage3, 73 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage3, 74 );
	subRoundu( ctxa, ctxb, ctxc, ctxd, ctxe, F1, const_stage3, 75 );
	subRoundu( ctxe, ctxa, ctxb, ctxc, ctxd, F1, const_stage3, 76 );
	subRoundu( ctxd, ctxe, ctxa, ctxb, ctxc, F1, const_stage3, 77 );
	subRoundu( ctxc, ctxd, ctxe, ctxa, ctxb, F1, const_stage3, 78 );
	subRoundu( ctxb, ctxc, ctxd, ctxe, ctxa, F1, const_stage3, 79 );

	paddd storea, ctxa
	paddd storeb, ctxb
	paddd storec, ctxc
	paddd stored, ctxd
	paddd storee, ctxe
	MMXMOVE ctxa, storea
	MMXMOVE ctxb, storeb
	MMXMOVE ctxc, storec
	MMXMOVE ctxd, stored
	MMXMOVE ctxe, storee
	jmp endianity

endianity:

//reverse indianity w/ rotate & and
//mmx has no rotate instructions ..
#define ENDIAN(a) \
	MMXMOVE a, tmp1; \
	MMXMOVE maskf0f0, tmp3; \
	pand tmp3, a; \
	MMXMOVE mask0f0f, tmp3; \
	pand tmp3, tmp1; \
	psrld $8, a; \
	pslld $8, tmp1; \
	por tmp1, a; \
	MMXMOVE a, tmp1; \
	psrld $16, a; \
	pslld $16, tmp1; \
	por tmp1, a

// why is this so slow ?
#define ENDIAN2(a) \
	pshuflw $177,a,a; \
	pshufhw $177,a,a; \
	movq a,tmp1; \
	pand maskf0f0, a; \
	pand mask0f0f, tmp1; \
	psrld $8, a; \
	pslld $8, tmp1; \
	por tmp1, a

//changes indianity ...
	MMXMOVE maskf0f0, tmp3
	MMXMOVE ctxa, tmp1
	MMXMOVE ctxb, tmp2
	pand tmp3, ctxa
	pand tmp3, ctxb
	MMXMOVE mask0f0f, tmp3
	pand tmp3, tmp1
	pand tmp3, tmp2
	psrld $8, ctxa
	psrld $8, ctxb
	pslld $8, tmp1
	pslld $8, tmp2
	por tmp1, ctxa
	por tmp2, ctxb
	MMXMOVE ctxa, tmp1
	MMXMOVE ctxb, tmp2
	psrld $16, ctxa
	psrld $16, ctxb
	pslld $16, tmp1
	pslld $16, tmp2
	por tmp1, ctxa
	por tmp2, ctxb 
	MMXMOVE ctxa, 0(%eax)
	MMXMOVE ctxb, 4*MMX_COEF(%eax)


//now 2 more register to play with ..
#define tmp4 ctxa
#define tmp5 ctxb

	MMXMOVE maskf0f0, tmp5
	MMXMOVE ctxc, tmp1
	MMXMOVE ctxd, tmp2
	MMXMOVE ctxe, tmp3
	pand tmp5, ctxc
	pand tmp5, ctxd
	pand tmp5, ctxe
	MMXMOVE mask0f0f, tmp5
	pand tmp5, tmp1
	pand tmp5, tmp2
	pand tmp5, tmp3
	psrld $8, ctxc
	psrld $8, ctxd
	psrld $8, ctxe
	pslld $8, tmp1
	pslld $8, tmp2
	pslld $8, tmp3
	por tmp1, ctxc
	por tmp2, ctxd
	por tmp3, ctxe
	MMXMOVE ctxc, tmp1
	MMXMOVE ctxd, tmp2
	MMXMOVE ctxe, tmp3
	psrld $16, ctxc
	psrld $16, ctxd
	psrld $16, ctxe
	pslld $16, tmp1
	pslld $16, tmp2
	pslld $16, tmp3
	por tmp1, ctxc
	por tmp2, ctxd
	por tmp3, ctxe

	MMXMOVE ctxc, 8*MMX_COEF(%eax)
	MMXMOVE ctxd, 12*MMX_COEF(%eax)
	MMXMOVE ctxe, 16*MMX_COEF(%eax)

	//mov %ecx, %eax
	//movd ctxe, %eax
	popa
	emms
	
	ret

/*
 alternate endianity conversion
 shouldn't be so slow ...
	pshuflw $177, ctxa, ctxa
	pshuflw $177, ctxb, ctxb
	pshuflw $177, ctxc, ctxc
	pshuflw $177, ctxd, ctxd
	pshuflw $177, ctxe, ctxe
	movq maskf0f0, tmp3
	pshufhw $177, ctxa, ctxa
	pshufhw $177, ctxb, ctxb
	pshufhw $177, ctxc, ctxc
	pshufhw $177, ctxd, ctxd
	pshufhw $177, ctxe, ctxe
	movq ctxa, tmp1
	movq ctxb, tmp2
	pand tmp3, ctxa
	pand tmp3, ctxb
	movq mask0f0f, tmp3
	pand tmp3, tmp1
	pand tmp3, tmp2
	psrld $8, ctxa
	psrld $8, ctxb
	pslld $8, tmp1
	pslld $8, tmp2
	por tmp1, ctxa
	por tmp2, ctxb
	MMXMOVE ctxa, 0(%eax)
	MMXMOVE ctxb, 4*MMX_COEF(%eax)

//now 2 more register to play with ..
#define tmp4 ctxa
#define tmp5 ctxb
	movq ctxc, tmp1
	movq ctxd, tmp2
	movq ctxe, tmp4
	pand tmp3, tmp1
	pand tmp3, tmp2
	pand tmp3, tmp4
	movq maskf0f0, tmp3
	pand tmp3, ctxc
	pand tmp3, ctxd
	pand tmp3, ctxe
	psrld $8, ctxc
	psrld $8, ctxd
	psrld $8, ctxe
	pslld $8, tmp1
	pslld $8, tmp2
	pslld $8, tmp4
	por tmp1, ctxc
	por tmp2, ctxd
	por tmp4, ctxe
*/
#ifdef __ELF__
.section .note.GNU-stack,"",@progbits
#endif




/* crypto/sha/sha1dgst.c */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include <string.h>
#undef  SHA_0
#define SHA_1
#include "sha.h"
#include "sha_locl.h"

char *SHA1_version="SHA1 part of SSLeay 0.8.2b 08-Jan-1998";

/* Implemented from SHA-1 document - The Secure Hash Algorithm
 */

#define INIT_DATA_h0 (unsigned long)0x67452301L
#define INIT_DATA_h1 (unsigned long)0xefcdab89L
#define INIT_DATA_h2 (unsigned long)0x98badcfeL
#define INIT_DATA_h3 (unsigned long)0x10325476L
#define INIT_DATA_h4 (unsigned long)0xc3d2e1f0L

#define K_00_19	0x5a827999L
#define K_20_39 0x6ed9eba1L
#define K_40_59 0x8f1bbcdcL
#define K_60_79 0xca62c1d6L

#ifndef NOPROTO
#  ifdef SHA1_ASM
     void sha1_block_x86(SHA_CTX *c, register unsigned long *p, int num);
#    define sha1_block sha1_block_x86
#  else
     void sha1_block(SHA_CTX *c, register unsigned long *p, int num);
#  endif
#else
#  ifdef SHA1_ASM
     void sha1_block_x86();
#    define sha1_block sha1_block_x86
#  else
     void sha1_block();
#  endif
#endif

#if defined(L_ENDIAN) && defined(SHA1_ASM)
#  define	M_c2nl 		c2l
#  define	M_p_c2nl 	p_c2l
#  define	M_c2nl_p	c2l_p
#  define	M_p_c2nl_p	p_c2l_p
#  define	M_nl2c		l2c
#else
#  define	M_c2nl 		c2nl
#  define	M_p_c2nl	p_c2nl
#  define	M_c2nl_p	c2nl_p
#  define	M_p_c2nl_p	p_c2nl_p
#  define	M_nl2c		nl2c
#endif

void SHA1_Init(c)
SHA_CTX *c;
	{
	c->h0=INIT_DATA_h0;
	c->h1=INIT_DATA_h1;
	c->h2=INIT_DATA_h2;
	c->h3=INIT_DATA_h3;
	c->h4=INIT_DATA_h4;
	c->Nl=0;
	c->Nh=0;
	c->num=0;
	}

void SHA1_Update(c, data, len)
SHA_CTX *c;
register unsigned char *data;
unsigned long len;
	{
	register unsigned long *p;
	int ew,ec,sw,sc;
	unsigned long l;

	if (len == 0) return;

	l=(c->Nl+(len<<3))&0xffffffffL;
	if (l < c->Nl) /* overflow */
		c->Nh++;
	c->Nh+=(len>>29);
	c->Nl=l;

	if (c->num != 0)
		{
		p=c->data;
		sw=c->num>>2;
		sc=c->num&0x03;

		if ((c->num+len) >= SHA_CBLOCK)
			{
			l= p[sw];
			M_p_c2nl(data,l,sc);
			p[sw++]=l;
			for (; sw<SHA_LBLOCK; sw++)
				{
				M_c2nl(data,l);
				p[sw]=l;
				}
			len-=(SHA_CBLOCK-c->num);

			sha1_block(c,p,64);
			c->num=0;
			/* drop through and do the rest */
			}
		else
			{
			c->num+=(int)len;
			if ((sc+len) < 4) /* ugly, add char's to a word */
				{
				l= p[sw];
				M_p_c2nl_p(data,l,sc,len);
				p[sw]=l;
				}
			else
				{
				ew=(c->num>>2);
				ec=(c->num&0x03);
				l= p[sw];
				M_p_c2nl(data,l,sc);
				p[sw++]=l;
				for (; sw < ew; sw++)
					{ M_c2nl(data,l); p[sw]=l; }
				if (ec)
					{
					M_c2nl_p(data,l,ec);
					p[sw]=l;
					}
				}
			return;
			}
		}
	/* We can only do the following code for assember, the reason
	 * being that the sha1_block 'C' version changes the values
	 * in the 'data' array.  The assember code avoids this and
	 * copies it to a local array.  I should be able to do this for
	 * the C version as well....
	 */
#if 1
#if defined(B_ENDIAN) || defined(SHA1_ASM)
	if ((((unsigned int)data)%sizeof(unsigned long)) == 0)
		{
		sw=len/SHA_CBLOCK;
		if (sw)
			{
			sw*=SHA_CBLOCK;
			sha1_block(c,(unsigned long *)data,sw);
			data+=sw;
			len-=sw;
			}
		}
#endif
#endif
	/* we now can process the input data in blocks of SHA_CBLOCK
	 * chars and save the leftovers to c->data. */
	p=c->data;
	while (len >= SHA_CBLOCK)
		{
#if defined(B_ENDIAN) || defined(L_ENDIAN)
		if (p != (unsigned long *)data)
			memcpy(p,data,SHA_CBLOCK);
		data+=SHA_CBLOCK;
#  ifdef L_ENDIAN
#    ifndef SHA1_ASM /* Will not happen */
		for (sw=(SHA_LBLOCK/4); sw; sw--)
			{
			Endian_Reverse32(p[0]);
			Endian_Reverse32(p[1]);
			Endian_Reverse32(p[2]);
			Endian_Reverse32(p[3]);
			p+=4;
			}
		p=c->data;
#    endif
#  endif
#else
		for (sw=(SHA_BLOCK/4); sw; sw--)
			{
			M_c2nl(data,l); *(p++)=l;
			M_c2nl(data,l); *(p++)=l;
			M_c2nl(data,l); *(p++)=l;
			M_c2nl(data,l); *(p++)=l;
			}
		p=c->data;
#endif
		sha1_block(c,p,64);
		len-=SHA_CBLOCK;
		}
	ec=(int)len;
	c->num=ec;
	ew=(ec>>2);
	ec&=0x03;

	for (sw=0; sw < ew; sw++)
		{ M_c2nl(data,l); p[sw]=l; }
	M_c2nl_p(data,l,ec);
	p[sw]=l;
	}

void SHA1_Transform(c,b)
SHA_CTX *c;
unsigned char *b;
	{
	unsigned long p[16];
#ifndef B_ENDIAN
	unsigned long *q;
	int i;
#endif

#if defined(B_ENDIAN) || defined(L_ENDIAN)
	memcpy(p,b,64);
#ifdef L_ENDIAN
	q=p;
	for (i=(SHA_LBLOCK/4); i; i--)
		{
		Endian_Reverse32(q[0]);
		Endian_Reverse32(q[1]);
		Endian_Reverse32(q[2]);
		Endian_Reverse32(q[3]);
		q+=4;
		}
#endif
#else
	q=p;
	for (i=(SHA_LBLOCK/4); i; i--)
		{
		unsigned long l;
		c2nl(b,l); *(q++)=l;
		c2nl(b,l); *(q++)=l;
		c2nl(b,l); *(q++)=l;
		c2nl(b,l); *(q++)=l; 
		} 
#endif
	sha1_block(c,p,64);
	}

#ifndef SHA1_ASM

void sha1_block(c, W, num)
SHA_CTX *c;
register unsigned long *W;
int num;
	{
	register unsigned long A,B,C,D,E,T;
	unsigned long X[16];

	A=c->h0;
	B=c->h1;
	C=c->h2;
	D=c->h3;
	E=c->h4;

	for (;;)
		{
	BODY_00_15( 0,A,B,C,D,E,T,W);
	BODY_00_15( 1,T,A,B,C,D,E,W);
	BODY_00_15( 2,E,T,A,B,C,D,W);
	BODY_00_15( 3,D,E,T,A,B,C,W);
	BODY_00_15( 4,C,D,E,T,A,B,W);
	BODY_00_15( 5,B,C,D,E,T,A,W);
	BODY_00_15( 6,A,B,C,D,E,T,W);
	BODY_00_15( 7,T,A,B,C,D,E,W);
	BODY_00_15( 8,E,T,A,B,C,D,W);
	BODY_00_15( 9,D,E,T,A,B,C,W);
	BODY_00_15(10,C,D,E,T,A,B,W);
	BODY_00_15(11,B,C,D,E,T,A,W);
	BODY_00_15(12,A,B,C,D,E,T,W);
	BODY_00_15(13,T,A,B,C,D,E,W);
	BODY_00_15(14,E,T,A,B,C,D,W);
	BODY_00_15(15,D,E,T,A,B,C,W);
	BODY_16_19(16,C,D,E,T,A,B,W,W,W,W);
	BODY_16_19(17,B,C,D,E,T,A,W,W,W,W);
	BODY_16_19(18,A,B,C,D,E,T,W,W,W,W);
	BODY_16_19(19,T,A,B,C,D,E,W,W,W,X);

	BODY_20_31(20,E,T,A,B,C,D,W,W,W,X);
	BODY_20_31(21,D,E,T,A,B,C,W,W,W,X);
	BODY_20_31(22,C,D,E,T,A,B,W,W,W,X);
	BODY_20_31(23,B,C,D,E,T,A,W,W,W,X);
	BODY_20_31(24,A,B,C,D,E,T,W,W,X,X);
	BODY_20_31(25,T,A,B,C,D,E,W,W,X,X);
	BODY_20_31(26,E,T,A,B,C,D,W,W,X,X);
	BODY_20_31(27,D,E,T,A,B,C,W,W,X,X);
	BODY_20_31(28,C,D,E,T,A,B,W,W,X,X);
	BODY_20_31(29,B,C,D,E,T,A,W,W,X,X);
	BODY_20_31(30,A,B,C,D,E,T,W,X,X,X);
	BODY_20_31(31,T,A,B,C,D,E,W,X,X,X);
	BODY_32_39(32,E,T,A,B,C,D,X);
	BODY_32_39(33,D,E,T,A,B,C,X);
	BODY_32_39(34,C,D,E,T,A,B,X);
	BODY_32_39(35,B,C,D,E,T,A,X);
	BODY_32_39(36,A,B,C,D,E,T,X);
	BODY_32_39(37,T,A,B,C,D,E,X);
	BODY_32_39(38,E,T,A,B,C,D,X);
	BODY_32_39(39,D,E,T,A,B,C,X);

	BODY_40_59(40,C,D,E,T,A,B,X);
	BODY_40_59(41,B,C,D,E,T,A,X);
	BODY_40_59(42,A,B,C,D,E,T,X);
	BODY_40_59(43,T,A,B,C,D,E,X);
	BODY_40_59(44,E,T,A,B,C,D,X);
	BODY_40_59(45,D,E,T,A,B,C,X);
	BODY_40_59(46,C,D,E,T,A,B,X);
	BODY_40_59(47,B,C,D,E,T,A,X);
	BODY_40_59(48,A,B,C,D,E,T,X);
	BODY_40_59(49,T,A,B,C,D,E,X);
	BODY_40_59(50,E,T,A,B,C,D,X);
	BODY_40_59(51,D,E,T,A,B,C,X);
	BODY_40_59(52,C,D,E,T,A,B,X);
	BODY_40_59(53,B,C,D,E,T,A,X);
	BODY_40_59(54,A,B,C,D,E,T,X);
	BODY_40_59(55,T,A,B,C,D,E,X);
	BODY_40_59(56,E,T,A,B,C,D,X);
	BODY_40_59(57,D,E,T,A,B,C,X);
	BODY_40_59(58,C,D,E,T,A,B,X);
	BODY_40_59(59,B,C,D,E,T,A,X);

	BODY_60_79(60,A,B,C,D,E,T,X);
	BODY_60_79(61,T,A,B,C,D,E,X);
	BODY_60_79(62,E,T,A,B,C,D,X);
	BODY_60_79(63,D,E,T,A,B,C,X);
	BODY_60_79(64,C,D,E,T,A,B,X);
	BODY_60_79(65,B,C,D,E,T,A,X);
	BODY_60_79(66,A,B,C,D,E,T,X);
	BODY_60_79(67,T,A,B,C,D,E,X);
	BODY_60_79(68,E,T,A,B,C,D,X);
	BODY_60_79(69,D,E,T,A,B,C,X);
	BODY_60_79(70,C,D,E,T,A,B,X);
	BODY_60_79(71,B,C,D,E,T,A,X);
	BODY_60_79(72,A,B,C,D,E,T,X);
	BODY_60_79(73,T,A,B,C,D,E,X);
	BODY_60_79(74,E,T,A,B,C,D,X);
	BODY_60_79(75,D,E,T,A,B,C,X);
	BODY_60_79(76,C,D,E,T,A,B,X);
	BODY_60_79(77,B,C,D,E,T,A,X);
	BODY_60_79(78,A,B,C,D,E,T,X);
	BODY_60_79(79,T,A,B,C,D,E,X);
	
	c->h0=(c->h0+E)&0xffffffffL; 
	c->h1=(c->h1+T)&0xffffffffL;
	c->h2=(c->h2+A)&0xffffffffL;
	c->h3=(c->h3+B)&0xffffffffL;
	c->h4=(c->h4+C)&0xffffffffL;

	num-=64;
	if (num <= 0) break;

	A=c->h0;
	B=c->h1;
	C=c->h2;
	D=c->h3;
	E=c->h4;

	W+=16;
		}
	}
#endif

void SHA1_Final(md, c)
unsigned char *md;
SHA_CTX *c;
	{
	register int i,j;
	register unsigned long l;
	register unsigned long *p;
	static unsigned char end[4]={0x80,0x00,0x00,0x00};
	unsigned char *cp=end;

	/* c->num should definitly have room for at least one more byte. */
	p=c->data;
	j=c->num;
	i=j>>2;
#ifdef PURIFY
	if ((j&0x03) == 0) p[i]=0;
#endif
	l=p[i];
	M_p_c2nl(cp,l,j&0x03);
	p[i]=l;
	i++;
	/* i is the next 'undefined word' */
	if (c->num >= SHA_LAST_BLOCK)
		{
		for (; i<SHA_LBLOCK; i++)
			p[i]=0;
		sha1_block(c,p,64);
		i=0;
		}
	for (; i<(SHA_LBLOCK-2); i++)
		p[i]=0;
	p[SHA_LBLOCK-2]=c->Nh;
	p[SHA_LBLOCK-1]=c->Nl;
#if defined(L_ENDIAN) && defined(SHA1_ASM)
	Endian_Reverse32(p[SHA_LBLOCK-2]);
	Endian_Reverse32(p[SHA_LBLOCK-1]);
#endif
	sha1_block(c,p,64);
	cp=md;
	l=c->h0; nl2c(l,cp);
	l=c->h1; nl2c(l,cp);
	l=c->h2; nl2c(l,cp);
	l=c->h3; nl2c(l,cp);
	l=c->h4; nl2c(l,cp);

	/* clear stuff, sha1_block may be leaving some stuff on the stack
	 * but I'm not worried :-) */
	c->num=0;
/*	memset((char *)&c,0,sizeof(c));*/
	}





/* crypto/sha/sha_locl.h */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdlib.h>
#include <string.h>

#ifdef undef
/* one or the other needs to be defined */
#ifndef SHA_1 /* FIPE 180-1 */
#define SHA_0 /* FIPS 180   */
#endif
#endif

#ifdef NOCONST
#define const
#endif

#undef c2nl
#define c2nl(c,l)	(l =(((unsigned long)(*((c)++)))<<24), \
			 l|=(((unsigned long)(*((c)++)))<<16), \
			 l|=(((unsigned long)(*((c)++)))<< 8), \
			 l|=(((unsigned long)(*((c)++)))    ))

#undef p_c2nl
#define p_c2nl(c,l,n)	{ \
			switch (n) { \
			case 0: l =((unsigned long)(*((c)++)))<<24; \
			case 1: l|=((unsigned long)(*((c)++)))<<16; \
			case 2: l|=((unsigned long)(*((c)++)))<< 8; \
			case 3: l|=((unsigned long)(*((c)++))); \
				} \
			}

#undef c2nl_p
/* NOTE the pointer is not incremented at the end of this */
#define c2nl_p(c,l,n)	{ \
			l=0; \
			(c)+=n; \
			switch (n) { \
			case 3: l =((unsigned long)(*(--(c))))<< 8; \
			case 2: l|=((unsigned long)(*(--(c))))<<16; \
			case 1: l|=((unsigned long)(*(--(c))))<<24; \
				} \
			}

#undef p_c2nl_p
#define p_c2nl_p(c,l,sc,len) { \
			switch (sc) \
				{ \
			case 0: l =((unsigned long)(*((c)++)))<<24; \
				if (--len == 0) break; \
			case 1: l|=((unsigned long)(*((c)++)))<<16; \
				if (--len == 0) break; \
			case 2: l|=((unsigned long)(*((c)++)))<< 8; \
				} \
			}

#undef nl2c
#define nl2c(l,c)	(*((c)++)=(unsigned char)(((l)>>24)&0xff), \
			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
			 *((c)++)=(unsigned char)(((l)    )&0xff))

#undef c2l
#define c2l(c,l)	(l =(((unsigned long)(*((c)++)))    ), \
			 l|=(((unsigned long)(*((c)++)))<< 8), \
			 l|=(((unsigned long)(*((c)++)))<<16), \
			 l|=(((unsigned long)(*((c)++)))<<24))

#undef p_c2l
#define p_c2l(c,l,n)	{ \
			switch (n) { \
			case 0: l =((unsigned long)(*((c)++))); \
			case 1: l|=((unsigned long)(*((c)++)))<< 8; \
			case 2: l|=((unsigned long)(*((c)++)))<<16; \
			case 3: l|=((unsigned long)(*((c)++)))<<24; \
				} \
			}

#undef c2l_p
/* NOTE the pointer is not incremented at the end of this */
#define c2l_p(c,l,n)	{ \
			l=0; \
			(c)+=n; \
			switch (n) { \
			case 3: l =((unsigned long)(*(--(c))))<<16; \
			case 2: l|=((unsigned long)(*(--(c))))<< 8; \
			case 1: l|=((unsigned long)(*(--(c)))); \
				} \
			}

#undef p_c2l_p
#define p_c2l_p(c,l,sc,len) { \
			switch (sc) \
				{ \
			case 0: l =((unsigned long)(*((c)++))); \
				if (--len == 0) break; \
			case 1: l|=((unsigned long)(*((c)++)))<< 8; \
				if (--len == 0) break; \
			case 2: l|=((unsigned long)(*((c)++)))<<16; \
				} \
			}

#undef l2c
#define l2c(l,c)	(*((c)++)=(unsigned char)(((l)    )&0xff), \
			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
			 *((c)++)=(unsigned char)(((l)>>24)&0xff))

#undef ROTATE
#if defined(WIN32)
#define ROTATE(a,n)     _lrotl(a,n)
#else
#define ROTATE(a,n)     (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
#endif

/* A nice byte order reversal from Wei Dai <weidai@eskimo.com> */
#if defined(WIN32)
/* 5 instructions with rotate instruction, else 9 */
#define Endian_Reverse32(a) \
	{ \
	unsigned long l=(a); \
	(a)=((ROTATE(l,8)&0x00FF00FF)|(ROTATE(l,24)&0xFF00FF00)); \
	}
#else
/* 6 instructions with rotate instruction, else 8 */
#define Endian_Reverse32(a) \
	{ \
	unsigned long l=(a); \
	l=(((l&0xFF00FF00)>>8L)|((l&0x00FF00FF)<<8L)); \
	(a)=ROTATE(l,16L); \
	}
#endif

/* As  pointed out by Wei Dai <weidai@eskimo.com>, F() below can be
 * simplified to the code in F_00_19.  Wei attributes these optimisations
 * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
 * #define F(x,y,z) (((x) & (y))  |  ((~(x)) & (z)))
 * I've just become aware of another tweak to be made, again from Wei Dai,
 * in F_40_59, (x&a)|(y&a) -> (x|y)&a
 */
#define	F_00_19(b,c,d)	((((c) ^ (d)) & (b)) ^ (d)) 
#define	F_20_39(b,c,d)	((b) ^ (c) ^ (d))
#define F_40_59(b,c,d)	(((b) & (c)) | (((b)|(c)) & (d))) 
#define	F_60_79(b,c,d)	F_20_39(b,c,d)

#ifdef SHA_0
#undef Xupdate
#define Xupdate(a,i,ia,ib,ic,id) X[(i)&0x0f]=(a)=\
	(ia[(i)&0x0f]^ib[((i)+2)&0x0f]^ic[((i)+8)&0x0f]^id[((i)+13)&0x0f]);
#endif
#ifdef SHA_1
#undef Xupdate
#define Xupdate(a,i,ia,ib,ic,id) (a)=\
	(ia[(i)&0x0f]^ib[((i)+2)&0x0f]^ic[((i)+8)&0x0f]^id[((i)+13)&0x0f]);\
	X[(i)&0x0f]=(a)=ROTATE((a),1);
#endif

#define BODY_00_15(i,a,b,c,d,e,f,xa) \
	(f)=xa[i]+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
	(b)=ROTATE((b),30);

#define BODY_16_19(i,a,b,c,d,e,f,xa,xb,xc,xd) \
	Xupdate(f,i,xa,xb,xc,xd); \
	(f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
	(b)=ROTATE((b),30);

#define BODY_20_31(i,a,b,c,d,e,f,xa,xb,xc,xd) \
	Xupdate(f,i,xa,xb,xc,xd); \
	(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
	(b)=ROTATE((b),30);

#define BODY_32_39(i,a,b,c,d,e,f,xa) \
	Xupdate(f,i,xa,xa,xa,xa); \
	(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
	(b)=ROTATE((b),30);

#define BODY_40_59(i,a,b,c,d,e,f,xa) \
	Xupdate(f,i,xa,xa,xa,xa); \
	(f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \
	(b)=ROTATE((b),30);

#define BODY_60_79(i,a,b,c,d,e,f,xa) \
	Xupdate(f,i,xa,xa,xa,xa); \
	(f)=X[(i)&0x0f]+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \
	(b)=ROTATE((b),30);




/* 
   Unix SMB/Netbios implementation.
   Version 1.9.
   SMB parameters and setup
   Copyright (C) Andrew Tridgell 1992-1998
   Modified by Jeremy Allison 1995.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/


#include <sys/types.h>
#include <string.h>
#include "arch.h"

#ifndef uchar
#define uchar unsigned char
#endif

#if !defined(uint16) && !defined(HAVE_UINT16_FROM_RPC_RPC_H)
#if (SIZEOF_SHORT == 4)
#define uint16 __ERROR___CANNOT_DETERMINE_TYPE_FOR_INT16;
#else /* SIZEOF_SHORT != 4 */
#define uint16 unsigned short
#endif /* SIZEOF_SHORT != 4 */
#endif

#if !defined(int16) && !defined(HAVE_INT16_FROM_RPC_RPC_H)
#if (SIZEOF_SHORT == 4)
#define int16 __ERROR___CANNOT_DETERMINE_TYPE_FOR_INT16;
#else /* SIZEOF_SHORT != 4 */
#define int16 short
#endif /* SIZEOF_SHORT != 4 */
#endif

#include "byteorder.h"

extern void mdfour(unsigned char *out, unsigned char *in, int n);

/*
 * Convert a string into an NT UNICODE string.
 * Note that regardless of processor type 
 * this must be in intel (little-endian)
 * format.
 */
 
int _my_mbstowcs(int16 *dst, uchar *src, int len)
{
	int i;
 
	for(i = 0; i < len; i++) {
#if ARCH_LITTLE_ENDIAN
		dst[i] = src[i];
#else
		dst[i] = src[i] << 8;
#endif
	}
	return i;
}

/* 
 * Creates the MD4 Hash of the users password in NT UNICODE.
 */
 
void E_md4hash(uchar *passwd, uchar *p16)
{
	int len;
	int16 wpwd[129];
	
	/* Password cannot be longer than 128 characters */
	len = strlen((char *)passwd);
	if(len > 128)
		len = 128;
	/* Password must be converted to NT unicode */
	_my_mbstowcs(wpwd, passwd, len);
	wpwd[len] = 0; /* Ensure string is null terminated */
	/* Calculate length in bytes */
	//len = _my_wcslen(wpwd) * sizeof(int16);

	mdfour(p16, (unsigned char *)wpwd, len*2);
}


Lines 410-412 Link Here

(-)john-1.7.0.1/src/sparc.S (+3 lines)
410	.common DES_KS_table, (8 * 128 * 16 * 8), 32	410	.common DES_KS_table, (8 * 128 * 16 * 8), 32
411		411
412	#endif	412	#endif
		413	#ifdef __ELF__
		414	.section .note.GNU-stack,"",@progbits
		415	#endif




const_stage_1:
.long 0xd76aa478
.long 0xd76aa478
const_stage_2:
.long 0xe8c7b756
.long 0xe8c7b756
const_stage_3:
.long 0x242070db
.long 0x242070db
const_stage_4:
.long 0xc1bdceee
.long 0xc1bdceee
const_stage_5:
.long 0xf57c0faf
.long 0xf57c0faf
const_stage_6:
.long 0x4787c62a
.long 0x4787c62a
const_stage_7:
.long 0xa8304613
.long 0xa8304613
const_stage_8:
.long 0xfd469501
.long 0xfd469501
const_stage_9:
.long 0x698098d8
.long 0x698098d8
const_stage_10:
.long 0x8b44f7af
.long 0x8b44f7af
const_stage_11:
.long 0xffff5bb1
.long 0xffff5bb1
const_stage_12:
.long 0x895cd7be
.long 0x895cd7be
const_stage_13:
.long 0x6b901122
.long 0x6b901122
const_stage_14:
.long 0xfd987193
.long 0xfd987193
const_stage_15:
.long 0xa679438e
.long 0xa679438e
const_stage_16:
.long 0x49b40821
.long 0x49b40821
const_stage_17:
.long 0xf61e2562
.long 0xf61e2562
const_stage_18:
.long 0xc040b340
.long 0xc040b340
const_stage_19:
.long 0x265e5a51
.long 0x265e5a51
const_stage_20:
.long 0xe9b6c7aa
.long 0xe9b6c7aa
const_stage_21:
.long 0xd62f105d
.long 0xd62f105d
const_stage_22:
.long 0x02441453
.long 0x02441453
const_stage_23:
.long 0xd8a1e681
.long 0xd8a1e681
const_stage_24:
.long 0xe7d3fbc8
.long 0xe7d3fbc8
const_stage_25:
.long 0x21e1cde6
.long 0x21e1cde6
const_stage_26:
.long 0xc33707d6
.long 0xc33707d6
const_stage_27:
.long 0xf4d50d87
.long 0xf4d50d87
const_stage_28:
.long 0x455a14ed
.long 0x455a14ed
const_stage_29:
.long 0xa9e3e905
.long 0xa9e3e905
const_stage_30:
.long 0xfcefa3f8
.long 0xfcefa3f8
const_stage_31:
.long 0x676f02d9
.long 0x676f02d9
const_stage_32:
.long 0x8d2a4c8a
.long 0x8d2a4c8a
const_stage_33:
.long 0xfffa3942
.long 0xfffa3942
const_stage_34:
.long 0x8771f681
.long 0x8771f681
const_stage_35:
.long 0x6d9d6122
.long 0x6d9d6122
const_stage_36:
.long 0xfde5380c
.long 0xfde5380c
const_stage_37:
.long 0xa4beea44
.long 0xa4beea44
const_stage_38:
.long 0x4bdecfa9
.long 0x4bdecfa9
const_stage_39:
.long 0xf6bb4b60
.long 0xf6bb4b60
const_stage_40:
.long 0xbebfbc70
.long 0xbebfbc70
const_stage_41:
.long 0x289b7ec6
.long 0x289b7ec6
const_stage_42:
.long 0xeaa127fa
.long 0xeaa127fa
const_stage_43:
.long 0xd4ef3085
.long 0xd4ef3085
const_stage_44:
.long 0x04881d05
.long 0x04881d05
const_stage_45:
.long 0xd9d4d039
.long 0xd9d4d039
const_stage_46:
.long 0xe6db99e5
.long 0xe6db99e5
const_stage_47:
.long 0x1fa27cf8
.long 0x1fa27cf8
const_stage_48:
.long 0xc4ac5665
.long 0xc4ac5665
const_stage_49:
.long 0xf4292244
.long 0xf4292244
const_stage_50:
.long 0x432aff97
.long 0x432aff97
const_stage_51:
.long 0xab9423a7
.long 0xab9423a7
const_stage_52:
.long 0xfc93a039
.long 0xfc93a039
const_stage_53:
.long 0x655b59c3
.long 0x655b59c3
const_stage_54:
.long 0x8f0ccc92
.long 0x8f0ccc92
const_stage_55:
.long 0xffeff47d
.long 0xffeff47d
const_stage_56:
.long 0x85845dd1
.long 0x85845dd1
const_stage_57:
.long 0x6fa87e4f
.long 0x6fa87e4f
const_stage_58:
.long 0xfe2ce6e0
.long 0xfe2ce6e0
const_stage_59:
.long 0xa3014314
.long 0xa3014314
const_stage_60:
.long 0x4e0811a1
.long 0x4e0811a1
const_stage_61:
.long 0xf7537e82
.long 0xf7537e82
const_stage_62:
.long 0xbd3af235
.long 0xbd3af235
const_stage_63:
.long 0x2ad7d2bb
.long 0x2ad7d2bb
const_stage_64:
.long 0xeb86d391
.long 0xeb86d391




const_stage_1:
.long 0xd76aa478
.long 0xd76aa478
.long 0xd76aa478
.long 0xd76aa478
const_stage_2:
.long 0xe8c7b756
.long 0xe8c7b756
.long 0xe8c7b756
.long 0xe8c7b756
const_stage_3:
.long 0x242070db
.long 0x242070db
.long 0x242070db
.long 0x242070db
const_stage_4:
.long 0xc1bdceee
.long 0xc1bdceee
.long 0xc1bdceee
.long 0xc1bdceee
const_stage_5:
.long 0xf57c0faf
.long 0xf57c0faf
.long 0xf57c0faf
.long 0xf57c0faf
const_stage_6:
.long 0x4787c62a
.long 0x4787c62a
.long 0x4787c62a
.long 0x4787c62a
const_stage_7:
.long 0xa8304613
.long 0xa8304613
.long 0xa8304613
.long 0xa8304613
const_stage_8:
.long 0xfd469501
.long 0xfd469501
.long 0xfd469501
.long 0xfd469501
const_stage_9:
.long 0x698098d8
.long 0x698098d8
.long 0x698098d8
.long 0x698098d8
const_stage_10:
.long 0x8b44f7af
.long 0x8b44f7af
.long 0x8b44f7af
.long 0x8b44f7af
const_stage_11:
.long 0xffff5bb1
.long 0xffff5bb1
.long 0xffff5bb1
.long 0xffff5bb1
const_stage_12:
.long 0x895cd7be
.long 0x895cd7be
.long 0x895cd7be
.long 0x895cd7be
const_stage_13:
.long 0x6b901122
.long 0x6b901122
.long 0x6b901122
.long 0x6b901122
const_stage_14:
.long 0xfd987193
.long 0xfd987193
.long 0xfd987193
.long 0xfd987193
const_stage_15:
.long 0xa679438e
.long 0xa679438e
.long 0xa679438e
.long 0xa679438e
const_stage_16:
.long 0x49b40821
.long 0x49b40821
.long 0x49b40821
.long 0x49b40821
const_stage_17:
.long 0xf61e2562
.long 0xf61e2562
.long 0xf61e2562
.long 0xf61e2562
const_stage_18:
.long 0xc040b340
.long 0xc040b340
.long 0xc040b340
.long 0xc040b340
const_stage_19:
.long 0x265e5a51
.long 0x265e5a51
.long 0x265e5a51
.long 0x265e5a51
const_stage_20:
.long 0xe9b6c7aa
.long 0xe9b6c7aa
.long 0xe9b6c7aa
.long 0xe9b6c7aa
const_stage_21:
.long 0xd62f105d
.long 0xd62f105d
.long 0xd62f105d
.long 0xd62f105d
const_stage_22:
.long 0x02441453
.long 0x02441453
.long 0x02441453
.long 0x02441453
const_stage_23:
.long 0xd8a1e681
.long 0xd8a1e681
.long 0xd8a1e681
.long 0xd8a1e681
const_stage_24:
.long 0xe7d3fbc8
.long 0xe7d3fbc8
.long 0xe7d3fbc8
.long 0xe7d3fbc8
const_stage_25:
.long 0x21e1cde6
.long 0x21e1cde6
.long 0x21e1cde6
.long 0x21e1cde6
const_stage_26:
.long 0xc33707d6
.long 0xc33707d6
.long 0xc33707d6
.long 0xc33707d6
const_stage_27:
.long 0xf4d50d87
.long 0xf4d50d87
.long 0xf4d50d87
.long 0xf4d50d87
const_stage_28:
.long 0x455a14ed
.long 0x455a14ed
.long 0x455a14ed
.long 0x455a14ed
const_stage_29:
.long 0xa9e3e905
.long 0xa9e3e905
.long 0xa9e3e905
.long 0xa9e3e905
const_stage_30:
.long 0xfcefa3f8
.long 0xfcefa3f8
.long 0xfcefa3f8
.long 0xfcefa3f8
const_stage_31:
.long 0x676f02d9
.long 0x676f02d9
.long 0x676f02d9
.long 0x676f02d9
const_stage_32:
.long 0x8d2a4c8a
.long 0x8d2a4c8a
.long 0x8d2a4c8a
.long 0x8d2a4c8a
const_stage_33:
.long 0xfffa3942
.long 0xfffa3942
.long 0xfffa3942
.long 0xfffa3942
const_stage_34:
.long 0x8771f681
.long 0x8771f681
.long 0x8771f681
.long 0x8771f681
const_stage_35:
.long 0x6d9d6122
.long 0x6d9d6122
.long 0x6d9d6122
.long 0x6d9d6122
const_stage_36:
.long 0xfde5380c
.long 0xfde5380c
.long 0xfde5380c
.long 0xfde5380c
const_stage_37:
.long 0xa4beea44
.long 0xa4beea44
.long 0xa4beea44
.long 0xa4beea44
const_stage_38:
.long 0x4bdecfa9
.long 0x4bdecfa9
.long 0x4bdecfa9
.long 0x4bdecfa9
const_stage_39:
.long 0xf6bb4b60
.long 0xf6bb4b60
.long 0xf6bb4b60
.long 0xf6bb4b60
const_stage_40:
.long 0xbebfbc70
.long 0xbebfbc70
.long 0xbebfbc70
.long 0xbebfbc70
const_stage_41:
.long 0x289b7ec6
.long 0x289b7ec6
.long 0x289b7ec6
.long 0x289b7ec6
const_stage_42:
.long 0xeaa127fa
.long 0xeaa127fa
.long 0xeaa127fa
.long 0xeaa127fa
const_stage_43:
.long 0xd4ef3085
.long 0xd4ef3085
.long 0xd4ef3085
.long 0xd4ef3085
const_stage_44:
.long 0x04881d05
.long 0x04881d05
.long 0x04881d05
.long 0x04881d05
const_stage_45:
.long 0xd9d4d039
.long 0xd9d4d039
.long 0xd9d4d039
.long 0xd9d4d039
const_stage_46:
.long 0xe6db99e5
.long 0xe6db99e5
.long 0xe6db99e5
.long 0xe6db99e5
const_stage_47:
.long 0x1fa27cf8
.long 0x1fa27cf8
.long 0x1fa27cf8
.long 0x1fa27cf8
const_stage_48:
.long 0xc4ac5665
.long 0xc4ac5665
.long 0xc4ac5665
.long 0xc4ac5665
const_stage_49:
.long 0xf4292244
.long 0xf4292244
.long 0xf4292244
.long 0xf4292244
const_stage_50:
.long 0x432aff97
.long 0x432aff97
.long 0x432aff97
.long 0x432aff97
const_stage_51:
.long 0xab9423a7
.long 0xab9423a7
.long 0xab9423a7
.long 0xab9423a7
const_stage_52:
.long 0xfc93a039
.long 0xfc93a039
.long 0xfc93a039
.long 0xfc93a039
const_stage_53:
.long 0x655b59c3
.long 0x655b59c3
.long 0x655b59c3
.long 0x655b59c3
const_stage_54:
.long 0x8f0ccc92
.long 0x8f0ccc92
.long 0x8f0ccc92
.long 0x8f0ccc92
const_stage_55:
.long 0xffeff47d
.long 0xffeff47d
.long 0xffeff47d
.long 0xffeff47d
const_stage_56:
.long 0x85845dd1
.long 0x85845dd1
.long 0x85845dd1
.long 0x85845dd1
const_stage_57:
.long 0x6fa87e4f
.long 0x6fa87e4f
.long 0x6fa87e4f
.long 0x6fa87e4f
const_stage_58:
.long 0xfe2ce6e0
.long 0xfe2ce6e0
.long 0xfe2ce6e0
.long 0xfe2ce6e0
const_stage_59:
.long 0xa3014314
.long 0xa3014314
.long 0xa3014314
.long 0xa3014314
const_stage_60:
.long 0x4e0811a1
.long 0x4e0811a1
.long 0x4e0811a1
.long 0x4e0811a1
const_stage_61:
.long 0xf7537e82
.long 0xf7537e82
.long 0xf7537e82
.long 0xf7537e82
const_stage_62:
.long 0xbd3af235
.long 0xbd3af235
.long 0xbd3af235
.long 0xbd3af235
const_stage_63:
.long 0x2ad7d2bb
.long 0x2ad7d2bb
.long 0x2ad7d2bb
.long 0x2ad7d2bb
const_stage_64:
.long 0xeb86d391
.long 0xeb86d391
.long 0xeb86d391
.long 0xeb86d391




/*	
 * Eggdrop userfile converter
 * Copyright (c) 2002 by Sun-Zero <sun-zero@freemail.hu>
 * This is a free software distributable under terms of the GNU GPL. 
 * See the file COPYING for details. 
 *
 * 2003-04-21
*/

#include <stdio.h>
#include <string.h>
#include <unistd.h>


#define USERFILE_HEADER "#4v:"
#define USERNAME_LENGTH 11
#define PASSWORD_LENGTH 13
#define MAX_FLAGS_LENGTH 32
#define BUFSIZE 512

int undrop(int argc, char *argv[]) {

    FILE *userfile;
    char username[USERNAME_LENGTH];
    char password[PASSWORD_LENGTH];
    char flags[MAX_FLAGS_LENGTH];
    char t_username[BUFSIZE];
    char t_flags[BUFSIZE];
    char t_line[BUFSIZE];

    if (argc != 2) {
	userfile = stdin;
	printf("# userfile reading from stdin\n");
    } else {
        if ((userfile = fopen(argv[1], "rt")) == NULL) {
    	        fprintf(stderr, "opening userfile\n");
	        userfile = stdin;
        }
    }
    
    
    if (fgets(t_line, sizeof(t_line) - 1, userfile) == NULL) 
	return 1;

    if (strncmp(t_line, USERFILE_HEADER, strlen(USERFILE_HEADER)) != 0) { 
	fprintf(stderr, "usefile format is wrong\n"); 
	return 1;
    } else {
	printf("# userfile format OK\n\n");
    }
    
    while (fgets(t_line, sizeof(t_line) - 1, userfile) != NULL) {
	if (sscanf(t_line, "%10s - %24s\n", t_username, t_flags)  == 2) {
	    if (strncmp(t_username, "! ", 2) != 0 &&
		strncmp(t_username, "--", 2) != 0 &&
		strncmp(t_username, "&&", 2) != 0 &&
		strncmp(t_username, "::", 2) != 0 &&
		strncmp(t_username, "$$", 2) != 0
	    ) {
		strncpy(username, t_username, USERNAME_LENGTH);
	        strncpy(flags, t_flags, MAX_FLAGS_LENGTH);
	    }
	}

	if (strncmp(t_line, "--PASS +", 8) == 0) {
	    sscanf(t_line, "--PASS %s", password);
	    printf("%s:%s:::%s:\n", username, password, flags);
	}
	fflush(stdout);
    }
    fclose(userfile);
    return 0;
}

Lines 2-8 Link Here

(-)john-1.7.0.1/src/x86-mmx.S (-1 / +4 lines)
2	* This file is part of John the Ripper password cracker,	2	* This file is part of John the Ripper password cracker,
3	* Copyright (c) 2000-2001,2005 by Solar Designer and others:	3	* Copyright (c) 2000-2001,2005 by Solar Designer and others:
4	*	4	*
5	* The MMX DES S-box code is by Bruce Ford and Rémi Guyomarch, originally	5	* The MMX DES S-box code is by Bruce Ford and Rï¿½i Guyomarch, originally
6	* for use in the distributed.net clients, included here with permission.	6	* for use in the distributed.net clients, included here with permission.
7	* Only minor modifications have been made to their S-box code. Optimized	7	* Only minor modifications have been made to their S-box code. Optimized
8	* S-box expressions are based on work by Matthew Kwan (see nonstd.c).	8	* S-box expressions are based on work by Matthew Kwan (see nonstd.c).
Lines 1309-1311 Link Here
1309	emms	1309	emms
1310	#endif	1310	#endif
1311	ret	1311	ret
		1312	#ifdef __ELF__
		1313	.section .note.GNU-stack,"",@progbits
		1314	#endif

Lines 58-61 Link Here

(-)john-1.7.0.1/src/x86-mmx.h (+3 lines)
58	#define BF_ASM 1	58	#define BF_ASM 1
59	#define BF_SCALE 1	59	#define BF_SCALE 1
60		60
		61	#define MMX_COEF 2
		62	#define MMX_TYPE "(MMX 2x)"
		63
61	#endif	64	#endif




/*
 * This file is part of John the Ripper password cracker,
 * Copyright (c) 1996-2002 by Solar Designer
 */

/*
 * Architecture specific parameters for x86 with MMX.
 */

#ifndef _JOHN_ARCH_H
#define _JOHN_ARCH_H

#define ARCH_WORD			long
#define ARCH_SIZE			4
#define ARCH_BITS			32
#define ARCH_BITS_LOG			5
#define ARCH_BITS_STR			"32"
#define ARCH_LITTLE_ENDIAN		1
#define ARCH_INT_GT_32			0
#define ARCH_ALLOWS_UNALIGNED		1
#define ARCH_INDEX(x)			((unsigned int)(unsigned char)(x))

#if defined(__CYGWIN32__) || defined(__BEOS__)
#define OS_TIMER			0
#else
#define OS_TIMER			1
#endif
#define OS_FLOCK			1

#define CPU_DETECT			1
#define CPU_REQ				1
#define CPU_NAME			"MMX"
#ifndef CPU_FALLBACK
#define CPU_FALLBACK			0
#endif
#if CPU_FALLBACK
#define CPU_FALLBACK_BINARY		"john-non-mmx"
#endif

#define DES_ASM				1
#define DES_128K			0
#define DES_X2				1
#define DES_MASK			1
#define DES_SCALE			0
#define DES_EXTB			0
#define DES_COPY			1
#define DES_STD_ALGORITHM_NAME		"48/64 4K MMX"
#define DES_BS_ASM			1
#define DES_BS				1
#define DES_BS_VECTOR			2
#define DES_BS_EXPAND			1
#define DES_BS_ALGORITHM_NAME		"64/64 BS MMX"

#define MD5_ASM				1
#define MD5_X2				0
#define MD5_IMM				1

#define BF_ASM				1
#define BF_SCALE			1

#define MMX_COEF			4
#define MMX_TYPE			" (SSE2 4x)"

#endif

Lines 1355-1357 Link Here

(-)john-1.7.0.1/src/x86.S (+3 lines)
1355	CPU_detect_ret:	1355	CPU_detect_ret:
1356	popl %ebx	1356	popl %ebx
1357	ret	1357	ret
		1358	#ifdef __ELF__
		1359	.section .note.GNU-stack,"",@progbits
		1360	#endif

Return to bug 122435

Line 0 Link Here

(-)john-1.7.0.1/doc/JOHN-BIGPATCH-FAQ (+54 lines)
	1
	2	Q: What's this?
	3	A: It's a patch to Solar Designer's "john the ripper" password cracker.
	4
	5	Q: What's it good for, then?
	6	A: It enables cracking of many different hashes. The list includes:
	7	- Kerberos AFS DES
	8	- Eggdrop Blowfish
	9	- OpenBSD Blowfish
	10	- BSDI DES
	11	- Traditional DES
	12	- NT LM DES
	13	- Lotus V5 web password
	14	- Apache MD5
	15	- FreeBSD MD5
	16	- MS Cache Hash
	17	- MYSQL
	18	- Netscape LDAP SHA
	19	- NTHASH (md4)
	20	- Raw MD5
	21	- Raw SHA1
	22	- Oracle
	23
	24	Q: Who made this?
	25	A: The original patches are from the /contrib/ directory of john the ripper.
	26	Their respective authors are shown on the john page, except:
	27	- Domino v5 by Jeff Fay
	28	- mscash, raw-md5, raw-sha1, hmac-md5, oracle
	29	by Bartavelle@bandecon.com
	30
	31	Q: How do I install it?
	32	A: I assume you are able to install john from a source distribution,
	33	if you are not, PLEASE read john's documentation before e-mailing me.
	34	To install run 'gunzip -c john-1.6.37-bigpatch.x.ge \| patch -p0' from the
	35	directory containing john and then run 'make (your-system-type-here)' to
	36	build john.
	37
	38	Q: NT hash support is broken!
	39	A: NT hash support works with file whose format is:
	40	USERNAME:$NT$A04B60AC43771EB386B94FEBAC779BBC
	41	if your file looks that way:
	42	USERNAME:A04B60AC43771EB386B94FEBAC779BBC
	43	use the "-format:NT" option.
	44
	45	Q: It doesn't work!
	46	A: This big patch has not been extensively tested. It should work most of the
	47	time on all architectures. Please send all questions to bartavelle@bandecon.com
	48
	49	Thanks to:
	50	Solar Designer for john and the advises
	51	Arnaud Pilon for the MS Cash algorithm and the CacheDump tool
	52	Moof (from thinko.net) for the macintosh shell
	53	HP for their testdrive systems, and the fact they allow me to use john on their
	54	servers.

Line 0 Link Here

(-)john-1.7.0.1/doc/JOHN-NTLM-FAQ (+29 lines)
	1
	2	Q: What's this?
	3	A: It's a patch to Solar Designer's "john the ripper" password cracker.
	4
	5	Q: What's it good for, then?
	6	A: It enables cracking of Windows NT/2000 MD4 (case-sensitive) password hashes.
	7
	8	Q: Who made this?
	9	A: This patch was thrown together on a boring Sunday by Olle Segerdahl.
	10	It uses Andrew Tridgell's NTLM and MD4 code stolen from samba-2.0.7 .
	11
	12	Q: How do I install it?
	13	A: I assume you are able to install john from a source distribution,
	14	if you are not, PLEASE read john's documentation before e-mailing me.
	15	To install run 'patch < john-ntlm-v02.diff' from the john "src" directory
	16	and then run 'make (your-system-type-here)' to build john.
	17
	18	Q: How do I use john to crack NT password hashes?
	19	A: Use pwdump2 or L0phtcrack to dump the password hashes into a file,
	20	then run 'john pwfile -format:NT' to start cracking!
	21
	22	Q: I get all kinds of compile errors!
	23	A: This patch was made against john-1.6.36, lots of stuff might have broken
	24	source compatibility since then... Use something closer to john-1.6.36.
	25
	26	Q: I have a question not covered by this FAQ!
	27	A: Make sure you have read all there is to read about john, then
	28	mail me at olle@nxs.se with "JOHN-NTLM" in the subject.
	29

Line 0 Link Here

(-)john-1.7.0.1/run/john.conf.rej (+15 lines)
	1	***************
	2	* 1,6 **
	3	#
	4	# This file is part of John the Ripper password cracker,
	5	- # Copyright (c) 1996-2004 by Solar Designer
	6	#
	7
	8	[Options]
	9	--- 1,6 ----
	10	#
	11	# This file is part of John the Ripper password cracker,
	12	+ # Copyright (c) 1996-2003 by Solar Designer
	13	#
	14
	15	[Options]

Line 0 Link Here

(-)john-1.7.0.1/src/BFEgg_fmt.c (+125 lines)
		1	/*
		2	* This file is part of Eggdrop blowfish patch for John The Ripper.
		3	* Copyright (c) 2002 by Sun-Zero <sun-zero@freemail.hu>
		4	* This is a free software distributable under terms of the GNU GPL.
		5	*/
		6
		7	#include <string.h>
		8
		9	#include "misc.h"
		10	#include "formats.h"
		11	#include "common.h"
		12	#include "blowfish.c"
		13
		14	#define FORMAT_LABEL "bfegg"
		15	#define FORMAT_NAME "Eggdrop"
		16	#define ALG_NAME "blowfish"
		17
		18	#define BENCHMARK_COMMENT ""
		19	#define BENCHMARK_LENGTH -1
		20
		21	#define PLAINTEXT_LENGTH 31
		22	#define CIPHERTEXT_LENGTH 33
		23
		24	#define BINARY_SIZE 13
		25	#define SALT_SIZE 0
		26
		27	#define MIN_KEYS_PER_CRYPT 1
		28	#define MAX_KEYS_PER_CRYPT 1
		29
		30	static struct fmt_tests tests[] = {
		31	{"+9F93o1OxwgK1", "123456"},
		32	{"+C/.8o.Wuph9.", "qwerty"},
		33	{"+EEHgy/MBLDd0", "walkman"},
		34	{"+vPBrs07OTXE/", "tesztuser"},
		35	{"+zIvO/1nDsd9.", "654321"},
		36	{NULL}
		37	};
		38
		39	int zerolengthkey = 0;
		40
		41	static char crypt_key[BINARY_SIZE + 1]; //changed by bartavelle so that it works on alpha
		42	static char saved_key[PLAINTEXT_LENGTH + 1];
		43
		44	static int valid(char *ciphertext) {
		45	if (strncmp(ciphertext, "+", 1) != 0) return 0;
		46	if (strlen(ciphertext) != 13) return 0;
		47
		48	return 1;
		49	}
		50
		51	void init() {
		52	blowfish_first_init();
		53	}
		54
		55
		56	static void set_key(char *key, int index) {
		57	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
		58	}
		59
		60	static char *get_key(int index) {
		61	return saved_key;
		62	}
		63
		64	static int cmp_all(void *binary, int index) {
65	if (zerolengthkey) return 0;
66	return !memcmp(binary, crypt_key, BINARY_SIZE);
67	}
68
69	static int cmp_exact(char *source, int index) {
70	return 1;
71	}
72
73	static void set_salt(void *salt) { }
74
75	static void crypt_all(int count) {
76	if (saved_key[0] == '\0') {
77	zerolengthkey = 1;
78	} else {
79	zerolengthkey = 0;
80	blowfish_encrypt_pass(saved_key, crypt_key);
81	}
82	}
83
84	struct fmt_main fmt_BFEgg = {
85	{
86	FORMAT_LABEL,
87	FORMAT_NAME,
88	ALG_NAME,
89	BENCHMARK_COMMENT,
90	BENCHMARK_LENGTH,
91	PLAINTEXT_LENGTH,
92	BINARY_SIZE,
93	SALT_SIZE,
94	MIN_KEYS_PER_CRYPT,
95	MAX_KEYS_PER_CRYPT,
96	FMT_CASE \| FMT_8_BIT,
97	tests
98	}, {
99	init,
100	valid,
101	fmt_default_split,
102	fmt_default_binary,
103	fmt_default_salt,
104	{
105	fmt_default_binary_hash,
106	fmt_default_binary_hash,
107	fmt_default_binary_hash,
108	},
109	fmt_default_salt_hash,
110	set_salt,
111	set_key,
112	get_key,
113	fmt_default_clear_keys,
114	crypt_all,
115	{
116	fmt_default_get_hash,
117	fmt_default_get_hash,
118	fmt_default_get_hash,
119	},
120	cmp_all,
121	cmp_all,
122	cmp_exact
123	}
124	};
125

Line 0 Link Here

(-)john-1.7.0.1/src/MD5_apache_fmt.c (+201 lines)
		1	/*
		2	Modified by Sun-Zero <sun-zero@freemail.hu>
		3	2004. 07. 26.
		4
		5	Now, its work with md5 hash of apache.
		6	The original john patch came from
		7	http://lists.jammed.com/pen-test/2001/11/0134.html by
		8	Kostas Evangelinos (kos@bastard.net)
		9	*/
		10
		11	/*
		12	* This file is part of John the Ripper password cracker,
		13	* Copyright (c) 1996-2001 by Solar Designer
		14	*/
		15
		16	#include <string.h>
		17
		18	#include "arch.h"
		19	#include "misc.h"
		20	#include "MD5_std.h"
		21	#include "common.h"
		22	#include "formats.h"
		23
		24	#define FORMAT_LABEL "md5a"
		25	#define FORMAT_NAME "Apache MD5"
		26
		27	#define BENCHMARK_COMMENT ""
		28	#define BENCHMARK_LENGTH -1
		29
		30	#define PLAINTEXT_LENGTH 15
		31	#define CIPHERTEXT_LENGTH 22
		32
		33	#define BINARY_SIZE 4
		34	#define SALT_SIZE 8
		35
		36	#define MIN_KEYS_PER_CRYPT MD5_N
		37	#define MAX_KEYS_PER_CRYPT MD5_N
		38
		39
		40	static struct fmt_tests tests[] = {
		41	{"$apr1$Q6ZYh...$RV6ft2bZ8j.NGrxLYaJt9.", "test"},
		42	{"$apr1$rBXqc...$NlXxN9myBOk95T0AyLAsJ0", "john"},
		43	{"$apr1$Grpld/..$qp5GyjwM2dnA5Cdej9b411", "the"},
		44	{"$apr1$GBx.D/..$yfVeeYFCIiEXInfRhBRpy/", "ripper"},
		45	{NULL}
		46	};
		47
		48	static char saved_key[MD5_N][PLAINTEXT_LENGTH + 1];
		49
		50	static int valid(char *ciphertext)
		51	{
		52	char pos, start;
		53
		54	if (strncmp(ciphertext, "$apr1$", 6)) return 0;
		55
		56	/* magic string */
		57	start = &ciphertext[1];
		58	for (pos = start; pos && pos != '$'; pos++);
		59	if (!*pos \|\| pos < start+1 \|\| pos > start+MD5_MAGIC_LENGTH+1)
		60	return 0;
		61
		62	/* salt */
		63	start = ++pos;
		64	for (pos = start; pos && pos != '$'; pos++);
65	if (!*pos \|\| pos < start \|\| pos > start+8)
66	return 0;
67
68
69	start = ++pos;
70	while (atoi64[ARCH_INDEX(*pos)] != 0x7F) pos++;
71	if (*pos \|\| pos - start != CIPHERTEXT_LENGTH) return 0;
72
73	if (atoi64[ARCH_INDEX(*(pos - 1))] & 0x3C) return 0;
74
75	return 1;
76	}
77
78	static int binary_hash_0(void *binary)
79	{
80	return (MD5_word )binary & 0xF;
81	}
82
83	static int binary_hash_1(void *binary)
84	{
85	return (MD5_word )binary & 0xFF;
86	}
87
88	static int binary_hash_2(void *binary)
89	{
90	return (MD5_word )binary & 0xFFF;
91	}
92
93	static int get_hash_0(int index)
94	{
95	return MD5_out[index][0] & 0xF;
96	}
97
98	static int get_hash_1(int index)
99	{
100	return MD5_out[index][0] & 0xFF;
101	}
102
103	static int get_hash_2(int index)
104	{
105	return MD5_out[index][0] & 0xFFF;
106	}
107
108	static int salt_hash(void *salt)
109	{
110	return
111	((int)atoi64[ARCH_INDEX(((char *)salt)[0])] \|
112	((int)atoi64[ARCH_INDEX(((char *)salt)[1])] << 6)) & 0x3FF;
113	}
114
115	static void set_key(char *key, int index)
116	{
117	MD5_std_set_key(key, index);
118
119	strnfcpy(saved_key[index], key, PLAINTEXT_LENGTH);
120	}
121
122	static char *get_key(int index)
123	{
124	saved_key[index][PLAINTEXT_LENGTH] = 0;
125
126	return saved_key[index];
127	}
128
129	static int cmp_all(void *binary, int index)
130	{
131
132	#if MD5_X2
133	return (MD5_word )binary == MD5_out[0][0] \|\|
134	(MD5_word )binary == MD5_out[1][0];
135	#else
136	return (MD5_word )binary == MD5_out[0][0];
137	#endif
138	}
139
140
141	static int cmp_exact(char *source, int index)
142	{
143	return !memcmp(MD5_std_get_binary(source, MD5_TYPE_APACHE), MD5_out[index],
144	sizeof(MD5_binary));
145	}
146
147
148	static void crypt_all(int count) {
149	MD5_std_crypt(MD5_TYPE_APACHE);
150	}
151
152	static void get_salt(char ciphertext) {
153	return MD5_std_get_salt(ciphertext, MD5_TYPE_APACHE);
154	}
155
156	static void get_binary(char ciphertext) {
157	return MD5_std_get_binary(ciphertext, MD5_TYPE_APACHE);
158	}
159
160
161	struct fmt_main fmt_MD5_apache = {
162	{
163	FORMAT_LABEL,
164	FORMAT_NAME,
165	MD5_ALGORITHM_NAME,
166	BENCHMARK_COMMENT,
167	BENCHMARK_LENGTH,
168	PLAINTEXT_LENGTH,
169	BINARY_SIZE,
170	SALT_SIZE,
171	MIN_KEYS_PER_CRYPT,
172	MAX_KEYS_PER_CRYPT,
173	FMT_CASE \| FMT_8_BIT,
174	tests
175	}, {
176	MD5_std_init,
177	valid,
178	fmt_default_split,
179	get_binary, //(void ()(char *))MD5_std_get_binary,
180	get_salt, //(void ()(char *))MD5_std_get_salt,
181	{
182	binary_hash_0,
183	binary_hash_1,
184	binary_hash_2
185	},
186	salt_hash,
187	(void ()(void ))MD5_std_set_salt,
188	set_key,
189	get_key,
190	fmt_default_clear_keys,
191	crypt_all, //(void (*)(int))MD5_std_crypt,
192	{
193	get_hash_0,
194	get_hash_1,
195	get_hash_2
196	},
197	cmp_all,
198	cmp_all,
199	cmp_exact
200	}
201	};

Lines 117-126 Link Here

(-)john-1.7.0.1/src/MD5_fmt.c (-4 / +16 lines)
117		117
118	static int cmp_exact(char *source, int index)	118	static int cmp_exact(char *source, int index)
119	{	119	{
120	return !memcmp(MD5_std_get_binary(source), MD5_out[index],	120	return !memcmp(MD5_std_get_binary(source, MD5_TYPE_STD), MD5_out[index],
121	sizeof(MD5_binary));	121	sizeof(MD5_binary));
122	}	122	}
123		123
		124	static void crypt_all(int count) {
		125	MD5_std_crypt(MD5_TYPE_STD);
		126	}
		127
		128	static void get_salt(char ciphertext) {
		129	return MD5_std_get_salt(ciphertext, MD5_TYPE_STD);
		130	}
		131
		132	static void get_binary(char ciphertext) {
		133	return MD5_std_get_binary(ciphertext, MD5_TYPE_STD);
		134	}
		135
124	struct fmt_main fmt_MD5 = {	136	struct fmt_main fmt_MD5 = {
125	{	137	{
126	FORMAT_LABEL,	138	FORMAT_LABEL,
Lines 139-146 Link Here
139	MD5_std_init,	151	MD5_std_init,
140	valid,	152	valid,
141	fmt_default_split,	153	fmt_default_split,
142	(void ()(char *))MD5_std_get_binary,	154	get_binary, /* (void ()(char ))MD5_std_get_binary, /
143	(void ()(char *))MD5_std_get_salt,	155	get_salt, /* (void ()(char ))MD5_std_get_salt, /
144	{	156	{
145	binary_hash_0,	157	binary_hash_0,
146	binary_hash_1,	158	binary_hash_1,
Lines 151-157 Link Here
151	set_key,	163	set_key,
152	get_key,	164	get_key,
153	fmt_default_clear_keys,	165	fmt_default_clear_keys,
154	(void (*)(int))MD5_std_crypt,	166	crypt_all, /* (void ()(int))MD5_std_crypt, /
155	{	167	{
156	get_hash_0,	168	get_hash_0,
157	get_hash_1,	169	get_hash_1,

Lines 400-406 Link Here

(-)john-1.7.0.1/src/MD5_std.c (-11 / +41 lines)
400	order[19][index].length = current->l.pp;	400	order[19][index].length = current->l.pp;
401	}	401	}
402		402
403	void MD5_std_crypt(void)	403	void MD5_std_crypt(int md5_type)
404	{	404	{
405	int length, index, mask;	405	int length, index, mask;
406	MD5_pattern *line;	406	MD5_pattern *line;
Lines 483-493 Link Here
483	for (index = 0, key = pool; index < MD5_N; index++, key++) {	483	for (index = 0, key = pool; index < MD5_N; index++, key++) {
484	#endif	484	#endif
485	memcpy(&block[index], key->o.p.b, key->l.p);	485	memcpy(&block[index], key->o.p.b, key->l.p);
486	memcpy(&block[index].b[key->l.p], "$1$", 3);	486	if (md5_type == MD5_TYPE_APACHE) {
487	memcpy(&block[index].b[key->l.p + 3], key->s, key->l.s);	487	memcpy(&block[index].b[key->l.p], "$apr1$", 6);
488	memcpy(&block[index].b[key->l.ps + 3],	488	memcpy(&block[index].b[key->l.p + 6], key->s, key->l.s);
489	MD5_out[index], key->l.p);	489	memcpy(&block[index].b[key->l.ps + 6],
490	length = key->l.psp + 3;	490	MD5_out[index], key->l.p);
		491	length = key->l.psp + 6;
		492	} else {
		493	memcpy(&block[index].b[key->l.p], "$1$", 3);
		494	memcpy(&block[index].b[key->l.p + 3], key->s, key->l.s);
		495	memcpy(&block[index].b[key->l.ps + 3],
		496	MD5_out[index], key->l.p);
		497	length = key->l.psp + 3;
		498	}
491	if ((mask = key->l.p))	499	if ((mask = key->l.p))
492	do {	500	do {
493	block[index].b[length++] =	501	block[index].b[length++] =
Lines 853-865 Link Here
853		861
854	#endif	862	#endif
855		863
856	char MD5_std_get_salt(char ciphertext)	864	char MD5_std_get_salt(char ciphertext, int md5_type)
857	{	865	{
858	static char out[9];	866	static char out[9];
859	int length;	867	int length;
		868	char *pos;
		869	char *start;
		870
		871	start = &ciphertext[1];
		872	if (md5_type == MD5_TYPE_APACHE) {
		873	for (pos = start; pos && pos != '$'; pos++);
		874	start = ++pos;
		875	}
860		876
861	for (length = 0; length < 8; length++)	877	for (length = 0; length < 8; length++) {
862	if ((out[length] = ciphertext[3 + length]) == '$') break;	878	if (md5_type == MD5_TYPE_APACHE) {
		879	if ((out[length] = start[length]) == '$') break;
		880	} else {
		881	if ((out[length] = ciphertext[3 + length]) == '$') break;
		882	}
		883	}
863	out[length] = 0;	884	out[length] = 0;
864		885
865	return out;	886	return out;
Lines 876-882 Link Here
876	out.b[b2] = value >> 8; \	897	out.b[b2] = value >> 8; \
877	out.b[b3] = value;	898	out.b[b3] = value;
878		899
879	MD5_word MD5_std_get_binary(char ciphertext)	900	MD5_word MD5_std_get_binary(char ciphertext, int md5_type)
880	{	901	{
881	static union {	902	static union {
882	MD5_binary w;	903	MD5_binary w;
Lines 885-891 Link Here
885	char *pos;	906	char *pos;
886	MD5_word value;	907	MD5_word value;
887		908
888	pos = ciphertext + 3; while (*pos++ != '$');	909	char *start;
		910	if (md5_type == MD5_TYPE_APACHE) {
		911	start = &ciphertext[1];
		912	for (pos = start; pos && pos != '$'; pos++);
		913	if (!*pos \|\| pos < start+1 \|\| pos > start+MD5_MAGIC_LENGTH+1) return 0;
		914	pos++;
		915	while (*pos++ != '$');
		916	} else {
		917	pos = ciphertext + 3; while (*pos++ != '$');
		918	}
889		919
890	TO_BINARY(0, 6, 12);	920	TO_BINARY(0, 6, 12);
891	TO_BINARY(1, 7, 13);	921	TO_BINARY(1, 7, 13);

Line 0 Link Here

(-)john-1.7.0.1/src/MYSQL_fmt.c (+251 lines)
		1	////////////////////////////////////////////////////////////////
		2	// MySQL password cracker - v1.0 - 16.1.2003
		3	//
		4	// by Andrew Hintz <http://guh.nu> drew@overt.org
		5	//
		6	// This production has been brought to you by
		7	// 4tphi <http://4tphi.net> and violating <http://violating.us>
		8	//
		9	// This file is an add-on to John the Ripper <http://www.openwall.com/john/>
		10	//
		11	// Part of this code is based on the MySQL brute password cracker
		12	// mysqlpassword.c by Chris Given
		13	// This program executes about 75% faster than mysqlpassword.c
		14	// John the ripper also performs sophisticated password guessing.
		15	//
		16	// John the Ripper will expect the MySQL password file to be
		17	// in the following format (without the leading // ):
		18	// dumb_user:5d2e19393cc5ef67
		19	// another_luser:28ff8d49159ffbaf
		20	//
		21	// performance enhancements by bartavelle@bandecon.com
		22
		23	#include <string.h>
		24	#include <stdio.h>
		25	#include <stdlib.h>
		26	#include <math.h>
		27
		28	// johntr includes
		29	#include "arch.h"
		30	#include "misc.h"
		31	#include "formats.h"
		32	#include "common.h"
		33
		34	//johntr defines
		35	#define FORMAT_LABEL "mysql"
		36	#define FORMAT_NAME "mysql"
		37	#define ALGORITHM_NAME "mysql"
		38
		39	#define BENCHMARK_COMMENT ""
		40	#define BENCHMARK_LENGTH -1
		41
		42	// Increase the PLAINTEXT_LENGTH value for longer passwords.
		43	// You can also set it to 8 when using MySQL systems that truncate
		44	// the password to only 8 characters.
		45	#define PLAINTEXT_LENGTH 32
		46
		47	#define CIPHERTEXT_LENGTH 16
		48
		49	#define BINARY_SIZE 16
		50	#define SALT_SIZE 0
		51
		52	#define MIN_KEYS_PER_CRYPT 1
		53	#define MAX_KEYS_PER_CRYPT 1
		54
		55
		56	//used for mysql scramble function
		57	struct rand_struct {
		58	unsigned long seed1,seed2,max_value;
		59	double max_value_dbl;
		60	};
		61
		62
		63	void make_scrambled_password(char ,const char );
		64	char scramble(char ,const char ,const char , int);
65
66	//test cases
67	static struct fmt_tests mysql_tests[] = {
68	{"30f098972cc8924d", "http://guh.nu"},
69	{"3fc56f6037218993", "Andrew Hintz"},
70	{"697a7de87c5390b2", "drew"},
71	{"1eb71cf460712b3e", "http://4tphi.net"},
72	{"28ff8d49159ffbaf", "http://violating.us"},
73	{"5d2e19393cc5ef67", "password"},
74	{NULL}
75	};
76
77
78	//stores the ciphertext for value currently being tested
79	static char crypt_key[BINARY_SIZE+1];
80
81	//used by set_key
82	static char saved_key[PLAINTEXT_LENGTH + 1];
83
84	static int mysql_valid(char *ciphertext) { //returns 0 for invalid ciphertexts
85
86	int i; //used as counter in loop
87
88	//ciphertext is 16 characters
89	if (strlen(ciphertext) != 16) return 0;
90
91	//ciphertext is ASCII representation of hex digits
92	for (i = 0; i < 16; i++){
93	if (!( ((48 <= ciphertext[i])&&(ciphertext[i] <= 57)) \|\|
94	((97 <= ciphertext[i])&&(ciphertext[i] <= 102)) ))
95	return 0;
96	}
97
98	return 1;
99	}
100
101	static void mysql_set_salt(void *salt) { }
102
103	static void mysql_set_key(char *key, int index) {
104	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
105	}
106
107	static char *mysql_get_key(int index) {
108	return saved_key;
109	}
110
111	static int mysql_cmp_all(void *binary, int index) { //also is mysql_cmp_one
112	int i = 0;
113	while(i<BINARY_SIZE)
114	{
115	if(((char )binary)[i]!=((char )crypt_key)[i])
116	return 0;
117	i++;
118	}
119	return 1;
120	}
121
122	static int mysql_cmp_exact(char *source, int count){
123	return (1); // mysql_cmp_all fallthrough?
124	}
125
126	static void mysql_crypt_all(int count) {
127	// get plaintext input in saved_key put it into ciphertext crypt_key
128	make_scrambled_password(crypt_key,saved_key);
129	}
130
131	////////////////////////////////////////////////////////////////
132	//begin mysql code
133	// This code was copied from mysqlpassword.c by Chris Given
134	// He probably copied it from password.c in the MySQL source
135	// The code is GPLed
136
137	void randominit(struct rand_struct *rand_st,unsigned long seed1, unsigned long seed2) {
138	rand_st->max_value= 0x3FFFFFFFL;
139	rand_st->max_value_dbl=(double) rand_st->max_value;
140	rand_st->seed1=seed1%rand_st->max_value ;
141	rand_st->seed2=seed2%rand_st->max_value;
142	}
143	static void old_randominit(struct rand_struct *rand_st,unsigned long seed1) {
144	rand_st->max_value= 0x01FFFFFFL;
145	rand_st->max_value_dbl=(double) rand_st->max_value;
146	seed1%=rand_st->max_value;
147	rand_st->seed1=seed1 ; rand_st->seed2=seed1/2;
148	}
149	double rnd(struct rand_struct *rand_st) {
150	rand_st->seed1=(rand_st->seed1*3+rand_st->seed2) %
151	rand_st->max_value;
152	rand_st->seed2=(rand_st->seed1+rand_st->seed2+33) %
153	rand_st->max_value;
154	return(((double) rand_st->seed1)/rand_st->max_value_dbl);
155	}
156	void hash_password(unsigned long result, const char password) {
157	unsigned long nr=1345345333L, add=7, nr2=0x12345671L;
158	unsigned long tmp;
159	for (; *password ; password++) {
160	if (password == ' ' \|\| password == '\t')
161	continue;
162	//tmp= (unsigned long) (unsigned char) *password;
163	tmp= (unsigned long) (*password & 0xFF);
164	nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
165	nr2+=(nr2 << 8) ^ nr;
166	add+=tmp;
167	}
168	result[0]=nr & (((unsigned long) 1L << 31) -1L); /* Don't use sign bit
169	(str2int) */;
170	result[1]=nr2 & (((unsigned long) 1L << 31) -1L);
171	return;
172	}
173	void make_scrambled_password(char to,const char password) {
174	unsigned long hash_res[2];
175	hash_password(hash_res,password);
176	sprintf(to,"%08lx%08lx",hash_res[0],hash_res[1]);
177	}
178	static inline unsigned int char_val(char X) {
179	return (unsigned int) (X >= '0' && X <= '9' ? X-'0' : X >= 'A' && X <= 'Z' ?
180	X-'A'+10 : X-'a'+10);
181	}
182	char scramble(char to,const char message,const char password, int
183	old_ver) {
184	struct rand_struct rand_st;
185	unsigned long hash_pass[2],hash_message[2];
186	if(password && password[0]) {
187	char *to_start=to;
188	hash_password(hash_pass,password);
189	hash_password(hash_message,message);
190	if (old_ver)
191	old_randominit(&rand_st,hash_pass[0] ^
192	hash_message[0]);
193	else
194	randominit(&rand_st,hash_pass[0] ^ hash_message[0],
195	hash_pass[1] ^ hash_message[1]);
196	while (*message++)
197	to++= (char) (floor(rnd(&rand_st)31)+64);
198	if (!old_ver) {
199	char extra=(char) (floor(rnd(&rand_st)*31));
200	while(to_start != to)
201	*(to_start++)^=extra;
202	}
203	}
204	*to=0;
205	return to;
206	}
207
208	//end mysql code
209	////////////////////////////////////////////////////////////////
210
211	struct fmt_main fmt_MYSQL = {
212	{
213	FORMAT_LABEL,
214	FORMAT_NAME,
215	ALGORITHM_NAME,
216	BENCHMARK_COMMENT,
217	BENCHMARK_LENGTH,
218	PLAINTEXT_LENGTH,
219	BINARY_SIZE,
220	SALT_SIZE,
221	MIN_KEYS_PER_CRYPT,
222	MAX_KEYS_PER_CRYPT,
223	FMT_CASE \| FMT_8_BIT,
224	mysql_tests
225	}, {
226	fmt_default_init,
227	mysql_valid,
228	fmt_default_split,
229	fmt_default_binary,
230	fmt_default_salt,
231	{
232	fmt_default_binary_hash,
233	fmt_default_binary_hash,
234	fmt_default_binary_hash
235	},
236	fmt_default_salt_hash,
237	mysql_set_salt,
238	mysql_set_key,
239	mysql_get_key,
240	fmt_default_clear_keys,
241	mysql_crypt_all,
242	{
243	fmt_default_get_hash,
244	fmt_default_get_hash,
245	fmt_default_get_hash
246	},
247	mysql_cmp_all,
248	mysql_cmp_all, //should it be the same as cmp_all or same as cmp_exact?
249	mysql_cmp_exact //fallthrough
250	}
251	};

Lines 20-25 Link Here

(-)john-1.7.0.1/src/Makefile (-10 / +53 lines)
20	LDFLAGS = -s	20	LDFLAGS = -s
21	OPT_NORMAL = -funroll-loops	21	OPT_NORMAL = -funroll-loops
22	OPT_INLINE = -finline-functions	22	OPT_INLINE = -finline-functions
		23	LIBS =
23		24
24	JOHN_OBJS_MINIMAL = \	25	JOHN_OBJS_MINIMAL = \
25	DES_fmt.o DES_std.o DES_bs.o \	26	DES_fmt.o DES_std.o DES_bs.o \
Lines 28-39 Link Here
28	BF_fmt.o BF_std.o \	29	BF_fmt.o BF_std.o \
29	AFS_fmt.o \	30	AFS_fmt.o \
30	LM_fmt.o \	31	LM_fmt.o \
		32	des.o \
		33	MD5_apache_fmt.o \
		34	BFEgg_fmt.o \
		35	lotus5_fmt.o \
		36	md5.o \
		37	NSLDAP_fmt.o sha1.o base64.o \
		38	MYSQL_fmt.o \
		39	NT_fmt.o \
		40	md4.o smbencrypt.o \
		41	rawMD5_fmt.o \
		42	rawSHA1_fmt.o \
		43	mssql_fmt.o \
		44	hmacMD5_fmt.o \
		45	WPAPSK_fmt.o \
		46	mscash_fmt.o \
		47	oracle_fmt.o \
31	batch.o bench.o charset.o common.o compiler.o config.o cracker.o \	48	batch.o bench.o charset.o common.o compiler.o config.o cracker.o \
32	crc32.o external.o formats.o getopt.o idle.o inc.o john.o list.o \	49	crc32.o external.o formats.o getopt.o idle.o inc.o john.o list.o \
33	loader.o logger.o math.o memory.o misc.o options.o params.o path.o \	50	loader.o logger.o math.o memory.o misc.o options.o params.o path.o \
34	recovery.o rpp.o rules.o signals.o single.o status.o tty.o wordlist.o \	51	recovery.o rpp.o rules.o signals.o single.o status.o tty.o wordlist.o \
35	unshadow.o \	52	unshadow.o \
36	unafs.o \	53	unafs.o \
		54	undrop.o \
37	unique.o	55	unique.o
38		56
39	JOHN_OBJS_ORIG = \	57	JOHN_OBJS_ORIG = \
Lines 66-82 Link Here
66	bench.o best.o common.o config.o formats.o math.o memory.o miscnl.o \	84	bench.o best.o common.o config.o formats.o math.o memory.o miscnl.o \
67	params.o path.o signals.o tty.o	85	params.o path.o signals.o tty.o
68		86
69	PROJ = ../run/john ../run/unshadow ../run/unafs ../run/unique	87	PROJ = ../run/john ../run/unshadow ../run/unafs ../run/unique ../run/undrop
70	PROJ_DOS = ../run/john.bin ../run/john.com \	88	PROJ_DOS = ../run/john.bin ../run/john.com \
71	../run/unshadow.com ../run/unafs.com ../run/unique.com	89	../run/unshadow.com ../run/unafs.com ../run/unique.com ../run/undrop.com
72	PROJ_WIN32 = ../run/john.exe \	90	PROJ_WIN32 = ../run/john.exe \
73	../run/unshadow.exe ../run/unafs.exe ../run/unique.exe	91	../run/unshadow.exe ../run/unafs.exe ../run/unique.exe ../run/undrop.exe
74		92
75	default:	93	default:
76	@echo "To build John the Ripper, type:"	94	@echo "To build John the Ripper, type:"
77	@echo " make clean SYSTEM"	95	@echo " make clean SYSTEM"
78	@echo "where SYSTEM can be one of the following:"	96	@echo "where SYSTEM can be one of the following:"
79	@echo "linux-x86-mmx Linux, x86 with MMX (best)"	97	@echo "linux-x86-mmx Linux, x86 with MMX (best)"
		98	@echo "linux-x86-sse2 Linux, x86 with SSE2, ELF binaries"
80	@echo "linux-x86-any Linux, x86"	99	@echo "linux-x86-any Linux, x86"
81	@echo "linux-x86-any-a.out Linux, x86, a.out binaries (obsolete)"	100	@echo "linux-x86-any-a.out Linux, x86, a.out binaries (obsolete)"
82	@echo "linux-x86-64 Linux, AMD x86-64, 64-bit native"	101	@echo "linux-x86-64 Linux, AMD x86-64, 64-bit native"
Lines 127-132 Link Here
127	@echo "dos-djgpp-x86-mmx DOS, DJGPP 2.x, x86 with MMX (best)"	146	@echo "dos-djgpp-x86-mmx DOS, DJGPP 2.x, x86 with MMX (best)"
128	@echo "dos-djgpp-x86-any DOS, DJGPP 2.x, x86"	147	@echo "dos-djgpp-x86-any DOS, DJGPP 2.x, x86"
129	@echo "win32-cygwin-x86-mmx Win32, Cygwin, x86 with MMX (best)"	148	@echo "win32-cygwin-x86-mmx Win32, Cygwin, x86 with MMX (best)"
		149	@echo "win32-cygwin-x86-sse2 Win32, Cygwin, x86 with SSE2"
130	@echo "win32-cygwin-x86-any Win32, Cygwin, x86"	150	@echo "win32-cygwin-x86-any Win32, Cygwin, x86"
131	@echo "beos-x86-mmx BeOS, x86 with MMX"	151	@echo "beos-x86-mmx BeOS, x86 with MMX"
132	@echo "beos-x86-any BeOS, x86"	152	@echo "beos-x86-any BeOS, x86"
Lines 135-141 Link Here
135	linux-x86-mmx:	155	linux-x86-mmx:
136	$(LN) x86-mmx.h arch.h	156	$(LN) x86-mmx.h arch.h
137	$(MAKE) $(PROJ) \	157	$(MAKE) $(PROJ) \
138	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o"	158	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o md5-mmx.o sha1-mmx.o"
		159
		160	linux-x86-sse2:
		161	$(LN) x86-sse2.h arch.h
		162	$(MAKE) $(PROJ) \
		163	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-sse2.o NTmmx_fmt.o md5-mmx.o sha1-mmx.o"
139		164
140	linux-x86-any:	165	linux-x86-any:
141	$(LN) x86-any.h arch.h	166	$(LN) x86-any.h arch.h
Lines 156-162 Link Here
156	linux-x86-64-mmx:	181	linux-x86-64-mmx:
157	$(LN) x86-mmx.h arch.h	182	$(LN) x86-mmx.h arch.h
158	$(MAKE) $(PROJ) \	183	$(MAKE) $(PROJ) \
159	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o" \	184	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
160	CFLAGS="$(CFLAGS) -m32" \	185	CFLAGS="$(CFLAGS) -m32" \
161	ASFLAGS="$(ASFLAGS) -m32" \	186	ASFLAGS="$(ASFLAGS) -m32" \
162	LDFLAGS="$(LDFLAGS) -m32"	187	LDFLAGS="$(LDFLAGS) -m32"
Lines 236-242 Link Here
236	openbsd-x86-mmx:	261	openbsd-x86-mmx:
237	$(LN) x86-mmx.h arch.h	262	$(LN) x86-mmx.h arch.h
238	$(MAKE) $(PROJ) \	263	$(MAKE) $(PROJ) \
239	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o" \	264	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
240	ASFLAGS="$(ASFLAGS) -DBSD"	265	ASFLAGS="$(ASFLAGS) -DBSD"
241		266
242	openbsd-x86-any:	267	openbsd-x86-any:
Lines 541-547 Link Here
541	dos-djgpp-x86-mmx:	566	dos-djgpp-x86-mmx:
542	copy x86-mmx.h arch.h	567	copy x86-mmx.h arch.h
543	$(MAKE) $(PROJ_DOS) \	568	$(MAKE) $(PROJ_DOS) \
544	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o" \	569	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o" \
545	CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \	570	CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
546	ASFLAGS="$(ASFLAGS) -DUNDERSCORES -DALIGN_LOG"	571	ASFLAGS="$(ASFLAGS) -DUNDERSCORES -DALIGN_LOG"
547		572
Lines 555-561 Link Here
555	win32-cygwin-x86-mmx:	580	win32-cygwin-x86-mmx:
556	$(CP) x86-mmx.h arch.h	581	$(CP) x86-mmx.h arch.h
557	$(MAKE) $(PROJ_WIN32) \	582	$(MAKE) $(PROJ_WIN32) \
558	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o" \	583	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o md5_mmx.o sha1-mmx.o" \
		584	CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
		585	ASFLAGS="$(ASFLAGS) -DUNDERSCORES"
		586
		587	win32-cygwin-x86-sse2:
		588	$(CP) x86-sse2.h arch.h
		589	$(MAKE) $(PROJ_WIN32) \
		590	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-sse2.o NTmmx_fmt.o md5_mmx.o sha1-mmx.o" \
559	CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \	591	CFLAGS="$(CFLAGS) -mpreferred-stack-boundary=2" \
560	ASFLAGS="$(ASFLAGS) -DUNDERSCORES"	592	ASFLAGS="$(ASFLAGS) -DUNDERSCORES"
561		593
Lines 569-575 Link Here
569	beos-x86-mmx:	601	beos-x86-mmx:
570	$(LN) x86-mmx.h arch.h	602	$(LN) x86-mmx.h arch.h
571	$(MAKE) $(PROJ) \	603	$(MAKE) $(PROJ) \
572	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o"	604	JOHN_OBJS="$(JOHN_OBJS_MINIMAL) x86.o x86-mmx.o md4-mmx.o NTmmx_fmt.o"
573		605
574	beos-x86-any:	606	beos-x86-any:
575	$(LN) x86-any.h arch.h	607	$(LN) x86-any.h arch.h
Lines 595-601 Link Here
595	$(LD) $(LDFLAGS) $(BENCH_OBJS) -o bench	627	$(LD) $(LDFLAGS) $(BENCH_OBJS) -o bench
596		628
597	../run/john: $(JOHN_OBJS)	629	../run/john: $(JOHN_OBJS)
598	$(LD) $(LDFLAGS) $(JOHN_OBJS) -o ../run/john	630	$(LD) $(LDFLAGS) $(JOHN_OBJS) -o ../run/john ${LIBS}
599		631
600	../run/unshadow: ../run/john	632	../run/unshadow: ../run/john
601	$(RM) ../run/unshadow	633	$(RM) ../run/unshadow
Lines 605-610 Link Here
605	$(RM) ../run/unafs	637	$(RM) ../run/unafs
606	ln -s john ../run/unafs	638	ln -s john ../run/unafs
607		639
		640	../run/undrop: ../run/john
		641	$(RM) ../run/undrop
		642	ln -s john ../run/undrop
		643
608	../run/unique: ../run/john	644	../run/unique: ../run/john
609	$(RM) ../run/unique	645	$(RM) ../run/unique
610	ln -s john ../run/unique	646	ln -s john ../run/unique
Lines 623-628 Link Here
623	../run/unafs.com: john.com	659	../run/unafs.com: john.com
624	copy john.com ..\run\unafs.com	660	copy john.com ..\run\unafs.com
625		661
		662	../run/undrop.com: john.com
		663	copy john.com ..\run\undrop.com
		664
626	../run/unique.com: john.com	665	../run/unique.com: john.com
627	copy john.com ..\run\unique.com	666	copy john.com ..\run\unique.com
628		667
Lines 641-646 Link Here
641	$(CC) symlink.c -o ../run/unafs.exe	680	$(CC) symlink.c -o ../run/unafs.exe
642	strip ../run/unafs.exe	681	strip ../run/unafs.exe
643		682
		683	../run/undrop.exe: symlink.c
		684	$(CC) symlink.c -o ../run/undrop.exe
		685	strip ../run/undrop.exe
		686
644	../run/unique.exe: symlink.c	687	../run/unique.exe: symlink.c
645	$(CC) symlink.c -o ../run/unique.exe	688	$(CC) symlink.c -o ../run/unique.exe
646	strip ../run/unique.exe	689	strip ../run/unique.exe

Line 0 Link Here

(-)john-1.7.0.1/src/NSLDAP_fmt.c (+259 lines)
		1	// Fix for john the ripper 1.6.37 by Sun-Zero, 2004. 07. 26.
		2	/*
		3	* This file is part of John the Ripper password cracker,
		4	* Copyright (c) 1996-98 by Solar Designer
		5	*
		6	* Minor performance enhancement by bartavelle@bandecon.com
		7	*/
		8
		9	#include <string.h>
		10
		11	#include "misc.h"
		12	#include "formats.h"
		13	#include "common.h"
		14
		15	#include "sha.h"
		16	#include "base64.h"
		17
		18	#define FORMAT_LABEL "nsldap"
		19	#define FORMAT_NAME "Netscape LDAP SHA"
		20	#define SHA_TYPE "SHA1"
		21
		22	#ifdef MMX_TYPE
		23	#define BENCHMARK_COMMENT MMX_TYPE
		24	#else
		25	#define BENCHMARK_COMMENT ""
		26	#endif
		27	#define BENCHMARK_LENGTH -1
		28
		29	#define PLAINTEXT_LENGTH 32
		30	#define CIPHERTEXT_LENGTH 33
		31
		32	#define BINARY_SIZE 20
		33	#define SALT_SIZE 0
		34
		35	#ifdef MMX_COEF
		36	#define MIN_KEYS_PER_CRYPT MMX_COEF
		37	#define MAX_KEYS_PER_CRYPT MMX_COEF
		38	#define GETPOS(i, index) ( (index)4 + (i& (0xffffffff-3) )MMX_COEF + (3-((i)&3)) )
		39	#else
		40	#define MIN_KEYS_PER_CRYPT 1
		41	#define MAX_KEYS_PER_CRYPT 1
		42	#endif
		43
		44	#define NSLDAP_MAGIC "{sha}"
		45	#define NSLDAP_MAGIC_LENGTH 5
		46
		47	static struct fmt_tests tests[] = {
		48	{"{SHA}cMiB1KJphN3OeV9vcYF8nPRIDnk=", "aaaa"},
		49	{"{SHA}iu0TIuVFC62weOH7YKgXod8loso=", "bbbb"},
		50	{"{SHA}0ijZPTcJXMa+t2XnEbEwSOkvQu0=", "ccccccccc"},
		51	{"{SHA}vNR9eUfJfcKmdkLDqNoKagho+qU=", "dddddddddd"},
		52	{NULL}
		53	};
		54
		55	#ifdef MMX_COEF
		56	static char crypt_key[BINARY_SIZE*MMX_COEF];
		57	static char saved_key[(PLAINTEXT_LENGTH+1)*MMX_COEF];
		58	unsigned long total_len;
		59	unsigned char buffer[804MMX_COEF] __attribute__ ((aligned(8*MMX_COEF)));
		60	unsigned char out[PLAINTEXT_LENGTH];
		61	#else
		62	static char crypt_key[BINARY_SIZE];
		63	static char saved_key[PLAINTEXT_LENGTH + 1];
		64	#endif
65
66	static void *
67	binary(char *ciphertext) {
68	static char realcipher[BINARY_SIZE + 9];
69
70	/* stupid overflows */
71	memset(realcipher, 0, BINARY_SIZE + 9);
72	base64_decode(NSLDAP_MAGIC_LENGTH+ciphertext, CIPHERTEXT_LENGTH, realcipher);
73	return (void *)realcipher;
74	}
75
76	static int
77	valid(char *ciphertext)
78	{
79	if(ciphertext && strlen(ciphertext) == CIPHERTEXT_LENGTH)
80	return !strncasecmp(ciphertext, NSLDAP_MAGIC, NSLDAP_MAGIC_LENGTH);
81	return 0;
82	}
83
84	static int binary_hash_0(void *binary)
85	{
86	return ((int *)binary)[0] & 0xF;
87	}
88
89	static int binary_hash_1(void *binary)
90	{
91	return ((int *)binary)[0] & 0xFF;
92	}
93
94	static int binary_hash_2(void *binary)
95	{
96	return ((int *)binary)[0] & 0xFFF;
97	}
98
99	static int get_hash_0(int index)
100	{
101	return ((int *)crypt_key)[index] & 0xF;
102	}
103
104	static int get_hash_1(int index)
105	{
106	return ((int *)crypt_key)[index] & 0xFF;
107	}
108
109	static int get_hash_2(int index)
110	{
111	return ((int *)crypt_key)[index] & 0xFFF;
112	}
113
114	static void set_key(char *key, int index)
115	{
116	#ifdef MMX_COEF
117	int len;
118	int i;
119
120	if(index==0)
121	{
122	total_len = 0;
123	memset(saved_key, 0, PLAINTEXT_LENGTH*MMX_COEF);
124	}
125	len = strlen(key);
126	if(len>PLAINTEXT_LENGTH)
127	len = PLAINTEXT_LENGTH;
128
129	total_len += len << ( ( (32/MMX_COEF) * index ) );
130	for(i=0;i<len;i++)
131	saved_key[GETPOS(i, index)] = key[i];
132
133	saved_key[GETPOS(i, index)] = 0x80;
134	#else
135	strnzcpy(saved_key, key, PLAINTEXT_LENGTH+1);
136	#endif
137	}
138
139	static char *get_key(int index)
140	{
141	#ifdef MMX_COEF
142	unsigned int i,s;
143
144	s = (total_len >> (((32/MMX_COEF)*(index)))) & 0xff;
145	for(i=0;i<s;i++)
146	out[i] = saved_key[ GETPOS(i, index) ];
147	out[i] = 0;
148	return out;
149	#else
150	return saved_key;
151	#endif
152	}
153
154	static int
155	cmp_all(void *binary, int index)
156	{
157	int i = 0;
158	#ifdef MMX_COEF
159	while(i< (BINARY_SIZE/4) )
160	{
161	if (
162	( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF])
163	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+1])
164	#if (MMX_COEF > 3)
165	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+2])
166	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+3])
167	#endif
168	)
169	return 0;
170	i++;
171	}
172	#else
173	while(i<BINARY_SIZE)
174	{
175	if(((char )binary)[i]!=((char )crypt_key)[i])
176	return 0;
177	i++;
178	}
179	#endif
180	return 1;
181	}
182
183	static int
184	cmp_exact(char *source, int index)
185	{
186	return 1;
187	}
188
189	static int cmp_one(void * binary, int index)
190	{
191	#ifdef MMX_COEF
192	int i = 0;
193	for(i=0;i<(BINARY_SIZE/4);i++)
194	if ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+index] )
195	return 0;
196	return 1;
197	#else
198	return cmp_all(binary, index);
199	#endif
200	}
201
202	static void set_salt(void *salt) {
203	}
204
205	static void
206	crypt_all(int count) {
207	#ifdef MMX_COEF
208	memcpy(buffer, saved_key, 32*MMX_COEF);
209	shammx(crypt_key, buffer, total_len);
210	#else
211	static SHA_CTX ctx;
212	SHA1_Init(&ctx);
213	SHA1_Update(&ctx, saved_key, strlen(saved_key));
214	SHA1_Final(crypt_key, &ctx);
215	#endif
216	}
217
218	struct fmt_main fmt_NSLDAP = {
219	{
220	FORMAT_LABEL,
221	FORMAT_NAME,
222	SHA_TYPE,
223	BENCHMARK_COMMENT,
224	BENCHMARK_LENGTH,
225	PLAINTEXT_LENGTH,
226	BINARY_SIZE,
227	SALT_SIZE,
228	MIN_KEYS_PER_CRYPT,
229	MAX_KEYS_PER_CRYPT,
230	FMT_CASE \| FMT_8_BIT,
231	tests
232	}, {
233	fmt_default_init,
234	valid,
235	fmt_default_split,
236	binary,
237	fmt_default_salt,
238	{
239	binary_hash_0,
240	binary_hash_1,
241	binary_hash_2
242	},
243	fmt_default_salt_hash,
244	set_salt,
245	set_key,
246	get_key,
247	fmt_default_clear_keys,
248	crypt_all,
249	{
250	get_hash_0,
251	get_hash_1,
252	get_hash_2
253	},
254	cmp_all,
255	cmp_one,
256	cmp_exact
257	}
258	};
259

Line 0 Link Here

(-)john-1.7.0.1/src/NT_fmt.c (+194 lines)
		1	/*
		2	* NTLM patch for john version 0.3
		3	*
		4	* (C) 2001 Olle Segerdahl <olle@nxs.se>
		5	*
		6	* license: GPL <http://www.gnu.org/licenses/gpl.html>
		7	*
		8	* This file is based on code from John the Ripper,
		9	* Copyright (c) 1996-99 by Solar Designer
		10	*
		11	* performance enhancements by bartavelle@bandecon.com
		12	*/
		13
		14	#include <string.h>
		15
		16	#include "arch.h"
		17	#include "memory.h"
		18	#include "common.h"
		19	#include "formats.h"
		20
		21	#ifndef uchar
		22	#define uchar unsigned char
		23	#endif
		24
		25	#define FORMAT_LABEL "nt"
		26	#define FORMAT_NAME "NT MD4"
		27
		28	#define BENCHMARK_COMMENT ""
		29	#define BENCHMARK_LENGTH -1
		30
		31	#define PLAINTEXT_LENGTH 54
		32	#define CIPHERTEXT_LENGTH 36
		33
		34
		35	static struct fmt_tests tests[] = {
		36	{"$NT$b7e4b9022cd45f275334bbdb83bb5be5", "John the Ripper"},
		37	{"$NT$8846f7eaee8fb117ad06bdd830b7586c", "password"},
		38	{"$NT$0cb6948805f797bf2a82807973b89537", "test"},
		39	{"$NT$31d6cfe0d16ae931b73c59d7e0c089c0", ""},
		40	{NULL}
		41	};
		42
		43	#define ALGORITHM_NAME "TridgeMD4"
		44
		45	#define BINARY_SIZE 16
		46	#define SALT_SIZE 0
		47
		48	#define MIN_KEYS_PER_CRYPT 1
		49	#define MAX_KEYS_PER_CRYPT 1
		50
		51	uchar saved_plain[PLAINTEXT_LENGTH + 1];
		52	uchar output[BINARY_SIZE + 1];
		53
		54	extern void E_md4hash(uchar passwd, uchar p16);
		55
		56
		57	static int valid(char *ciphertext)
		58	{
		59	char *pos;
		60
		61	if (strncmp(ciphertext, "$NT$", 4)!=0) return 0;
		62
		63	for (pos = &ciphertext[4]; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);
		64
65	if (!*pos && pos - ciphertext == CIPHERTEXT_LENGTH)
66	return 1;
67	else
68	return 0;
69
70	}
71
72	static void get_binary(char ciphertext)
73	{
74	static uchar binary[BINARY_SIZE];
75	int i;
76
77	ciphertext+=4;
78	for (i=0; i<BINARY_SIZE; i++)
79	{
80	binary[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])])<<4;
81	binary[i] \|= (atoi16[ARCH_INDEX(ciphertext[i*2+1])]);
82	}
83
84	return binary;
85	}
86
87	static int binary_hash_0(void *binary)
88	{
89	return ((uchar *)binary)[0] & 0x0F;
90	}
91
92	static int binary_hash_1(void *binary)
93	{
94	return ((uchar *)binary)[0];
95	}
96
97	static int binary_hash_2(void *binary)
98	{
99	return (((uchar )binary)[0] << 4) + (((uchar )binary)[1] & 0x0F);
100	}
101
102	static int get_hash_0(int index)
103	{
104	return output[0] & 0x0F;
105	}
106
107	static int get_hash_1(int index)
108	{
109	return output[0];
110	}
111
112	static int get_hash_2(int index)
113	{
114	return (output[0] << 4) + (output[1] & 0x0F);
115	}
116
117	static void crypt_all(int count)
118	{
119	E_md4hash(saved_plain, output);
120	}
121
122	static int cmp_all(void *binary, int count)
123	{
124	int i = 0;
125	while(i<BINARY_SIZE)
126	{
127	if(((char )binary)[i]!=((char )output)[i])
128	return 0;
129	i++;
130	}
131	return 1;
132	}
133
134	static int cmp_exact(char *source, int index)
135	{
136	return !memcmp(output, get_binary(source), index);
137	}
138
139	static void set_salt(void *salt)
140	{
141	}
142
143	static void set_key(char *key, int index)
144	{
145	strncpy(saved_plain, key, PLAINTEXT_LENGTH);
146	saved_plain[PLAINTEXT_LENGTH] = 0;
147	}
148
149	static char *get_key(int index)
150	{
151	return saved_plain;
152	}
153
154	struct fmt_main fmt_NT = {
155	{
156	FORMAT_LABEL,
157	FORMAT_NAME,
158	ALGORITHM_NAME,
159	BENCHMARK_COMMENT,
160	BENCHMARK_LENGTH,
161	PLAINTEXT_LENGTH,
162	BINARY_SIZE,
163	SALT_SIZE,
164	MIN_KEYS_PER_CRYPT,
165	MAX_KEYS_PER_CRYPT,
166	FMT_CASE \| FMT_8_BIT,
167	tests
168	}, {
169	fmt_default_init,
170	valid,
171	fmt_default_split,
172	get_binary,
173	fmt_default_salt,
174	{
175	binary_hash_0,
176	binary_hash_1,
177	binary_hash_2
178	},
179	fmt_default_salt_hash,
180	set_salt,
181	set_key,
182	get_key,
183	fmt_default_clear_keys,
184	crypt_all,
185	{
186	get_hash_0,
187	get_hash_1,
188	get_hash_2
189	},
190	cmp_all,
191	cmp_all,
192	cmp_exact
193	}
194	};

Line 0 Link Here

(-)john-1.7.0.1/src/NTmmx_fmt.c (+254 lines)
		1	/*
		2	* NTLM patch for john version 0.3
		3	*
		4	* (C) 2001 Olle Segerdahl <olle@nxs.se>
		5	*
		6	* license: GPL <http://www.gnu.org/licenses/gpl.html>
		7	*
		8	* This file is based on code from John the Ripper,
		9	* Copyright (c) 1996-99 by Solar Designer
		10	*
		11	* performance enhancements by bartavelle@bandecon.com
		12	*/
		13
		14	#include <string.h>
		15
		16	#include "arch.h"
		17	#include "memory.h"
		18	#include "common.h"
		19	#include "formats.h"
		20	#include "md4.h"
		21
		22	#ifndef uchar
		23	#define uchar unsigned char
		24	#endif
		25
		26	#define FORMAT_LABEL "ntmmx"
		27	#define FORMAT_NAME "NT MD4 MMX"
		28
		29	#define BENCHMARK_COMMENT MMX_TYPE
		30	#define BENCHMARK_LENGTH -1
		31
		32	#define PLAINTEXT_LENGTH 32
		33	#define CIPHERTEXT_LENGTH 36
		34
		35
		36	static struct fmt_tests tests[] = {
		37	{"$NT$b7e4b9022cd45f275334bbdb83bb5be5", "John the Ripper"},
		38	{"$NT$8846f7eaee8fb117ad06bdd830b7586c", "password"},
		39	{"$NT$0cb6948805f797bf2a82807973b89537", "test"},
		40	{"$NT$31d6cfe0d16ae931b73c59d7e0c089c0", ""},
		41	{NULL}
		42	};
		43
		44	#define ALGORITHM_NAME "bartavelle"
		45
		46	#define BINARY_SIZE 16
		47	#define SALT_SIZE 0
		48
		49
		50	#define MIN_KEYS_PER_CRYPT MMX_COEF
		51	#define MAX_KEYS_PER_CRYPT MMX_COEF
		52
		53	#define GETPOS(i,idx) ( ((i)&0xfffe)*MMX_COEF + ((i)&1) + ((idx)<<1) )
		54
		55	//uchar saved_plain[PLAINTEXT_LENGTH + 1];
		56
		57	static unsigned char saved_plain[64 * MMX_COEF] __attribute__ ((aligned(32)));
		58	/static unsigned char tmpbuf[64 MMX_COEF] __attribute__ ((aligned(32)));*/
		59	static unsigned char output[BINARY_SIZE*MMX_COEF + 1] __attribute__ ((aligned(32)));
		60	static unsigned char out[32];
		61	static unsigned long total_len;
		62	/static int global_watch = 0;/
		63
		64	static int valid(char *ciphertext)
65	{
66	char *pos;
67
68	if (strncmp(ciphertext, "$NT$", 4)!=0) return 0;
69
70	for (pos = &ciphertext[4]; atoi16[ARCH_INDEX(*pos)] != 0x7F; pos++);
71
72	if (!*pos && pos - ciphertext == CIPHERTEXT_LENGTH)
73	return 1;
74	else
75	return 0;
76
77	}
78
79	static void get_binary(char ciphertext)
80	{
81	static uchar binary[BINARY_SIZE];
82	int i;
83
84	ciphertext+=4;
85	for (i=0; i<BINARY_SIZE; i++)
86	{
87	binary[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])])<<4;
88	binary[i] \|= (atoi16[ARCH_INDEX(ciphertext[i*2+1])]);
89	}
90
91	return binary;
92	}
93
94	static int binary_hash_0(void *binary)
95	{
96	return ((uchar *)binary)[0] & 0x0F;
97	}
98
99	static int binary_hash_1(void *binary)
100	{
101	return ((uchar *)binary)[0];
102	}
103
104	static int binary_hash_2(void *binary)
105	{
106	return (((uchar )binary)[0] << 4) + (((uchar )binary)[1] & 0x0F);
107	}
108
109	static int get_hash_0(int index)
110	{
111	return output[index*4] & 0x0F;
112	}
113
114	static int get_hash_1(int index)
115	{
116	return output[index*4];
117	}
118
119	static int get_hash_2(int index)
120	{
121	return (output[index4] << 4) + (output[index4+1] & 0x0F);
122	}
123
124	static void crypt_all(int count)
125	{
126	#if (MMX_COEF == 2)
127	mdfourmmx(output, saved_plain, total_len);
128	#endif
129	#if (MMX_COEF == 4)
130	mdfoursse2(output, saved_plain, total_len);
131	#endif
132	}
133
134	static int cmp_all(void *binary, int count)
135	{
136	int i = 0;
137
138	while(i<(BINARY_SIZE/4))
139	{
140	if (
141	( ((unsigned long )binary)[i] != ((unsigned long )output)[i*MMX_COEF])
142	#if (MMX_COEF > 1 )
143	&& ( ((unsigned long )binary)[i] != ((unsigned long )output)[i*MMX_COEF+1])
144	#endif
145	#if (MMX_COEF > 3)
146	&& ( ((unsigned long )binary)[i] != ((unsigned long )output)[i*MMX_COEF+2])
147	&& ( ((unsigned long )binary)[i] != ((unsigned long )output)[i*MMX_COEF+3])
148	#endif
149
150	)
151	return 0;
152	i++;
153	}
154	return 1;
155	}
156
157	static int cmp_one(void * binary, int index)
158	{
159	int i = 0;
160	for(i=0;i<(BINARY_SIZE/4);i++)
161	if ( ((unsigned long )binary)[i] != ((unsigned long )output)[i*MMX_COEF+index] )
162	return 0;
163	return 1;
164	}
165
166	static int cmp_exact(char *source, int index)
167	{
168	return 1;
169	}
170
171	static void set_salt(void *salt)
172	{
173	}
174
175	static void set_key(char *key, int index)
176	{
177	int len;
178	int i;
179
180	if(index==0)
181	{
182	total_len = 0;
183	memset(saved_plain, 0, 64*MMX_COEF);
184	}
185	len = strlen(key);
186	if(len > 32)
187	len = 32;
188
189	total_len += len << (1 + ( (32/MMX_COEF) * index ) );
190
191	for(i=0;i<len;i++)
192	((unsigned short *)saved_plain)[ GETPOS(i, index) ] = key[i] ;
193	((unsigned short *)saved_plain)[ GETPOS(i, index) ] = 0x80;
194	}
195
196	static char *get_key(int index)
197	{
198	unsigned int s, i;
199
200	#if (MMX_COEF == 4)
201	s = (total_len >> (1+((32/MMX_COEF)*(index)))) & 0xff;
202	#else
203	if(index == 0)
204	s = (total_len & 0xffff) >> 1 ;
205	else
206	s = total_len >> 17;
207	#endif
208	for(i=0;i<s;i++)
209	out[i] = ((unsigned short *)saved_plain)[ GETPOS(i, index) ];
210	out[i]=0;
211	return out;
212	}
213
214	struct fmt_main fmt_NTmmx = {
215	{
216	FORMAT_LABEL,
217	FORMAT_NAME,
218	ALGORITHM_NAME,
219	BENCHMARK_COMMENT,
220	BENCHMARK_LENGTH,
221	PLAINTEXT_LENGTH,
222	BINARY_SIZE,
223	SALT_SIZE,
224	MIN_KEYS_PER_CRYPT,
225	MAX_KEYS_PER_CRYPT,
226	FMT_CASE \| FMT_8_BIT,
227	tests
228	}, {
229	fmt_default_init,
230	valid,
231	fmt_default_split,
232	get_binary,
233	fmt_default_salt,
234	{
235	binary_hash_0,
236	binary_hash_1,
237	binary_hash_2
238	},
239	fmt_default_salt_hash,
240	set_salt,
241	set_key,
242	get_key,
243	fmt_default_clear_keys,
244	crypt_all,
245	{
246	get_hash_0,
247	get_hash_1,
248	get_hash_2
249	},
250	cmp_all,
251	cmp_one,
252	cmp_exact
253	}
254	};

Line 0 Link Here

(-)john-1.7.0.1/src/WPAPSK_fmt.c (+482 lines)
		1	/*
		2	* Copyright (c) 2004 bartavelle
		3	* bartavelle@bandecon.com
		4	*
		5	* Simple MD5 hashes cracker
		6	* It uses the Solar Designer's md5 implementation
		7	*
		8	*/
		9
		10	#include <string.h>
		11
		12	#include "arch.h"
		13	#include "misc.h"
		14	#include "common.h"
		15	#include "formats.h"
		16	#include "md5.h"
		17	#include "sha.h"
		18
		19	#define FORMAT_LABEL "wpapsk"
		20	#define FORMAT_NAME "WPA PSK"
		21	#ifdef MMX_COEF
		22	#if (MMX_COEF == 2)
		23	#define ALGORITHM_NAME "wpa-psk MMX"
		24	#else
		25	#define ALGORITHM_NAME "pwa-psk SSE2"
		26	#endif
		27	#else
		28	#define ALGORITHM_NAME "wpa-psk"
		29	#endif
		30
		31	#ifdef MMX_TYPE
		32	#define BENCHMARK_COMMENT MMX_TYPE
		33	#else
		34	#define BENCHMARK_COMMENT ""
		35	#endif
		36	#define BENCHMARK_LENGTH -1
		37
		38	#define PLAINTEXT_LENGTH 60
		39	#define CIPHERTEXT_LENGTH (128+400)
		40
		41	#define BINARY_SIZE 16
		42	#define SHA_SIZE 20
		43	#define SALT_SIZE 64
		44
		45	#ifdef MMX_COEF
		46	#define MIN_KEYS_PER_CRYPT MMX_COEF
		47	#define MAX_KEYS_PER_CRYPT MMX_COEF
		48	#define GETPOS(i, index) ( (index)4 + ((i)& (0xffffffff-3) )MMX_COEF + (((i)&3)) )
		49	#else
		50	#define MIN_KEYS_PER_CRYPT 1
		51	#define MAX_KEYS_PER_CRYPT 1
		52	#endif
		53
		54	// format : essid#MIC AA SPA snonce anonce keymic eapolframe
		55	static struct fmt_tests wpapsk_tests[] = {
		56	{"somethingclever#c016873ee6bb01499d77bde7c5e7a4be 00026f01b8fb000c413f313e289f35c24325dda9e773a11cd0416a880622c3589a37886e318120a7e0ad68dd8a4b70c7b368bac5b4476a9e6071270d1d5734e484cf09ddd3f29966e20136de 0103005ffe010900200000000000000001289f35c24325dda9e773a11cd0416a880622c3589a37886e318120a7e0ad68dd", "family movie night"},
		57	{NULL}
		58	};
		59
		60	#ifdef MMX_COEF
		61	//static char saved_key[PLAINTEXT_LENGTHMMX_COEF2 + 1] __attribute__ ((aligned(16)));
		62	static char crypt_key[64*MMX_COEF] __attribute__ ((aligned(16)));
		63	unsigned long total_len;
		64	unsigned char opad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
65	unsigned char ipad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
66	unsigned char cursalt[SALT_SIZE*MMX_COEF] __attribute__ ((aligned(16)));
67	unsigned char dump[804MMX_COEF] __attribute__((aligned(16)));
68	#else
69	//static char saved_key[PLAINTEXT_LENGTH + 1];
70	static char crypt_key[BINARY_SIZE+1];
71	static SHA_CTX ctx;
72	unsigned char opad[64];
73	unsigned char ipad[64];
74	unsigned char nopad[64];
75	unsigned char nipad[64];
76	unsigned char cursalt[SALT_SIZE];
77	unsigned char dump[SHA_SIZE];
78	#endif
79	unsigned char out[PLAINTEXT_LENGTH];
80
81	unsigned char DATA[12+64];
82	unsigned char nDATA[12+64+23+1];
83	unsigned char EAPOL[99];
84
85	static void wpapsk_init(void)
86	{
87	#ifdef MMX_COEF
88	memset(crypt_key, 0, 64*MMX_COEF);
89	memset(cursalt, 0, 64*MMX_COEF);
90	crypt_key[GETPOS(BINARY_SIZE,0)] = 0x80;
91	crypt_key[GETPOS(BINARY_SIZE,1)] = 0x80;
92	#if (MMX_COEF == 4)
93	crypt_key[GETPOS(BINARY_SIZE,2)] = 0x80;
94	crypt_key[GETPOS(BINARY_SIZE,3)] = 0x80;
95	#endif
96	#else
97	memset(nipad, 0x36, 64);
98	memset(nopad, 0x5C, 64);
99	memset(EAPOL, 0, sizeof(EAPOL));
100	strcpy(nDATA, "Pairwise key expansion");
101	#endif
102	}
103
104	static int valid(char *ciphertext)
105	{
106	int pos, i;
107
108	for(i=0;(i<strlen(ciphertext)) && (ciphertext[i]!='#');i++) ;
109	if(i==strlen(ciphertext))
110	return 0;
111	pos = i+1;
112	for (i = pos; i < BINARY_SIZE*2+pos; i++){
113	if (!( (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) \|\|
114	(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))
115	\|\| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
116	return 0;
117	}
118	return 1;
119	}
120
121	static void wpapsk_set_salt(void *salt)
122	{
123	#ifdef MMX_COEF
124	total_len = 0;
125	while( ((unsigned char *)salt)[total_len] )
126	{
127	cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
128	cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
129	#if (MMX_COEF == 4)
130	cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
131	cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
132	#endif
133	total_len ++;
134	}
135	while( ((unsigned char *)salt)[total_len-4] )
136	{
137	cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
138	cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
139	#if (MMX_COEF == 4)
140	cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
141	cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
142	#endif
143	total_len ++;
144	}
145
146	cursalt[GETPOS(total_len, 0)] = 0x80;
147	cursalt[GETPOS(total_len, 1)] = 0x80;
148	#if (MMX_COEF == 4)
149	cursalt[GETPOS(total_len, 2)] = 0x80;
150	cursalt[GETPOS(total_len, 3)] = 0x80;
151	#endif
152	#else
153	memcpy(cursalt, salt, SALT_SIZE);
154	#endif
155	}
156
157	static void wpapsk_set_key(char *key, int index) {
158	int i;
159	int len;
160
161	len = strlen(key);
162	if(len>PLAINTEXT_LENGTH)
163	len = PLAINTEXT_LENGTH;
164
165	#ifdef MMX_COEF
166	if(index==0)
167	{
168	memset(ipad, 0x36, 64*MMX_COEF);
169	memset(opad, 0x5C, 64*MMX_COEF);
170	}
171
172	for(i=0;i<len;i++)
173	{
174	ipad[GETPOS(i, index)] = 0x36 ^ key[i];
175	opad[GETPOS(i, index)] = 0x5C ^ key[i];
176	}
177
178	//saved_key[GETPOS(i, index)] = 0x80;
179	#else
180	memset(ipad, 0x36, 64);
181	memset(opad, 0x5C, 64);
182	for(i=0;i<len;i++)
183	{
184	ipad[i] ^= key[i];
185	opad[i] ^= key[i];
186	}
187	#endif
188	}
189
190	static char *wpapsk_get_key(int index) {
191	unsigned int i;
192	for(i=0;i<PLAINTEXT_LENGTH;i++)
193	#ifdef MMX_COEF
194	out[i] = ipad[ GETPOS(i, index) ] ^ 0x36;
195	#else
196	out[i] = ipad[ i ] ^ 0x36;
197	#endif
198	return out;
199	}
200
201	static int wpapsk_cmp_all(void *binary, int index) {
202	int i=0;
203	#ifdef MMX_COEF
204	while(i< (BINARY_SIZE/4) )
205	{
206	if (
207	( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF])
208	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+1])
209	#if (MMX_COEF > 3)
210	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+2])
211	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+3])
212	#endif
213	)
214	return 0;
215	i++;
216	}
217	#else
218	while(i<BINARY_SIZE)
219	{
220	if(((char )binary)[i]!=((char )crypt_key)[i])
221	return 0;
222	i++;
223	}
224	#endif
225	return 1;
226	}
227
228	static int wpapsk_cmp_exact(char *source, int count){
229	return (1);
230	}
231
232	static int wpapsk_cmp_one(void * binary, int index)
233	{
234	#ifdef MMX_COEF
235	int i = 0;
236	for(i=0;i<(BINARY_SIZE/4);i++)
237	if ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+index] )
238	return 0;
239	return 1;
240	#else
241	return wpapsk_cmp_all(binary, index);
242	#endif
243	}
244
245	/*
246	* ça ne marche pas et ça m'a gonflé
247	*/
248
249	static void wpapsk_crypt_all(int count) {
250	#ifdef MMX_COEF
251	/int i;/
252	printf("\n");
253	dump_stuff_mmx(ipad, 64, 0);
254	memcpy(dump, ipad, 64*MMX_COEF);
255	shammx_nosizeupdate( dump, dump, 64);
256
257	memcpy(dump, cursalt, 64*MMX_COEF);
258	shammx_noinit_uniformsizeupdate(dump, dump, total_len + 64 );
259	dump_stuff_mmx(dump, SHA_SIZE, 0);
260
261	shammx_nosizeupdate( dump, opad, 64);
262	shammx_noinit_uniformsizeupdate(dump, dump, SHA_SIZE + 64);
263	dump_stuff_mmx(dump, SHA_SIZE, 0);
264
265	return;
266	#else
267	unsigned char dump[SHA_SIZE];
268	unsigned char digest[SHA_SIZE];
269	unsigned char ptk[20*4];
270	unsigned int i,j;
271	MD5_CTX md5ctx;
272
273	//printf("\n");
274	//first calculation - left part
275	SHA1_Init( &ctx );
276	SHA1_Update( &ctx, ipad, 64 );
277	SHA1_Update( &ctx, cursalt, strlen(cursalt) + 4 );
278	SHA1_Final( dump, &ctx);
279	SHA1_Init( &ctx );
280	SHA1_Update( &ctx, opad, 64 );
281	SHA1_Update( &ctx, dump, SHA_SIZE);
282	SHA1_Final( dump, &ctx);
283	memcpy(digest, dump, SHA_SIZE);
284	for(i=1;i<4096;i++)
285	{
286	SHA1_Init( &ctx );
287	SHA1_Update( &ctx, ipad, 64 );
288	SHA1_Update( &ctx, dump, SHA_SIZE );
289	SHA1_Final( dump, &ctx);
290	SHA1_Init( &ctx );
291	SHA1_Update( &ctx, opad, 64 );
292	SHA1_Update( &ctx, dump, SHA_SIZE);
293	SHA1_Final( dump, &ctx);
294	for(j=0;j<SHA_SIZE;j++)
295	digest[j] ^= dump[j];
296	}
297	//first calculation - right part
298	cursalt[ strlen(cursalt) + 3 ] = 2;
299	SHA1_Init( &ctx );
300	SHA1_Update( &ctx, ipad, 64 );
301	SHA1_Update( &ctx, cursalt, strlen(cursalt) + 4 );
302	SHA1_Final( dump, &ctx);
303	SHA1_Init( &ctx );
304	SHA1_Update( &ctx, opad, 64 );
305	SHA1_Update( &ctx, dump, SHA_SIZE);
306	SHA1_Final( dump, &ctx);
307	memcpy(digest+SHA_SIZE, dump, 32-SHA_SIZE);
308	for(i=1;i<4096;i++)
309	{
310	SHA1_Init( &ctx );
311	SHA1_Update( &ctx, ipad, 64 );
312	SHA1_Update( &ctx, dump, SHA_SIZE );
313	SHA1_Final( dump, &ctx);
314	SHA1_Init( &ctx );
315	SHA1_Update( &ctx, opad, 64 );
316	SHA1_Update( &ctx, dump, SHA_SIZE);
317	SHA1_Final( dump, &ctx);
318	for(j=0;j<32-SHA_SIZE;j++)
319	digest[j+SHA_SIZE] ^= dump[j];
320	}
321	//we now got pmk in digest,32
322	//dump_stuff(digest, 32 );
323	for(i=0;i<32;i++)
324	{
325	nipad[i] = 0x36 ^ digest[i];
326	nopad[i] = 0x5c ^ digest[i];
327	}
328	//a hmac must be done with secret key pmk/32, and text "Pairwise key expansion",0,DATA,counter
329	nDATA[23+64+12] = 0;
330	SHA1_Init( &ctx );
331	SHA1_Update( &ctx, nipad, 64 );
332	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
333	SHA1_Final( dump, &ctx );
334	SHA1_Init( &ctx );
335	SHA1_Update( &ctx, nopad, 64 );
336	SHA1_Update( &ctx, dump, SHA_SIZE);
337	SHA1_Final( ptk, &ctx);
338
339	//seems not to be used ...
340	/*
341	nDATA[23+64+12] = 1;
342	SHA1_Init( &ctx );
343	SHA1_Update( &ctx, nipad, 64 );
344	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
345	SHA1_Final( dump, &ctx );
346	SHA1_Init( &ctx );
347	SHA1_Update( &ctx, nopad, 64 );
348	SHA1_Update( &ctx, dump, SHA_SIZE);
349	SHA1_Final( ptk + 20, &ctx);
350
351	nDATA[23+64+12] = 2;
352	SHA1_Init( &ctx );
353	SHA1_Update( &ctx, nipad, 64 );
354	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
355	SHA1_Final( dump, &ctx );
356	SHA1_Init( &ctx );
357	SHA1_Update( &ctx, nopad, 64 );
358	SHA1_Update( &ctx, dump, SHA_SIZE);
359	SHA1_Final( ptk + 40, &ctx);
360
361	nDATA[23+64+12] = 3;
362	SHA1_Init( &ctx );
363	SHA1_Update( &ctx, nipad, 64 );
364	SHA1_Update( &ctx, nDATA, 22+1+12+64+1 );
365	SHA1_Final( dump, &ctx );
366	SHA1_Init( &ctx );
367	SHA1_Update( &ctx, nopad, 64 );
368	SHA1_Update( &ctx, dump, SHA_SIZE);
369	SHA1_Final( ptk + 60, &ctx);
370	*/
371	//we now have the ptk ...
372
373	//now hmac md5 ...
374	memset(nipad + 16, 0x36 , 16);
375	memset(nopad + 16, 0x5C , 16);
376	for(i=0;i<16;i++)
377	{
378	nipad[i] = 0x36 ^ ptk[i];
379	nopad[i] = 0x5C ^ ptk[i];
380	}
381	MD5_Init( &md5ctx );
382	MD5_Update( &md5ctx, nipad, 64 );
383	MD5_Update( &md5ctx, EAPOL, sizeof(EAPOL) );
384	MD5_Final ( dump, &md5ctx );
385	MD5_Init( &md5ctx );
386	MD5_Update( &md5ctx, nopad, 64 );
387	MD5_Update( &md5ctx, dump, 16 );
388	MD5_Final ( crypt_key, &md5ctx );
389	#endif
390
391	}
392
393	static void * wpapsk_binary(char *ciphertext)
394	{
395	static unsigned char realcipher[BINARY_SIZE];
396	int i,pos;
397
398	for(i=0;ciphertext[i]!='#';i++);
399	pos=i+1;
400	for(i=0;i<BINARY_SIZE;i++)
401	{
402	realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i2+pos])]16 + atoi16[ARCH_INDEX(ciphertext[i*2+1+pos])];
403	}
404	pos += i*2+1;
405	i=0;
406	while(ciphertext[pos]!=' ')
407	{
408	DATA[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];
409	i++;
410	pos += 2;
411	}
412	memcpy(nDATA+23, DATA, 12+64);
413	pos++;
414	i=0;
415	while(ciphertext[pos])
416	{
417	EAPOL[i] = atoi16[ARCH_INDEX(ciphertext[pos])]*16 + atoi16[ARCH_INDEX(ciphertext[1+pos])];
418	i++;
419	pos += 2;
420	}
421
422	return (void *)realcipher;
423	}
424
425	static void * wpapsk_salt(char *ciphertext)
426	{
427	static unsigned char salt[SALT_SIZE];
428	memset(salt, 0, SALT_SIZE);
429	int i=0;
430	while(ciphertext[i]!='#')
431	{
432	salt[i] = ciphertext[i];
433	i++;
434	}
435	salt[i]=0;
436	salt[i+1]=0;
437	salt[i+2]=0;
438	salt[i+3]=1;
439	return salt;
440	}
441
442	struct fmt_main fmt_WPAPSK = {
443	{
444	FORMAT_LABEL,
445	FORMAT_NAME,
446	ALGORITHM_NAME,
447	BENCHMARK_COMMENT,
448	BENCHMARK_LENGTH,
449	PLAINTEXT_LENGTH,
450	BINARY_SIZE,
451	SALT_SIZE,
452	MIN_KEYS_PER_CRYPT,
453	MAX_KEYS_PER_CRYPT,
454	FMT_CASE \| FMT_8_BIT,
455	wpapsk_tests
456	}, {
457	wpapsk_init,
458	valid,
459	fmt_default_split,
460	wpapsk_binary,
461	wpapsk_salt,
462	{
463	fmt_default_binary_hash,
464	fmt_default_binary_hash,
465	fmt_default_binary_hash
466	},
467	fmt_default_salt_hash,
468	wpapsk_set_salt,
469	wpapsk_set_key,
470	wpapsk_get_key,
471	fmt_default_clear_keys,
472	wpapsk_crypt_all,
473	{
474	fmt_default_get_hash,
475	fmt_default_get_hash,
476	fmt_default_get_hash
477	},
478	wpapsk_cmp_all,
479	wpapsk_cmp_one,
480	wpapsk_cmp_exact
481	}
482	};

Line 0 Link Here

(-)john-1.7.0.1/src/base64.c (+74 lines)
		1
		2	#include <stdio.h>
		3	#include <string.h>
		4	#include <sys/types.h>
		5	#include <sys/stat.h>
		6
		7	void base64_unmap(char *in_block) {
		8	int i;
		9	unsigned char *c;
		10
		11	for(i=0; i<4; i++) {
		12	c = in_block + i;
		13
		14	if(c>='A' && c<='Z') {
		15	*c -= 'A';
		16	continue;
		17	}
		18
		19	if(c>='a' && c<='z') {
		20	*c -= 'a';
		21	*c += 26;
		22	continue;
		23	}
		24
		25	if(*c == '+') {
		26	*c = 62;
		27	continue;
		28	}
		29
		30	if(*c == '/') {
		31	*c = 63;
		32	continue;
		33	}
		34
		35	if(*c == '=') {
		36	*c = 0;
		37	}
		38
		39	*c -= '0';
		40	*c += 52;
		41	}
		42	}
		43
		44	int base64_decode(char in, int inlen, char out) {
		45	int i;
		46	char *in_block;
		47	char *out_block;
		48	char temp[4];
		49
		50	out_block = out;
		51	in_block = in;
		52
		53	for(i=0; i<inlen; i+=4) {
		54
		55	if(*in_block == '=')
		56	return 0;
		57
		58	memcpy(temp, in_block, 4);
		59	memset(out_block, 0, 3);
		60	base64_unmap(temp);
		61
		62	out_block[0] =
		63	((temp[0]<<2) & 0xfc) \| ((temp[1]>>4) & 3);
		64	out_block[1] =
65	((temp[1]<<4) & 0xf0) \| ((temp[2]>>2) & 0xf);
66	out_block[2] =
67	((temp[2]<<6) & 0xc0) \| ((temp[3] ) & 0x3f);
68
69	out_block += 3;
70	in_block += 4;
71	}
72
73	return 0;
74	}

Line 0 Link Here

(-)john-1.7.0.1/src/bf_tab.h (+277 lines)
		1	/* bf_tab.h: Blowfish P-box and S-box tables */
		2	#ifndef _H_TAB_BF
		3	#define _H_TAB_BF
		4
		5	static UWORD_32bits initbf_P[bf_N + 2] =
		6	{
		7	0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
		8	0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
		9	0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
		10	0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
		11	0x9216d5d9, 0x8979fb1b,
		12	};
		13	static UWORD_32bits initbf_S[4][256] =
		14	{
		15	{
		16	0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
		17	0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
		18	0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
		19	0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
		20	0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
		21	0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
		22	0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
		23	0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
		24	0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
		25	0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
		26	0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
		27	0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
		28	0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
		29	0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
		30	0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
		31	0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
		32	0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
		33	0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
		34	0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
		35	0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
		36	0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
		37	0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
		38	0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
		39	0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
		40	0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
		41	0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
		42	0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
		43	0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
		44	0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
		45	0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
		46	0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
		47	0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
		48	0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
		49	0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
		50	0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
		51	0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
		52	0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
		53	0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
		54	0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
		55	0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
		56	0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
		57	0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
		58	0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
		59	0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
		60	0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
		61	0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
		62	0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
		63	0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
		64	0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
65	0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
66	0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
67	0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
68	0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
69	0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
70	0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
71	0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
72	0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
73	0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
74	0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
75	0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
76	0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
77	0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
78	0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
79	0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
80	{
81	0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
82	0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
83	0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
84	0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
85	0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
86	0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
87	0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
88	0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
89	0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
90	0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
91	0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
92	0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
93	0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
94	0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
95	0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
96	0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
97	0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
98	0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
99	0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
100	0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
101	0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
102	0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
103	0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
104	0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
105	0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
106	0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
107	0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
108	0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
109	0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
110	0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
111	0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
112	0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
113	0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
114	0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
115	0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
116	0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
117	0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
118	0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
119	0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
120	0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
121	0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
122	0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
123	0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
124	0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
125	0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
126	0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
127	0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
128	0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
129	0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
130	0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
131	0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
132	0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
133	0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
134	0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
135	0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
136	0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
137	0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
138	0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
139	0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
140	0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
141	0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
142	0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
143	0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
144	0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
145	{
146	0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
147	0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
148	0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
149	0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
150	0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
151	0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
152	0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
153	0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
154	0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
155	0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
156	0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
157	0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
158	0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
159	0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
160	0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
161	0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
162	0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
163	0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
164	0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
165	0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
166	0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
167	0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
168	0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
169	0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
170	0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
171	0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
172	0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
173	0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
174	0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
175	0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
176	0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
177	0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
178	0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
179	0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
180	0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
181	0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
182	0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
183	0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
184	0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
185	0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
186	0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
187	0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
188	0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
189	0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
190	0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
191	0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
192	0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
193	0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
194	0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
195	0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
196	0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
197	0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
198	0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
199	0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
200	0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
201	0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
202	0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
203	0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
204	0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
205	0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
206	0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
207	0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
208	0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
209	0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
210	{
211	0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
212	0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
213	0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
214	0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
215	0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
216	0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
217	0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
218	0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
219	0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
220	0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
221	0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
222	0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
223	0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
224	0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
225	0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
226	0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
227	0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
228	0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
229	0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
230	0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
231	0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
232	0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
233	0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
234	0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
235	0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
236	0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
237	0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
238	0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
239	0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
240	0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
241	0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
242	0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
243	0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
244	0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
245	0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
246	0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
247	0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
248	0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
249	0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
250	0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
251	0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
252	0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
253	0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
254	0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
255	0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
256	0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
257	0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
258	0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
259	0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
260	0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
261	0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
262	0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
263	0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
264	0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
265	0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
266	0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
267	0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
268	0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
269	0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
270	0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
271	0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
272	0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
273	0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
274	0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
275	};
276
277	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/blowfish.c (+186 lines)
		1	/*
		2	* blowfish.c - part of blowfish.mod
		3	* handles: encryption and decryption of passwords
		4	*/
		5	/*
		6	* The first half of this is very lightly edited from public domain
		7	* sourcecode. For simplicity, this entire module will remain public
		8	* domain.
		9	*/
		10	/*
		11	* This is ripped from eggdrop 1.3.28's source files (blowfish.mod)
		12	* Modified by Sun-Zero <sun-zero@freemail.hu>
		13	* 2002-04-16
		14	*/
		15
		16	#include <stdlib.h>
		17
		18	#include "blowfish.h"
		19	#include "bf_tab.h" /* P-box P-array, S-box */
		20
		21	/* #define S(x,i) (bf_S[i][x.w.byte##i]) */
		22	#define S0(x) (bf_S[0][x.w.byte0])
		23	#define S1(x) (bf_S[1][x.w.byte1])
		24	#define S2(x) (bf_S[2][x.w.byte2])
		25	#define S3(x) (bf_S[3][x.w.byte3])
		26	#define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x))
		27	#define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n])
		28
		29	#include <time.h>
		30
		31	/* keep a set of rotating P & S boxes */
		32	static struct box_t {
		33	UWORD_32bits *P;
		34	UWORD_32bits **S;
		35	char key[81];
		36	char keybytes;
		37	} box;
		38
		39	//static UWORD_32bits bf_P[bf_N+2];
		40	//static UWORD_32bits bf_S[4][256];
		41	static UWORD_32bits *bf_P;
		42	static UWORD_32bits **bf_S;
		43
		44
		45	void blowfish_first_init(void) {
		46	box.P = NULL;
		47	box.S = NULL;
		48	box.key[0] = 0;
		49	}
		50
		51	static void blowfish_encipher(UWORD_32bits * xl, UWORD_32bits * xr)
		52	{
		53	union aword Xl;
		54	union aword Xr;
		55
		56	Xl.word = *xl;
		57	Xr.word = *xr;
		58
		59	Xl.word ^= bf_P[0];
		60	ROUND(Xr, Xl, 1);
		61	ROUND(Xl, Xr, 2);
		62	ROUND(Xr, Xl, 3);
		63	ROUND(Xl, Xr, 4);
		64	ROUND(Xr, Xl, 5);
65	ROUND(Xl, Xr, 6);
66	ROUND(Xr, Xl, 7);
67	ROUND(Xl, Xr, 8);
68	ROUND(Xr, Xl, 9);
69	ROUND(Xl, Xr, 10);
70	ROUND(Xr, Xl, 11);
71	ROUND(Xl, Xr, 12);
72	ROUND(Xr, Xl, 13);
73	ROUND(Xl, Xr, 14);
74	ROUND(Xr, Xl, 15);
75	ROUND(Xl, Xr, 16);
76	Xr.word ^= bf_P[17];
77
78	*xr = Xl.word;
79	*xl = Xr.word;
80	}
81
82	static void blowfish_init(UBYTE_08bits * key, short keybytes)
83	{
84	int i, j;
85	UWORD_32bits data;
86	UWORD_32bits datal;
87	UWORD_32bits datar;
88	union aword temp;
89
90	/* is buffer already allocated for this? */
91	if (box.P != NULL) {
92	if ((box.keybytes == keybytes) &&
93	(!strncmp((char ) (box.key), (char ) key, keybytes))) {
94	/* match! */
95	bf_P = box.P;
96	bf_S = box.S;
97	return;
98	}
99	free(box.P);
100	for (i = 0; i < 4; i++)
101	free(box.S[i]);
102	free(box.S);
103	}
104	/* initialize new buffer */
105	/* uh... this is over 4k */
106	box.P = (UWORD_32bits ) malloc((bf_N + 2) sizeof(UWORD_32bits));
107	box.S = (UWORD_32bits *) malloc(4 sizeof(UWORD_32bits *));
108	for (i = 0; i < 4; i++)
109	box.S[i] = (UWORD_32bits ) malloc(256 sizeof(UWORD_32bits));
110	bf_P = box.P;
111	bf_S = box.S;
112	box.keybytes = keybytes;
113	strncpy(box.key, key, keybytes);
114	/* robey: reset blowfish boxes to initial state */
115	/* (i guess normally it just keeps scrambling them, but here it's
116	* important to get the same encrypted result each time) */
117	for (i = 0; i < bf_N + 2; i++)
118	bf_P[i] = initbf_P[i];
119	for (i = 0; i < 4; i++)
120	for (j = 0; j < 256; j++)
121	bf_S[i][j] = initbf_S[i][j];
122
123	j = 0;
124	for (i = 0; i < bf_N + 2; ++i) {
125	temp.word = 0;
126	temp.w.byte0 = key[j];
127	temp.w.byte1 = key[(j + 1) % keybytes];
128	temp.w.byte2 = key[(j + 2) % keybytes];
129	temp.w.byte3 = key[(j + 3) % keybytes];
130	data = temp.word;
131	bf_P[i] = bf_P[i] ^ data;
132	j = (j + 4) % keybytes;
133	}
134	datal = 0x00000000;
135	datar = 0x00000000;
136	for (i = 0; i < bf_N + 2; i += 2) {
137	blowfish_encipher(&datal, &datar);
138	bf_P[i] = datal;
139	bf_P[i + 1] = datar;
140	}
141	for (i = 0; i < 4; ++i) {
142	for (j = 0; j < 256; j += 2) {
143	blowfish_encipher(&datal, &datar);
144	bf_S[i][j] = datal;
145	bf_S[i][j + 1] = datar;
146	}
147	}
148	}
149
150	/* stuff below this line was written by robey for eggdrop use */
151
152	/* of course, if you change either of these, then your userfile will
153	* no longer be able to be shared. :) */
154	#define SALT1 0xdeadd061
155	#define SALT2 0x23f6b095
156
157	/* convert 64-bit encrypted password to text for userfile */
158	static char *base64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
159
160	static void blowfish_encrypt_pass(char text, char new)
161	{
162	UWORD_32bits left, right;
163	int n;
164	char *p;
165
166	blowfish_init(text, strlen(text));
167	left = SALT1;
168	right = SALT2;
169	blowfish_encipher(&left, &right);
170	p = new;
171	p++ = '+'; / + means encrypted pass */
172	n = 32;
173	while (n > 0) {
174	*p++ = base64[right & 0x3f];
175	right = (right >> 6);
176	n -= 6;
177	}
178	n = 32;
179	while (n > 0) {
180	*p++ = base64[left & 0x3f];
181	left = (left >> 6);
182	n -= 6;
183	}
184	*p = 0;
185	}
186

Line 0 Link Here

(-)john-1.7.0.1/src/blowfish.h (+55 lines)
	1	/* modified 19jul1996 by robey -- uses autoconf values now */
	2	#ifndef _H_BLOWFISH
	3	#define _H_BLOWFISH
	4
	5	#include "arch.h"
	6
	7	#define bf_N 16
	8	#define noErr 0
	9	#define DATAERROR -1
	10
	11	#define UBYTE_08bits unsigned char
	12	#define UWORD_16bits unsigned short
	13
	14	#define SIZEOF_INT 4
	15
	16	#if SIZEOF_INT==4
	17	#define UWORD_32bits unsigned int
	18	#else
	19	#if SIZEOF_LONG==4
	20	#define UWORD_32bits unsigned long
	21	#endif
	22	#endif
	23
	24	/* choose a byte order for your hardware */
	25
	26	#if !ARCH_LITTLE_ENDIAN
	27	/* ABCD - big endian - motorola */
	28	union aword {
	29	UWORD_32bits word;
	30	UBYTE_08bits byte[4];
	31	struct {
	32	unsigned int byte0:8;
	33	unsigned int byte1:8;
	34	unsigned int byte2:8;
	35	unsigned int byte3:8;
	36	} w;
	37	};
	38	#endif /* !ARCH_LITTLE_ENDIAN */
	39
	40	#if ARCH_LITTLE_ENDIAN
	41	/* DCBA - little endian - intel */
	42	union aword {
	43	UWORD_32bits word;
	44	UBYTE_08bits byte[4];
	45	struct {
	46	unsigned int byte3:8;
	47	unsigned int byte2:8;
	48	unsigned int byte1:8;
	49	unsigned int byte0:8;
	50	} w;
	51	};
	52
	53	#endif /* ARCH_LITTLE_ENDIAN */
	54
	55	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/byteorder.h (+274 lines)
		1	/*
		2	Unix SMB/Netbios implementation.
		3	Version 1.9.
		4	SMB Byte handling
		5	Copyright (C) Andrew Tridgell 1992-1998
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 2 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		20	*/
		21
		22	#ifndef _BYTEORDER_H
		23	#define _BYTEORDER_H
		24
		25	/*
		26	This file implements macros for machine independent short and
		27	int manipulation
		28
		29	Here is a description of this file that I emailed to the samba list once:
		30
		31	> I am confused about the way that byteorder.h works in Samba. I have
		32	> looked at it, and I would have thought that you might make a distinction
		33	> between LE and BE machines, but you only seem to distinguish between 386
		34	> and all other architectures.
		35	>
		36	> Can you give me a clue?
		37
		38	sure.
		39
		40	The distinction between 386 and other architectures is only there as
		41	an optimisation. You can take it out completely and it will make no
		42	difference. The routines (macros) in byteorder.h are totally byteorder
		43	independent. The 386 optimsation just takes advantage of the fact that
		44	the x86 processors don't care about alignment, so we don't have to
		45	align ints on int boundaries etc. If there are other processors out
		46	there that aren't alignment sensitive then you could also define
		47	CAREFUL_ALIGNMENT=0 on those processors as well.
		48
		49	Ok, now to the macros themselves. I'll take a simple example, say we
		50	want to extract a 2 byte integer from a SMB packet and put it into a
		51	type called uint16 that is in the local machines byte order, and you
		52	want to do it with only the assumption that uint16 is _at_least_ 16
		53	bits long (this last condition is very important for architectures
		54	that don't have any int types that are 2 bytes long)
		55
		56	You do this:
		57
		58	#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
		59	#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
		60	#define SVAL(buf,pos) (PVAL(buf,pos)\|PVAL(buf,(pos)+1)<<8)
		61
		62	then to extract a uint16 value at offset 25 in a buffer you do this:
		63
		64	char *buffer = foo_bar();
65	uint16 xx = SVAL(buffer,25);
66
67	We are using the byteoder independence of the ANSI C bitshifts to do
68	the work. A good optimising compiler should turn this into efficient
69	code, especially if it happens to have the right byteorder :-)
70
71	I know these macros can be made a bit tidier by removing some of the
72	casts, but you need to look at byteorder.h as a whole to see the
73	reasoning behind them. byteorder.h defines the following macros:
74
75	SVAL(buf,pos) - extract a 2 byte SMB value
76	IVAL(buf,pos) - extract a 4 byte SMB value
77	SVALS(buf,pos) signed version of SVAL()
78	IVALS(buf,pos) signed version of IVAL()
79
80	SSVAL(buf,pos,val) - put a 2 byte SMB value into a buffer
81	SIVAL(buf,pos,val) - put a 4 byte SMB value into a buffer
82	SSVALS(buf,pos,val) - signed version of SSVAL()
83	SIVALS(buf,pos,val) - signed version of SIVAL()
84
85	RSVAL(buf,pos) - like SVAL() but for NMB byte ordering
86	RSVALS(buf,pos) - like SVALS() but for NMB byte ordering
87	RIVAL(buf,pos) - like IVAL() but for NMB byte ordering
88	RIVALS(buf,pos) - like IVALS() but for NMB byte ordering
89	RSSVAL(buf,pos,val) - like SSVAL() but for NMB ordering
90	RSIVAL(buf,pos,val) - like SIVAL() but for NMB ordering
91	RSIVALS(buf,pos,val) - like SIVALS() but for NMB ordering
92
93	it also defines lots of intermediate macros, just ignore those :-)
94
95	*/
96
97	/* some switch macros that do both store and read to and from SMB buffers */
98
99	#define RW_PCVAL(read,inbuf,outbuf,len) \
100	{ if (read) { PCVAL (inbuf,0,outbuf,len); } \
101	else { PSCVAL(inbuf,0,outbuf,len); } }
102
103	#define RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
104	{ if (read) { if (big_endian) { RPIVAL(inbuf,0,outbuf,len); } else { PIVAL(inbuf,0,outbuf,len); } } \
105	else { if (big_endian) { RPSIVAL(inbuf,0,outbuf,len); } else { PSIVAL(inbuf,0,outbuf,len); } } }
106
107	#define RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
108	{ if (read) { if (big_endian) { RPSVAL(inbuf,0,outbuf,len); } else { PSVAL(inbuf,0,outbuf,len); } } \
109	else { if (big_endian) { RPSSVAL(inbuf,0,outbuf,len); } else { PSSVAL(inbuf,0,outbuf,len); } } }
110
111	#define RW_CVAL(read, inbuf, outbuf, offset) \
112	{ if (read) { (outbuf) = CVAL (inbuf,offset); } \
113	else { SCVAL(inbuf,offset,outbuf); } }
114
115	#define RW_IVAL(read, big_endian, inbuf, outbuf, offset) \
116	{ if (read) { (outbuf) = ((big_endian) ? RIVAL(inbuf,offset) : IVAL (inbuf,offset)); } \
117	else { if (big_endian) { RSIVAL(inbuf,offset,outbuf); } else { SIVAL(inbuf,offset,outbuf); } } }
118
119	#define RW_SVAL(read, big_endian, inbuf, outbuf, offset) \
120	{ if (read) { (outbuf) = ((big_endian) ? RSVAL(inbuf,offset) : SVAL (inbuf,offset)); } \
121	else { if (big_endian) { RSSVAL(inbuf,offset,outbuf); } else { SSVAL(inbuf,offset,outbuf); } } }
122
123	#undef CAREFUL_ALIGNMENT
124
125	/* we know that the 386 can handle misalignment and has the "right"
126	byteorder */
127	#ifdef __i386__
128	#define CAREFUL_ALIGNMENT 0
129	#endif
130
131	#ifndef CAREFUL_ALIGNMENT
132	#define CAREFUL_ALIGNMENT 1
133	#endif
134
135	#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
136	#define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
137	#define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))
138
139
140	#if CAREFUL_ALIGNMENT
141
142	#define SVAL(buf,pos) (PVAL(buf,pos)\|PVAL(buf,(pos)+1)<<8)
143	#define IVAL(buf,pos) (SVAL(buf,pos)\|SVAL(buf,(pos)+2)<<16)
144	#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
145	#define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
146	#define SVALS(buf,pos) ((int16)SVAL(buf,pos))
147	#define IVALS(buf,pos) ((int32)IVAL(buf,pos))
148	#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16)(val)))
149	#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
150	#define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16)(val)))
151	#define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32)(val)))
152
153	#else /* CAREFUL_ALIGNMENT */
154
155	/* this handles things for architectures like the 386 that can handle
156	alignment errors */
157	/*
158	WARNING: This section is dependent on the length of int16 and int32
159	being correct
160	*/
161
162	/* get single value from an SMB buffer */
163	#define SVAL(buf,pos) ((const uint16 )((const char *)(buf) + (pos)))
164	#define IVAL(buf,pos) ((const uint32 )((const char *)(buf) + (pos)))
165	#define SVALS(buf,pos) ((const int16 )((const char *)(buf) + (pos)))
166	#define IVALS(buf,pos) ((const int32 )((const char *)(buf) + (pos)))
167
168	/* store single value in an SMB buffer */
169	#define SVALMOD(buf,pos) ((uint16 )((char *)(buf) + (pos)))
170	#define IVALMOD(buf,pos) ((uint32 )((char *)(buf) + (pos)))
171	#define SVALSMOD(buf,pos) ((int16 )((char *)(buf) + (pos)))
172	#define IVALSMOD(buf,pos) ((int32 )((char *)(buf) + (pos)))
173
174	#define SSVAL(buf,pos,val) SVALMOD(buf,pos)=((uint16)(val))
175	#define SIVAL(buf,pos,val) IVALMOD(buf,pos)=((uint32)(val))
176	#define SSVALS(buf,pos,val) SVALSMOD(buf,pos)=((int16)(val))
177	#define SIVALS(buf,pos,val) IVALSMOD(buf,pos)=((int32)(val))
178
179	#endif /* CAREFUL_ALIGNMENT */
180
181	/* macros for reading / writing arrays */
182
183	#define SMBMACRO(macro,buf,pos,val,len,size) \
184	{ uint32 l; for (l = 0; l < (uint32)(len); l++) (val)[l] = macro((buf), (pos) + (size)*l); }
185
186	#define SSMBMACRO(macro,buf,pos,val,len,size) \
187	{ uint32 l; for (l = 0; l < (uint32)(len); l++) macro((buf), (pos) + (size)*l, (val)[l]); }
188
189	/* reads multiple data from an SMB buffer */
190	#define PCVAL(buf,pos,val,len) SMBMACRO(CVAL,buf,pos,val,len,1)
191	#define PSVAL(buf,pos,val,len) SMBMACRO(SVAL,buf,pos,val,len,2)
192	#define PIVAL(buf,pos,val,len) SMBMACRO(IVAL,buf,pos,val,len,4)
193	#define PCVALS(buf,pos,val,len) SMBMACRO(CVALS,buf,pos,val,len,1)
194	#define PSVALS(buf,pos,val,len) SMBMACRO(SVALS,buf,pos,val,len,2)
195	#define PIVALS(buf,pos,val,len) SMBMACRO(IVALS,buf,pos,val,len,4)
196
197	/* stores multiple data in an SMB buffer */
198	#define PSCVAL(buf,pos,val,len) SSMBMACRO(SCVAL,buf,pos,val,len,1)
199	#define PSSVAL(buf,pos,val,len) SSMBMACRO(SSVAL,buf,pos,val,len,2)
200	#define PSIVAL(buf,pos,val,len) SSMBMACRO(SIVAL,buf,pos,val,len,4)
201	#define PSCVALS(buf,pos,val,len) SSMBMACRO(SCVALS,buf,pos,val,len,1)
202	#define PSSVALS(buf,pos,val,len) SSMBMACRO(SSVALS,buf,pos,val,len,2)
203	#define PSIVALS(buf,pos,val,len) SSMBMACRO(SIVALS,buf,pos,val,len,4)
204
205
206	/* now the reverse routines - these are used in nmb packets (mostly) */
207	#define SREV(x) ((((x)&0xFF)<<8) \| (((x)>>8)&0xFF))
208	#define IREV(x) ((SREV(x)<<16) \| (SREV((x)>>16)))
209
210	#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
211	#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
212	#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
213	#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
214	#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
215	#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
216	#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
217	#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))
218
219	/* reads multiple data from an SMB buffer (big-endian) */
220	#define RPSVAL(buf,pos,val,len) SMBMACRO(RSVAL,buf,pos,val,len,2)
221	#define RPIVAL(buf,pos,val,len) SMBMACRO(RIVAL,buf,pos,val,len,4)
222	#define RPSVALS(buf,pos,val,len) SMBMACRO(RSVALS,buf,pos,val,len,2)
223	#define RPIVALS(buf,pos,val,len) SMBMACRO(RIVALS,buf,pos,val,len,4)
224
225	/* stores multiple data in an SMB buffer (big-endian) */
226	#define RPSSVAL(buf,pos,val,len) SSMBMACRO(RSSVAL,buf,pos,val,len,2)
227	#define RPSIVAL(buf,pos,val,len) SSMBMACRO(RSIVAL,buf,pos,val,len,4)
228	#define RPSSVALS(buf,pos,val,len) SSMBMACRO(RSSVALS,buf,pos,val,len,2)
229	#define RPSIVALS(buf,pos,val,len) SSMBMACRO(RSIVALS,buf,pos,val,len,4)
230
231	#define DBG_RW_PCVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
232	{ RW_PCVAL(read,inbuf,outbuf,len) \
233	DEBUG(5,("%s%04x %s: ", \
234	tab_depth(depth), base,string)); \
235	if (charmode) print_asc(5, (unsigned char*)(outbuf), (len)); else \
236	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%02x ", (outbuf)[idx])); } } \
237	DEBUG(5,("\n")); }
238
239	#define DBG_RW_PSVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
240	{ RW_PSVAL(read,big_endian,inbuf,outbuf,len) \
241	DEBUG(5,("%s%04x %s: ", \
242	tab_depth(depth), base,string)); \
243	if (charmode) print_asc(5, (unsigned char)(outbuf), 2(len)); else \
244	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%04x ", (outbuf)[idx])); } } \
245	DEBUG(5,("\n")); }
246
247	#define DBG_RW_PIVAL(charmode,string,depth,base,read,big_endian,inbuf,outbuf,len) \
248	{ RW_PIVAL(read,big_endian,inbuf,outbuf,len) \
249	DEBUG(5,("%s%04x %s: ", \
250	tab_depth(depth), base,string)); \
251	if (charmode) print_asc(5, (unsigned char)(outbuf), 4(len)); else \
252	{ uint32 idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%08x ", (outbuf)[idx])); } } \
253	DEBUG(5,("\n")); }
254
255	#define DBG_RW_CVAL(string,depth,base,read,inbuf,outbuf) \
256	{ RW_CVAL(read,inbuf,outbuf,0) \
257	DEBUG(5,("%s%04x %s: %02x\n", \
258	tab_depth(depth), base, string, outbuf)); }
259
260	#define DBG_RW_SVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
261	{ RW_SVAL(read,big_endian,inbuf,outbuf,0) \
262	DEBUG(5,("%s%04x %s: %04x\n", \
263	tab_depth(depth), base, string, outbuf)); }
264
265	#define DBG_RW_IVAL(string,depth,base,read,big_endian,inbuf,outbuf) \
266	{ RW_IVAL(read,big_endian,inbuf,outbuf,0) \
267	DEBUG(5,("%s%04x %s: %08x\n", \
268	tab_depth(depth), base, string, outbuf)); }
269
270	/* Alignment macros. */
271	#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
272	#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))
273
274	#endif /* _BYTEORDER_H */

Line 0 Link Here

(-)john-1.7.0.1/src/des.h (+27 lines)
	1	#ifndef _DES_H
	2	#define _DES_H
	3
	4	//#include <openssl/des.h>
	5	typedef unsigned long DES_LONG;
	6
	7	typedef unsigned char DES_cblock[8];
	8
	9	typedef struct DES_ks
	10	{
	11	union
	12	{
	13	DES_cblock cblock;
	14	/* make sure things are correct size on machines with
	15	* 8 byte longs */
	16	DES_LONG deslong[2];
	17	} ks[16];
	18	} DES_key_schedule;
	19
	20
	21
	22	void my_des_ncbc_encrypt(const unsigned char *input,
	23	long length, DES_key_schedule schedule, DES_cblock ivec);
	24	void my_des_set_key(DES_cblock key, DES_key_schedule schedule);
	25
	26
	27	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/hmacMD5_fmt.c (+310 lines)
		1	/*
		2	* Copyright (c) 2004 bartavelle
		3	* bartavelle@bandecon.com
		4	*
		5	* Simple MD5 hashes cracker
		6	* It uses the Solar Designer's md5 implementation
		7	*
		8	*/
		9
		10	#include <string.h>
		11
		12	#include "arch.h"
		13	#include "misc.h"
		14	#include "common.h"
		15	#include "formats.h"
		16	#include "md5.h"
		17
		18	#define FORMAT_LABEL "hmac-md5"
		19	#define FORMAT_NAME "HMAC MD5"
		20	#ifdef MMX_COEF
		21	#if (MMX_COEF == 2)
		22	#define ALGORITHM_NAME "hmac-md5 MMX"
		23	#else
		24	#define ALGORITHM_NAME "hmac-md5 SSE2"
		25	#endif
		26	#else
		27	#define ALGORITHM_NAME "hmac-md5"
		28	#endif
		29
		30	#ifdef MMX_TYPE
		31	#define BENCHMARK_COMMENT MMX_TYPE
		32	#else
		33	#define BENCHMARK_COMMENT ""
		34	#endif
		35	#define BENCHMARK_LENGTH -1
		36
		37	#define PLAINTEXT_LENGTH 64
		38	#define CIPHERTEXT_LENGTH 128
		39
		40	#define BINARY_SIZE 16
		41	#define SALT_SIZE 64
		42
		43	#ifdef MMX_COEF
		44	#define MIN_KEYS_PER_CRYPT MMX_COEF
		45	#define MAX_KEYS_PER_CRYPT MMX_COEF
		46	#define GETPOS(i, index) ( (index)4 + (i& (0xffffffff-3) )MMX_COEF + ((i)&3) )
		47	#else
		48	#define MIN_KEYS_PER_CRYPT 1
		49	#define MAX_KEYS_PER_CRYPT 1
		50	#endif
		51
		52	static struct fmt_tests hmacmd5_tests[] = {
		53	{"what do ya want for nothing?#750c783e6ab0b503eaa86e310a5db738", "Jefe"},
		54	{NULL}
		55	};
		56
		57	#ifdef MMX_COEF
		58	//static char saved_key[PLAINTEXT_LENGTHMMX_COEF2 + 1] __attribute__ ((aligned(16)));
		59	static char crypt_key[64*MMX_COEF] __attribute__ ((aligned(16)));
		60	unsigned long total_len;
		61	unsigned char opad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
		62	unsigned char ipad[PLAINTEXT_LENGTH*MMX_COEF] __attribute__ ((aligned(16)));
		63	unsigned char cursalt[SALT_SIZE*MMX_COEF] __attribute__ ((aligned(16)));
		64	unsigned char dump[BINARY_SIZE*MMX_COEF] __attribute__((aligned(16)));
65	#else
66	//static char saved_key[PLAINTEXT_LENGTH + 1];
67	static char crypt_key[BINARY_SIZE+1];
68	static MD5_CTX ctx;
69	unsigned char opad[PLAINTEXT_LENGTH];
70	unsigned char ipad[PLAINTEXT_LENGTH];
71	unsigned char cursalt[SALT_SIZE];
72	#endif
73	unsigned char out[PLAINTEXT_LENGTH];
74
75	static void hmacmd5_init(void)
76	{
77	#ifdef MMX_COEF
78	memset(crypt_key, 0, 64*MMX_COEF);
79	crypt_key[GETPOS(BINARY_SIZE,0)] = 0x80;
80	crypt_key[GETPOS(BINARY_SIZE,1)] = 0x80;
81	#if (MMX_COEF == 4)
82	crypt_key[GETPOS(BINARY_SIZE,2)] = 0x80;
83	crypt_key[GETPOS(BINARY_SIZE,3)] = 0x80;
84	#endif
85	#endif
86	}
87
88	static int valid(char *ciphertext)
89	{
90	int pos, i;
91
92	for(i=0;(i<strlen(ciphertext)) && (ciphertext[i]!='#');i++) ;
93	if(i==strlen(ciphertext))
94	return 0;
95	pos = i+1;
96	if (strlen(ciphertext+pos) != BINARY_SIZE*2) return 0;
97	for (i = pos; i < BINARY_SIZE*2+pos; i++){
98	if (!( (('0' <= ciphertext[i])&&(ciphertext[i] <= '9')) \|\|
99	(('a' <= ciphertext[i])&&(ciphertext[i] <= 'f'))
100	\|\| (('A' <= ciphertext[i])&&(ciphertext[i] <= 'F'))))
101	return 0;
102	}
103	return 1;
104	}
105
106	static void hmacmd5_set_salt(void *salt)
107	{
108	#ifdef MMX_COEF
109	total_len = 0;
110	while(((unsigned char *)salt)[total_len])
111	{
112	cursalt[GETPOS(total_len, 0)] = ((unsigned char *)salt)[total_len];
113	cursalt[GETPOS(total_len, 1)] = ((unsigned char *)salt)[total_len];
114	#if (MMX_COEF == 4)
115	cursalt[GETPOS(total_len, 2)] = ((unsigned char *)salt)[total_len];
116	cursalt[GETPOS(total_len, 3)] = ((unsigned char *)salt)[total_len];
117	#endif
118	total_len ++;
119	}
120	cursalt[GETPOS(total_len, 0)] = 0x80;
121	cursalt[GETPOS(total_len, 1)] = 0x80;
122	#if (MMX_COEF == 4)
123	cursalt[GETPOS(total_len, 2)] = 0x80;
124	cursalt[GETPOS(total_len, 3)] = 0x80;
125	#endif
126	//total_len += 64;
127	//total_len += (total_len<<16);
128	#else
129	memcpy(cursalt, salt, SALT_SIZE);
130	#endif
131	}
132
133	static void hmacmd5_set_key(char *key, int index) {
134	int i;
135	int len;
136
137	len = strlen(key);
138	if(len>PLAINTEXT_LENGTH)
139	len = PLAINTEXT_LENGTH;
140
141	#ifdef MMX_COEF
142	if(index==0)
143	{
144	memset(ipad, 0x36, PLAINTEXT_LENGTH*MMX_COEF);
145	memset(opad, 0x5C, PLAINTEXT_LENGTH*MMX_COEF);
146	}
147
148	for(i=0;i<len;i++)
149	{
150	ipad[GETPOS(i, index)] ^= key[i];
151	opad[GETPOS(i, index)] ^= key[i];
152	}
153
154	//saved_key[GETPOS(i, index)] = 0x80;
155	#else
156	memset(ipad, 0x36, PLAINTEXT_LENGTH);
157	memset(opad, 0x5C, PLAINTEXT_LENGTH);
158	for(i=0;i<len;i++)
159	{
160	ipad[i] ^= key[i];
161	opad[i] ^= key[i];
162	}
163	#endif
164	}
165
166	static char *hmacmd5_get_key(int index) {
167	unsigned int i;
168	for(i=0;i<PLAINTEXT_LENGTH;i++)
169	#ifdef MMX_COEF
170	out[i] = ipad[ GETPOS(i, index) ] ^ 0x36;
171	#else
172	out[i] = ipad[ i ] ^ 0x36;
173	#endif
174	return out;
175	}
176
177	static int hmacmd5_cmp_all(void *binary, int index) {
178	int i=0;
179	#ifdef MMX_COEF
180	while(i< (BINARY_SIZE/4) )
181	{
182	if (
183	( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF])
184	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+1])
185	#if (MMX_COEF > 3)
186	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+2])
187	&& ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+3])
188	#endif
189	)
190	return 0;
191	i++;
192	}
193	#else
194	while(i<BINARY_SIZE)
195	{
196	if(((char )binary)[i]!=((char )crypt_key)[i])
197	return 0;
198	i++;
199	}
200	#endif
201	return 1;
202	}
203
204	static int hmacmd5_cmp_exact(char *source, int count){
205	return (1);
206	}
207
208	static int hmacmd5_cmp_one(void * binary, int index)
209	{
210	#ifdef MMX_COEF
211	int i = 0;
212	for(i=0;i<(BINARY_SIZE/4);i++)
213	if ( ((unsigned long )binary)[i] != ((unsigned long )crypt_key)[i*MMX_COEF+index] )
214	return 0;
215	return 1;
216	#else
217	return hmacmd5_cmp_all(binary, index);
218	#endif
219	}
220
221	static void hmacmd5_crypt_all(int count) {
222
223	#ifdef MMX_COEF
224	int i;
225	i = mdfivemmx_nosizeupdate( dump, ipad, 64);
226	i = mdfivemmx_noinit_uniformsizeupdate(crypt_key, cursalt, total_len + 64);
227	i = mdfivemmx_nosizeupdate( dump, opad, 64);
228	i = mdfivemmx_noinit_uniformsizeupdate(crypt_key, crypt_key, BINARY_SIZE + 64);
229	#else
230	MD5_Init( &ctx );
231	MD5_Update( &ctx, ipad, 64 );
232	MD5_Update( &ctx, cursalt, strlen(cursalt) );
233	MD5_Final( crypt_key, &ctx);
234	MD5_Init( &ctx );
235	MD5_Update( &ctx, opad, 64 );
236	MD5_Update( &ctx, crypt_key, BINARY_SIZE);
237	MD5_Final( crypt_key, &ctx);
238	#endif
239
240	}
241
242	static void * hmacmd5_binary(char *ciphertext)
243	{
244	static unsigned char realcipher[BINARY_SIZE];
245	int i,pos;
246
247	for(i=0;ciphertext[i]!='#';i++);
248	pos=i+1;
249	for(i=0;i<BINARY_SIZE;i++)
250	{
251	realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i2+pos])]16 + atoi16[ARCH_INDEX(ciphertext[i*2+1+pos])];
252	}
253	return (void *)realcipher;
254	}
255
256	static void * hmacmd5_salt(char *ciphertext)
257	{
258	static unsigned char salt[SALT_SIZE];
259	memset(salt, 0, SALT_SIZE);
260	int i=0;
261	while(ciphertext[i]!='#')
262	{
263	salt[i] = ciphertext[i];
264	i++;
265	}
266	salt[i]=0;
267	return salt;
268	}
269
270	struct fmt_main fmt_hmacMD5 = {
271	{
272	FORMAT_LABEL,
273	FORMAT_NAME,
274	ALGORITHM_NAME,
275	BENCHMARK_COMMENT,
276	BENCHMARK_LENGTH,
277	PLAINTEXT_LENGTH,
278	BINARY_SIZE,
279	SALT_SIZE,
280	MIN_KEYS_PER_CRYPT,
281	MAX_KEYS_PER_CRYPT,
282	FMT_CASE \| FMT_8_BIT,
283	hmacmd5_tests
284	}, {
285	hmacmd5_init,
286	valid,
287	fmt_default_split,
288	hmacmd5_binary,
289	hmacmd5_salt,
290	{
291	fmt_default_binary_hash,
292	fmt_default_binary_hash,
293	fmt_default_binary_hash
294	},
295	fmt_default_salt_hash,
296	hmacmd5_set_salt,
297	hmacmd5_set_key,
298	hmacmd5_get_key,
299	fmt_default_clear_keys,
300	hmacmd5_crypt_all,
301	{
302	fmt_default_get_hash,
303	fmt_default_get_hash,
304	fmt_default_get_hash
305	},
306	hmacmd5_cmp_all,
307	hmacmd5_cmp_one,
308	hmacmd5_cmp_exact
309	}
310	};

Lines 37-47 Link Here

(-)john-1.7.0.1/src/john.c (-1 / +37 lines)
37	#endif	37	#endif
38		38
39	extern struct fmt_main fmt_DES, fmt_BSDI, fmt_MD5, fmt_BF;	39	extern struct fmt_main fmt_DES, fmt_BSDI, fmt_MD5, fmt_BF;
40	extern struct fmt_main fmt_AFS, fmt_LM;	40	extern struct fmt_main fmt_AFS, fmt_LM, fmt_rawMD5, fmt_NT;
		41	extern struct fmt_main fmt_MD5_apache;
		42	extern struct fmt_main fmt_BFEgg;
		43	extern struct fmt_main fmt_MYSQL;
		44	extern struct fmt_main fmt_NSLDAP;
		45	extern struct fmt_main fmt_lotus5;
		46	extern struct fmt_main fmt_mscash;
		47	extern struct fmt_main fmt_rawSHA1;
		48	extern struct fmt_main fmt_mssql;
		49	extern struct fmt_main fmt_hmacMD5;
		50	extern struct fmt_main fmt_WPAPSK;
		51	extern struct fmt_main fmt_oracle;
		52	#ifdef MMX_COEF
		53	extern struct fmt_main fmt_NTmmx;
		54	#endif
41		55
42	extern int unshadow(int argc, char **argv);	56	extern int unshadow(int argc, char **argv);
43	extern int unafs(int argc, char **argv);	57	extern int unafs(int argc, char **argv);
44	extern int unique(int argc, char **argv);	58	extern int unique(int argc, char **argv);
		59	extern int undrop(int argc, char **argv);
45		60
46	static struct db_main database;	61	static struct db_main database;
47	static struct fmt_main dummy_format;	62	static struct fmt_main dummy_format;
Lines 65-70 Link Here
65	john_register_one(&fmt_AFS);	80	john_register_one(&fmt_AFS);
66	john_register_one(&fmt_LM);	81	john_register_one(&fmt_LM);
67		82
		83	/* new ciphers */
		84	john_register_one(&fmt_MD5_apache);
		85	john_register_one(&fmt_MYSQL);
		86	john_register_one(&fmt_NSLDAP);
		87	john_register_one(&fmt_NT);
		88	john_register_one(&fmt_lotus5);
		89	john_register_one(&fmt_mscash);
		90	john_register_one(&fmt_rawMD5);
		91	john_register_one(&fmt_BFEgg);
		92	john_register_one(&fmt_rawSHA1);
		93	john_register_one(&fmt_mssql);
		94	john_register_one(&fmt_hmacMD5);
		95	john_register_one(&fmt_WPAPSK);
		96	john_register_one(&fmt_oracle);
		97	#ifdef MMX_COEF
		98	john_register_one(&fmt_NTmmx);
		99	#endif
		100
68	if (!fmt_list) {	101	if (!fmt_list) {
69	fprintf(stderr, "Unknown ciphertext format name requested\n");	102	fprintf(stderr, "Unknown ciphertext format name requested\n");
70	error();	103	error();
Lines 341-346 Link Here
341	if (!strcmp(name, "unique"))	374	if (!strcmp(name, "unique"))
342	return unique(argc, argv);	375	return unique(argc, argv);
343		376
		377	if (!strcmp(name, "undrop"))
		378	return undrop(argc, argv);
		379
344	john_init(name, argc, argv);	380	john_init(name, argc, argv);
345	john_run();	381	john_run();
346	john_done();	382	john_done();

Lines 206-211 Link Here

(-)john-1.7.0.1/src/loader.c (-1 / +64 lines)
206	if (!strncmp(*ciphertext, "NO PASSWORD", 11))	206	if (!strncmp(*ciphertext, "NO PASSWORD", 11))
207	*ciphertext = "";	207	*ciphertext = "";
208		208
		209	/* NT loader hack starts here ! */
		210	extern struct fmt_main fmt_NT;
		211
		212	/* TODO test !!! */
		213	if (&fmt_NT == *format) {
		214
		215	/*
		216	tmp = ldr_get_field(&line);
		217	*ciphertext = tmp;
		218	*/
		219
		220	if (!strncmp(*ciphertext, "NO PASSWORD", 11))
		221	*ciphertext = "";
		222	else {
		223	*ciphertext -= 4;
		224	strncpy(*ciphertext,"$NT$",4);
		225	}
		226	}
		227
		228	/* NT loader hack ends here ! */
		229
209	if (source) sprintf(source, "%s:%s", uid, line);	230	if (source) sprintf(source, "%s:%s", uid, line);
210	}	231	}
211		232
Lines 287-292 Link Here
287	struct list_main *words;	308	struct list_main *words;
288	size_t pw_size, salt_size;	309	size_t pw_size, salt_size;
289		310
		311	extern struct fmt_main fmt_mscash;
		312	extern struct fmt_main fmt_oracle;
		313
290	count = ldr_split_line(&login, &ciphertext, &gecos, &home,	314	count = ldr_split_line(&login, &ciphertext, &gecos, &home,
291	NULL, &db->format, db->options, line);	315	NULL, &db->format, db->options, line);
292	if (count <= 0) return;	316	if (count <= 0) return;
Lines 311-317 Link Here
311	}	335	}
312		336
313	for (index = 0; index < count; index++) {	337	for (index = 0; index < count; index++) {
314	piece = format->methods.split(ciphertext, index);	338	if (db->format == &fmt_mscash) {
		339	piece = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
		340	sprintf(piece, "M$%s#%s", login, ciphertext);
		341	} else if (db->format == &fmt_oracle) {
		342	piece = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
		343	sprintf(piece, "O$%s#%s", login, ciphertext);
		344	} else
		345	piece = format->methods.split(ciphertext, index);
315		346
316	binary = format->methods.binary(piece);	347	binary = format->methods.binary(piece);
317	pw_hash = LDR_HASH_FUNC(binary);	348	pw_hash = LDR_HASH_FUNC(binary);
Lines 644-649 Link Here
644	int hash;	675	int hash;
645	struct db_cracked *current;	676	struct db_cracked *current;
646		677
		678	extern struct fmt_main fmt_mscash;
		679	extern struct fmt_main fmt_oracle;
		680
647	format = NULL;	681	format = NULL;
648	count = ldr_split_line(&login, &ciphertext, &gecos, &home,	682	count = ldr_split_line(&login, &ciphertext, &gecos, &home,
649	source, &format, db->options, line);	683	source, &format, db->options, line);
Lines 653-658 Link Here
653		687
654	if (format) {	688	if (format) {
655	split = format->methods.split;	689	split = format->methods.split;
		690	if (format == &fmt_mscash) {
		691	char * ciphertext2 = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
		692	sprintf(ciphertext2, "M$%s#%s", login, ciphertext);
		693	ciphertext = ciphertext2;
		694	}
		695	if (format == &fmt_oracle) {
		696	char * ciphertext2 = (char *) mem_alloc_tiny(strlen(login) + strlen(ciphertext) + 4, MEM_ALIGN_NONE);
		697	sprintf(ciphertext2, "O$%s#%s", login, ciphertext);
		698	ciphertext = ciphertext2;
		699	}
656	unify = format->params.flags & FMT_SPLIT_UNIFIES_CASE;	700	unify = format->params.flags & FMT_SPLIT_UNIFIES_CASE;
657	} else {	701	} else {
658	split = fmt_default_split;	702	split = fmt_default_split;
Lines 692-697 Link Here
692	MEM_FREE(piece);	736	MEM_FREE(piece);
693		737
694	if (pass) {	738	if (pass) {
		739	/* modification by bartavelle, catches the no format bug */
		740	/*
		741	if(format)
		742	chars = format->params.plaintext_length;
		743	else
		744	chars = 0;
		745
		746	if (current && show && index < count - 1)
		747	if ((int)strlen(current->plaintext) != chars)
		748	current = NULL;
		749	*/
		750
695	chars = 0;	751	chars = 0;
696	if (show) {	752	if (show) {
697	if (format)	753	if (format)
Lines 710-715 Link Here
710		766
711	db->guess_count++;	767	db->guess_count++;
712	} else	768	} else
		769	/*
		770	if (show)
		771	do {
		772	putchar('?');
		773	} while (--chars);
		774	*/
		775
713	while (chars--)	776	while (chars--)
714	putchar('?');	777	putchar('?');
715	} else	778	} else

Line 0 Link Here

(-)john-1.7.0.1/src/lotus5_fmt.c (+247 lines)
		1	//original work by Jeff Fay
		2	//some optimisations by bartavelle@bandecon.com
		3
		4	#include <stdio.h>
		5	#include <string.h>
		6	#include "misc.h"
		7	#include "formats.h"
		8	#include "common.h"
		9
		10	/preprocessor constants that John The Ripper likes/
		11	#define FORMAT_LABEL "lotus5"
		12	#define FORMAT_NAME "Lotus5"
		13	#define ALGORITHM_NAME "Lotus v5 Proprietary"
		14	#define BENCHMARK_COMMENT ""
		15	#define BENCHMARK_LENGTH -1
		16	#define PLAINTEXT_LENGTH 16
		17	#define CIPHERTEXT_LENGTH 32
		18	#define BINARY_SIZE 16
		19	#define SALT_SIZE 0
		20	#define MIN_KEYS_PER_CRYPT 1
		21	#define MAX_KEYS_PER_CRYPT 1
		22
		23	/A struct used for JTR's benchmarks/
		24	static struct fmt_tests tests[] = {
		25	{"06E0A50B579AD2CD5FFDC48564627EE7", "secret"},
		26	{"355E98E7C7B59BD810ED845AD0FD2FC4", "password"},
		27	{"CD2D90E8E00D8A2A63A81F531EA8A9A3", "lotus"},
		28	{"69D90B46B1AC0912E5CCF858094BBBFC", "dirtydog"},
		29	{NULL}
		30	};
		31
		32	static const char lotus_magic_table[256] = {
		33	0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a,
		34	0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0,
		35	0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b,
		36	0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a,
		37	0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda,
		38	0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36,
		39	0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8,
		40	0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c,
		41	0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17,
		42	0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60,
		43	0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72,
		44	0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa,
		45	0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd,
		46	0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e,
		47	0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b,
		48	0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf,
		49	0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77,
		50	0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6,
		51	0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3,
		52	0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3,
		53	0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e,
		54	0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c,
		55	0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d,
		56	0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2,
		57	0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46,
		58	0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5,
		59	0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97,
		60	0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5,
		61	0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef,
		62	0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f,
		63	0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf,
		64	0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab,
65	};
66
67	/Some more JTR variables/
68	static char crypt_key[BINARY_SIZE+1];
69	static char saved_key[PLAINTEXT_LENGTH + 1];
70
71	/Utility function to convert hex to bin /
72	static void * binary (char *ciphertext)
73	{
74	static char realcipher[BINARY_SIZE];
75	int i;
76	for (i = 0; i < BINARY_SIZE; i++)
77	realcipher[i] = atoi16[ARCH_INDEX(ciphertext[i2])]16 + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
78	return ((void *) realcipher);
79	}
80
81	/*Another function required by JTR: decides whether we have a valid
82	* ciphertext */
83	static int
84	valid (char *ciphertext)
85	{
86	int i;
87
88	for (i = 0; i < CIPHERTEXT_LENGTH; i++)
89	if (!(((ciphertext[i] >= '0') && (ciphertext[i] <= '9'))
90	\|\| ((ciphertext[i] >= 'a') && (ciphertext[i] <= 'f'))
91	\|\| ((ciphertext[i] >= 'A') && (ciphertext[i] <= 'F'))))
92	{
93	return 0;
94	}
95	return 1;
96	}
97
98	/sets the value of saved_key so we can play with it/
99	static void set_key (char *key, int index)
100	{
101	strnzcpy (saved_key, key, PLAINTEXT_LENGTH + 1);
102	}
103
104	/retrieves the saved key; used by JTR/
105	static char * get_key (int index)
106	{
107	return saved_key;
108	}
109	static int
110	cmp_all (void *binary, int index)
111	{
112	int i = 0;
113	while(i<BINARY_SIZE)
114	{
115	if(((char )binary)[i]!=((char )crypt_key)[i])
116	return 0;
117	i++;
118	}
119	return 1;
120	}
121	static int cmp_exact (char *source, int index)
122	{
123	return 1;
124	}
125
126	static void set_salt (void *salt) { }
127
128
129	/Beginning of private functions/
130	/* Takes the plaintext password and generates the second row of our
131	* working matrix for the final call to the mixing function*/
132	void
133	lotus_transform_password (unsigned char inpass, unsigned char outh)
134	{
135	unsigned char prevbyte;
136	int i;
137
138	prevbyte = 0x00;
139	for (i = 0; i < 16; i++)
140	{
141	outh = lotus_magic_table[ARCH_INDEX((inpass) ^ prevbyte)];
142	prevbyte = *outh;
143	++outh;
144	++inpass;
145	}
146	}
147
148	/* The mixing function: perturbs the first three rows of the matrix*/
149	void lotus_mix (unsigned char *lotus_matrix)
150	{
151	int i, j;
152	unsigned char prevbyte;
153	unsigned char *temp;
154
155	prevbyte = 0x00;
156
157	for (i = 18; i > 0; i--)
158	{
159	temp = lotus_matrix;
160	for (j = 48; j > 0; j--)
161	{
162	temp = temp ^ lotus_magic_table[ARCH_INDEX((j + prevbyte) & 0xff)];
163	prevbyte = *temp;
164	temp++;
165	}
166	}
167	}
168
169
170	/the last public function; generates ciphertext/
171	static void crypt_all (int count)
172	{
173	unsigned char password[PLAINTEXT_LENGTH];
174	unsigned char lotus_matrix[64], lotus_matrix1, lotus_matrix2, lotus_matrix3, lotus_matrix4;
175	int i;
176	int password_length;
177
178	password_length = strlen (saved_key);
179	memset (password, (PLAINTEXT_LENGTH - password_length), PLAINTEXT_LENGTH);
180	lotus_matrix1 = lotus_matrix;
181	lotus_matrix2 = lotus_matrix1 + 16;
182	lotus_matrix3 = lotus_matrix2 + 16;
183	lotus_matrix4 = lotus_matrix3 + 16;
184	memcpy (password, saved_key, password_length);
185
186	memset (lotus_matrix1, 0, 16);
187	memcpy (lotus_matrix2, password, 16);
188	memcpy (lotus_matrix3, password, 16);
189	lotus_transform_password (lotus_matrix2, lotus_matrix4);
190	lotus_mix (lotus_matrix);
191	memcpy (lotus_matrix2, lotus_matrix4, 16);
192	for (i = 0; i < 16; i++)
193	{
194	lotus_matrix3[i] = lotus_matrix1[i] ^ lotus_matrix2[i];
195	}
196	lotus_mix (lotus_matrix);
197	memcpy (crypt_key, lotus_matrix1, BINARY_SIZE);
198	}
199
200	static int get_hash1(int index) { return (((unsigned int *)crypt_key)[0] & 0xf); }
201	static int get_hash2(int index) { return (((unsigned int *)crypt_key)[0] & 0xff); }
202	static int get_hash3(int index) { return (((unsigned int *)crypt_key)[0] & 0xfff); }
203	static int binary_hash1(void * binary) { return (((unsigned int *)binary)[0] & 0xf); }
204	static int binary_hash2(void * binary) { return (((unsigned int *)binary)[0] & 0xff); }
205	static int binary_hash3(void * binary) { return (((unsigned int *)binary)[0] & 0xfff); }
206
207	/* C's version of a class specifier */
208	struct fmt_main fmt_lotus5 = {
209	{
210	FORMAT_LABEL,
211	FORMAT_NAME,
212	ALGORITHM_NAME,
213	BENCHMARK_COMMENT,
214	BENCHMARK_LENGTH,
215	PLAINTEXT_LENGTH,
216	BINARY_SIZE,
217	SALT_SIZE,
218	MIN_KEYS_PER_CRYPT,
219	MAX_KEYS_PER_CRYPT,
220	FMT_CASE \| FMT_8_BIT,
221	tests
222	}, {
223	fmt_default_init,
224	valid,
225	fmt_default_split,
226	binary,
227	fmt_default_salt,
228	{
229	binary_hash1,
230	binary_hash2,
231	binary_hash3
232	},
233	fmt_default_salt_hash,
234	set_salt,
235	set_key,
236	get_key,
237	fmt_default_clear_keys,
238	crypt_all,
239	{
240	get_hash1,
241	get_hash2,
242	get_hash3
243	},
244	cmp_all,
245	cmp_all,
246	cmp_exact}
247	};

Line 0 Link Here

(-)john-1.7.0.1/src/md4-mmx.S (+194 lines)
		1
		2	// extern int mdfourmmx(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
		3
		4	#ifdef UNDERSCORES
		5	#define mdfourmmx _mdfourmmx
		6	#endif
		7
		8	.globl mdfourmmx
		9
		10	.data
		11	.align(16)
		12	const_init_a:
		13	.long 0x67452301
		14	.long 0x67452301
		15	const_init_b:
		16	.long 0xefcdab89
		17	.long 0xefcdab89
		18	const_init_c:
		19	.long 0x98badcfe
		20	.long 0x98badcfe
		21	const_init_d:
		22	.long 0x10325476
		23	.long 0x10325476
		24
		25	const_stage2:
		26	.long 0x5a827999
		27	.long 0x5a827999
		28	const_stage3:
		29	.long 0x6ed9eba1
		30	.long 0x6ed9eba1
		31
		32	.align(16)
		33	buffer:
		34	.zero(64*2)
		35
		36	#define ctxa %mm0
		37	#define ctxb %mm1
		38	#define ctxc %mm2
		39	#define ctxd %mm3
		40	#define tmp1 %mm4
		41	#define tmp2 %mm5
		42	#define tmp3 %mm6
		43	#define tmp4 %mm7
		44
		45
		46	//#define F_MMX(x, y, z) (z ^ (x & (y ^ z)))
		47
		48	#define F(x,y,z) \
		49	movq y, tmp1; \
		50	pxor z, tmp1; \
		51	pand x, tmp1; \
		52	pxor z, tmp1
		53
		54	//#define G_MMX(x, y, z) ((x & (y \| z)) \| (y & z))
		55
		56	#define G(x,y,z) \
		57	movq y, tmp1; \
		58	movq y, tmp2; \
		59	por z, tmp1; \
		60	pand z, tmp2; \
		61	pand x, tmp1; \
		62	por tmp2, tmp1
		63
		64	//#define H_MMX(x, y, z) (x ^ y ^ z)
65	#define H(x,y,z) \
66	movq x, tmp1; \
67	pxor y, tmp1; \
68	pxor z, tmp1
69
70	//#define STEP_MMX(f, a, b, c, d, x, s) \
71	// (a) += f((b), (c), (d)) + (x); \
72	// (a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s))));
73
74	#define STEP1(f, a, b, c, d, x, s) \
75	f(b, c, d); \
76	paddd (x*8)(%edx), tmp1; \
77	paddd tmp1, a; \
78	movq a, tmp3; \
79	pslld $s, a; \
80	psrld $(32-s), tmp3; \
81	por tmp3, a
82
83	#define STEP2(f, a, b, c, d, x, s) \
84	f(b, c, d); \
85	paddd (x*8)(%edx), tmp1; \
86	paddd tmp4, tmp1; \
87	paddd tmp1, a; \
88	movq a, tmp3; \
89	pslld $s, a; \
90	psrld $(32-s), tmp3; \
91	por tmp3, a
92
93
94	.text
95	/*
96	* Try to do some asm md4 w/ mmx
97	* %eax ptr -> out
98	* %edx ptr -> in
99	* %ecx n
100	*/
101
102	mdfourmmx:
103	//MD4 Init
104	pusha
105
106	shl $3, %ecx
107	mov %ecx, %ebx
108	and $0xffff, %ecx
109	shrl $16, %ebx
110	// %ecx contient la taille du premier mdp
111	// %edx celle du second
112	mov %ecx, (14*8)(%edx)
113	mov %ebx, (14*8+4)(%edx)
114
115	movq const_init_a, ctxa
116	movq const_init_b, ctxb
117	movq const_init_c, ctxc
118	movq const_init_d, ctxd
119
120	STEP1(F, ctxa, ctxb, ctxc, ctxd, 0, 3)
121	STEP1(F, ctxd, ctxa, ctxb, ctxc, 1, 7)
122	STEP1(F, ctxc, ctxd, ctxa, ctxb, 2, 11)
123	STEP1(F, ctxb, ctxc, ctxd, ctxa, 3, 19)
124	STEP1(F, ctxa, ctxb, ctxc, ctxd, 4, 3)
125	STEP1(F, ctxd, ctxa, ctxb, ctxc, 5, 7)
126	STEP1(F, ctxc, ctxd, ctxa, ctxb, 6, 11)
127	STEP1(F, ctxb, ctxc, ctxd, ctxa, 7, 19)
128	STEP1(F, ctxa, ctxb, ctxc, ctxd, 8, 3)
129	STEP1(F, ctxd, ctxa, ctxb, ctxc, 9, 7)
130	STEP1(F, ctxc, ctxd, ctxa, ctxb, 10, 11)
131	STEP1(F, ctxb, ctxc, ctxd, ctxa, 11, 19)
132	STEP1(F, ctxa, ctxb, ctxc, ctxd, 12, 3)
133	STEP1(F, ctxd, ctxa, ctxb, ctxc, 13, 7)
134	STEP1(F, ctxc, ctxd, ctxa, ctxb, 14, 11)
135	STEP1(F, ctxb, ctxc, ctxd, ctxa, 15, 19)
136
137	movq const_stage2, tmp4
138
139	STEP2(G, ctxa, ctxb, ctxc, ctxd, 0, 3)
140	STEP2(G, ctxd, ctxa, ctxb, ctxc, 4, 5)
141	STEP2(G, ctxc, ctxd, ctxa, ctxb, 8, 9)
142	STEP2(G, ctxb, ctxc, ctxd, ctxa, 12, 13)
143	STEP2(G, ctxa, ctxb, ctxc, ctxd, 1, 3)
144	STEP2(G, ctxd, ctxa, ctxb, ctxc, 5, 5)
145	STEP2(G, ctxc, ctxd, ctxa, ctxb, 9, 9)
146	STEP2(G, ctxb, ctxc, ctxd, ctxa, 13, 13)
147	STEP2(G, ctxa, ctxb, ctxc, ctxd, 2, 3)
148	STEP2(G, ctxd, ctxa, ctxb, ctxc, 6, 5)
149	STEP2(G, ctxc, ctxd, ctxa, ctxb, 10, 9)
150	STEP2(G, ctxb, ctxc, ctxd, ctxa, 14, 13)
151	STEP2(G, ctxa, ctxb, ctxc, ctxd, 3, 3)
152	STEP2(G, ctxd, ctxa, ctxb, ctxc, 7, 5)
153	STEP2(G, ctxc, ctxd, ctxa, ctxb, 11, 9)
154	STEP2(G, ctxb, ctxc, ctxd, ctxa, 15, 13)
155
156	movq const_stage3, tmp4
157
158	STEP2(H, ctxa, ctxb, ctxc, ctxd, 0, 3)
159	STEP2(H, ctxd, ctxa, ctxb, ctxc, 8, 9)
160	STEP2(H, ctxc, ctxd, ctxa, ctxb, 4, 11)
161	STEP2(H, ctxb, ctxc, ctxd, ctxa, 12, 15)
162	STEP2(H, ctxa, ctxb, ctxc, ctxd, 2, 3)
163	STEP2(H, ctxd, ctxa, ctxb, ctxc, 10, 9)
164	STEP2(H, ctxc, ctxd, ctxa, ctxb, 6, 11)
165	STEP2(H, ctxb, ctxc, ctxd, ctxa, 14, 15)
166	STEP2(H, ctxa, ctxb, ctxc, ctxd, 1, 3)
167	STEP2(H, ctxd, ctxa, ctxb, ctxc, 9, 9)
168	STEP2(H, ctxc, ctxd, ctxa, ctxb, 5, 11)
169	STEP2(H, ctxb, ctxc, ctxd, ctxa, 13, 15)
170	STEP2(H, ctxa, ctxb, ctxc, ctxd, 3, 3)
171	STEP2(H, ctxd, ctxa, ctxb, ctxc, 11, 9)
172	STEP2(H, ctxc, ctxd, ctxa, ctxb, 7, 11)
173	STEP2(H, ctxb, ctxc, ctxd, ctxa, 15, 15)
174
175	paddd const_init_a, ctxa
176	paddd const_init_b, ctxb
177	paddd const_init_c, ctxc
178	paddd const_init_d, ctxd
179
180
181	movq ctxa, 0(%eax)
182	movq ctxb, 8(%eax)
183	movq ctxc, 16(%eax)
184	movq ctxd, 24(%eax)
185
186	popa
187	movd ctxa, %eax
188	emms
189
190	ret
191
192	#ifdef __ELF__
193	.section .note.GNU-stack,"",@progbits
194	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md4-sse2.S (+223 lines)
		1
		2	// extern int mdfoursse2(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
		3
		4	#ifdef UNDERSCORES
		5	#define mdfoursse2 _mdfoursse2
		6	#endif
		7
		8	.globl mdfoursse2
		9
		10	.data
		11	.align(16)
		12	const_init_a:
		13	.long 0x67452301
		14	.long 0x67452301
		15	.long 0x67452301
		16	.long 0x67452301
		17	const_init_b:
		18	.long 0xefcdab89
		19	.long 0xefcdab89
		20	.long 0xefcdab89
		21	.long 0xefcdab89
		22	const_init_c:
		23	.long 0x98badcfe
		24	.long 0x98badcfe
		25	.long 0x98badcfe
		26	.long 0x98badcfe
		27	const_init_d:
		28	.long 0x10325476
		29	.long 0x10325476
		30	.long 0x10325476
		31	.long 0x10325476
		32
		33	const_stage2:
		34	.long 0x5a827999
		35	.long 0x5a827999
		36	.long 0x5a827999
		37	.long 0x5a827999
		38	const_stage3:
		39	.long 0x6ed9eba1
		40	.long 0x6ed9eba1
		41	.long 0x6ed9eba1
		42	.long 0x6ed9eba1
		43
		44	.align(16)
		45	buffer:
		46	.zero(64*4)
		47
		48	#define ctxa %xmm0
		49	#define ctxb %xmm1
		50	#define ctxc %xmm2
		51	#define ctxd %xmm3
		52	#define tmp1 %xmm4
		53	#define tmp2 %xmm5
		54	#define tmp3 %xmm6
		55	#define tmp4 %xmm7
		56
		57
		58	//#define F_MMX(x, y, z) (z ^ (x & (y ^ z)))
		59
		60	#define F(x,y,z) \
		61	movapd y, tmp1; \
		62	pxor z, tmp1; \
		63	pand x, tmp1; \
		64	pxor z, tmp1
65
66	//#define G_MMX(x, y, z) ((x & (y \| z)) \| (y & z))
67
68	#define G(x,y,z) \
69	movapd y, tmp1; \
70	movapd y, tmp2; \
71	por z, tmp1; \
72	pand z, tmp2; \
73	pand x, tmp1; \
74	por tmp2, tmp1
75
76	//#define H_MMX(x, y, z) (x ^ y ^ z)
77	#define H(x,y,z) \
78	movapd x, tmp1; \
79	pxor y, tmp1; \
80	pxor z, tmp1
81
82	//#define STEP_MMX(f, a, b, c, d, x, s) \
83	// (a) += f((b), (c), (d)) + (x); \
84	// (a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s))));
85
86	#define STEP1(f, a, b, c, d, x, s) \
87	f(b, c, d); \
88	paddd (x*16)(%edx), tmp1; \
89	paddd tmp1, a; \
90	movapd a, tmp3; \
91	pslld $s, a; \
92	psrld $(32-s), tmp3; \
93	por tmp3, a
94
95	#define STEP2(f, a, b, c, d, x, s) \
96	f(b, c, d); \
97	paddd (x*16)(%edx), tmp1; \
98	paddd tmp4, tmp1; \
99	paddd tmp1, a; \
100	movapd a, tmp3; \
101	pslld $s, a; \
102	psrld $(32-s), tmp3; \
103	por tmp3, a
104
105
106	.text
107	/*
108	* Try to do some asm md4 w/ sse2
109	* %eax ptr -> out
110	* %edx ptr -> in
111	* %ecx n
112	*/
113
114	mdfoursse2:
115	//MD4 Init
116	pusha
117
118	//mov %edx, %eax
119	//ret
120
121	// shl $3, %ecx
122	mov %ecx, %ebx
123	shr $8, %ecx
124	and $0xff, %ebx
125	shl $3, %ebx
126	mov %ebx, (14*16)(%edx)
127
128	mov %ecx, %ebx
129	shr $8, %ecx
130	and $0xff, %ebx
131	shl $3, %ebx
132	mov %ebx, (14*16+4)(%edx)
133
134	mov %ecx, %ebx
135	shr $8, %ecx
136	and $0xff, %ebx
137	shl $3, %ebx
138	mov %ebx, (14*16+8)(%edx)
139
140	and $0xff, %ecx
141	shl $3, %ecx
142	mov %ecx, (14*16+12)(%edx)
143
144	movapd const_init_a, ctxa
145	movapd const_init_b, ctxb
146	movapd const_init_c, ctxc
147	movapd const_init_d, ctxd
148
149	STEP1(F, ctxa, ctxb, ctxc, ctxd, 0, 3)
150	STEP1(F, ctxd, ctxa, ctxb, ctxc, 1, 7)
151	STEP1(F, ctxc, ctxd, ctxa, ctxb, 2, 11)
152	STEP1(F, ctxb, ctxc, ctxd, ctxa, 3, 19)
153	STEP1(F, ctxa, ctxb, ctxc, ctxd, 4, 3)
154	STEP1(F, ctxd, ctxa, ctxb, ctxc, 5, 7)
155	STEP1(F, ctxc, ctxd, ctxa, ctxb, 6, 11)
156	STEP1(F, ctxb, ctxc, ctxd, ctxa, 7, 19)
157	STEP1(F, ctxa, ctxb, ctxc, ctxd, 8, 3)
158	STEP1(F, ctxd, ctxa, ctxb, ctxc, 9, 7)
159	STEP1(F, ctxc, ctxd, ctxa, ctxb, 10, 11)
160	STEP1(F, ctxb, ctxc, ctxd, ctxa, 11, 19)
161	STEP1(F, ctxa, ctxb, ctxc, ctxd, 12, 3)
162	STEP1(F, ctxd, ctxa, ctxb, ctxc, 13, 7)
163	STEP1(F, ctxc, ctxd, ctxa, ctxb, 14, 11)
164	STEP1(F, ctxb, ctxc, ctxd, ctxa, 15, 19)
165
166	movapd const_stage2, tmp4
167
168	STEP2(G, ctxa, ctxb, ctxc, ctxd, 0, 3)
169	STEP2(G, ctxd, ctxa, ctxb, ctxc, 4, 5)
170	STEP2(G, ctxc, ctxd, ctxa, ctxb, 8, 9)
171	STEP2(G, ctxb, ctxc, ctxd, ctxa, 12, 13)
172	STEP2(G, ctxa, ctxb, ctxc, ctxd, 1, 3)
173	STEP2(G, ctxd, ctxa, ctxb, ctxc, 5, 5)
174	STEP2(G, ctxc, ctxd, ctxa, ctxb, 9, 9)
175	STEP2(G, ctxb, ctxc, ctxd, ctxa, 13, 13)
176	STEP2(G, ctxa, ctxb, ctxc, ctxd, 2, 3)
177	STEP2(G, ctxd, ctxa, ctxb, ctxc, 6, 5)
178	STEP2(G, ctxc, ctxd, ctxa, ctxb, 10, 9)
179	STEP2(G, ctxb, ctxc, ctxd, ctxa, 14, 13)
180	STEP2(G, ctxa, ctxb, ctxc, ctxd, 3, 3)
181	STEP2(G, ctxd, ctxa, ctxb, ctxc, 7, 5)
182	STEP2(G, ctxc, ctxd, ctxa, ctxb, 11, 9)
183	STEP2(G, ctxb, ctxc, ctxd, ctxa, 15, 13)
184
185	movapd const_stage3, tmp4
186
187	STEP2(H, ctxa, ctxb, ctxc, ctxd, 0, 3)
188	STEP2(H, ctxd, ctxa, ctxb, ctxc, 8, 9)
189	STEP2(H, ctxc, ctxd, ctxa, ctxb, 4, 11)
190	STEP2(H, ctxb, ctxc, ctxd, ctxa, 12, 15)
191	STEP2(H, ctxa, ctxb, ctxc, ctxd, 2, 3)
192	STEP2(H, ctxd, ctxa, ctxb, ctxc, 10, 9)
193	STEP2(H, ctxc, ctxd, ctxa, ctxb, 6, 11)
194	STEP2(H, ctxb, ctxc, ctxd, ctxa, 14, 15)
195	STEP2(H, ctxa, ctxb, ctxc, ctxd, 1, 3)
196	STEP2(H, ctxd, ctxa, ctxb, ctxc, 9, 9)
197	STEP2(H, ctxc, ctxd, ctxa, ctxb, 5, 11)
198	STEP2(H, ctxb, ctxc, ctxd, ctxa, 13, 15)
199	STEP2(H, ctxa, ctxb, ctxc, ctxd, 3, 3)
200	STEP2(H, ctxd, ctxa, ctxb, ctxc, 11, 9)
201	STEP2(H, ctxc, ctxd, ctxa, ctxb, 7, 11)
202	STEP2(H, ctxb, ctxc, ctxd, ctxa, 15, 15)
203
204	paddd const_init_a, ctxa
205	paddd const_init_b, ctxb
206	paddd const_init_c, ctxc
207	paddd const_init_d, ctxd
208
209
210	movapd ctxa, 0(%eax)
211	movapd ctxb, 16(%eax)
212	movapd ctxc, 32(%eax)
213	movapd ctxd, 48(%eax)
214
215	popa
216	movd ctxa, %eax
217	emms
218
219	ret
220
221	#ifdef __ELF__
222	.section .note.GNU-stack,"",@progbits
223	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md4.c (+276 lines)
		1	/*
		2	* This is an OpenSSL-compatible implementation of the RSA Data Security,
		3	* Inc. MD4 Message-Digest Algorithm (RFC 1320).
		4	*
		5	* Written by Solar Designer <solar at openwall.com> in 2005, and placed
		6	* in the public domain. There's absolutely no warranty.
		7	*
		8	* This differs from Colin Plumb's older public domain implementation in
		9	* that no 32-bit integer data type is required, there's no compile-time
		10	* endianness configuration, and the function prototypes match OpenSSL's.
		11	* The primary goals are portability and ease of use.
		12	*
		13	* This implementation is meant to be fast, but not as fast as possible.
		14	* Some known optimizations are not included to reduce source code size
		15	* and avoid compile-time configuration.
		16	*/
		17
		18	#ifndef HAVE_OPENSSL
		19
		20	#include <string.h>
		21	#include "md4.h"
		22
		23	/*
		24	* The basic MD4 functions.
		25	*
		26	* F and G are optimized compared to their RFC 1320 definitions, with the
		27	* optimization for F borrowed from Colin Plumb's MD5 implementation.
		28	*/
		29	#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
		30	#define G(x, y, z) (((x) & ((y) \| (z))) \| ((y) & (z)))
		31	#define H(x, y, z) ((x) ^ (y) ^ (z))
		32
		33	/*
		34	* The MD4 transformation for all three rounds.
		35	*/
		36	#define STEP(f, a, b, c, d, x, s) \
		37	(a) += f((b), (c), (d)) + (x); \
		38	(a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s))));
		39
		40	/*
		41	* SET reads 4 input bytes in little-endian byte order and stores them
		42	* in a properly aligned word in host byte order.
		43	*
		44	* The check for little-endian architectures which tolerate unaligned
		45	* memory accesses is just an optimization. Nothing will break if it
		46	* doesn't work.
		47	*/
		48	#if defined(__i386__) \|\| defined(__vax__)
		49	#define SET(n) \
		50	((MD4_u32plus )&ptr[(n) * 4])
		51	#define GET(n) \
		52	SET(n)
		53	#else
		54	#define SET(n) \
		55	(ctx->block[(n)] = \
		56	(MD4_u32plus)ptr[(n) * 4] \| \
		57	((MD4_u32plus)ptr[(n) * 4 + 1] << 8) \| \
		58	((MD4_u32plus)ptr[(n) * 4 + 2] << 16) \| \
		59	((MD4_u32plus)ptr[(n) * 4 + 3] << 24))
		60	#define GET(n) \
		61	(ctx->block[(n)])
		62	#endif
		63
		64	/*
65	* This processes one or more 64-byte data blocks, but does NOT update
66	* the bit counters. There're no alignment requirements.
67	*/
68	static void body(MD4_CTX ctx, void *data, unsigned long size)
69	{
70	unsigned char *ptr;
71	MD4_u32plus a, b, c, d;
72	MD4_u32plus saved_a, saved_b, saved_c, saved_d;
73
74	ptr = data;
75
76	a = ctx->a;
77	b = ctx->b;
78	c = ctx->c;
79	d = ctx->d;
80
81	do {
82	saved_a = a;
83	saved_b = b;
84	saved_c = c;
85	saved_d = d;
86
87	/* Round 1 */
88	STEP(F, a, b, c, d, SET(0), 3)
89	STEP(F, d, a, b, c, SET(1), 7)
90	STEP(F, c, d, a, b, SET(2), 11)
91	STEP(F, b, c, d, a, SET(3), 19)
92	STEP(F, a, b, c, d, SET(4), 3)
93	STEP(F, d, a, b, c, SET(5), 7)
94	STEP(F, c, d, a, b, SET(6), 11)
95	STEP(F, b, c, d, a, SET(7), 19)
96	STEP(F, a, b, c, d, SET(8), 3)
97	STEP(F, d, a, b, c, SET(9), 7)
98	STEP(F, c, d, a, b, SET(10), 11)
99	STEP(F, b, c, d, a, SET(11), 19)
100	STEP(F, a, b, c, d, SET(12), 3)
101	STEP(F, d, a, b, c, SET(13), 7)
102	STEP(F, c, d, a, b, SET(14), 11)
103	STEP(F, b, c, d, a, SET(15), 19)
104
105	/* Round 2 */
106	STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
107	STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
108	STEP(G, c, d, a, b, GET(8) + 0x5a827999, 9)
109	STEP(G, b, c, d, a, GET(12) + 0x5a827999, 13)
110	STEP(G, a, b, c, d, GET(1) + 0x5a827999, 3)
111	STEP(G, d, a, b, c, GET(5) + 0x5a827999, 5)
112	STEP(G, c, d, a, b, GET(9) + 0x5a827999, 9)
113	STEP(G, b, c, d, a, GET(13) + 0x5a827999, 13)
114	STEP(G, a, b, c, d, GET(2) + 0x5a827999, 3)
115	STEP(G, d, a, b, c, GET(6) + 0x5a827999, 5)
116	STEP(G, c, d, a, b, GET(10) + 0x5a827999, 9)
117	STEP(G, b, c, d, a, GET(14) + 0x5a827999, 13)
118	STEP(G, a, b, c, d, GET(3) + 0x5a827999, 3)
119	STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
120	STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
121	STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)
122
123	/* Round 3 */
124	STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
125	STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
126	STEP(H, c, d, a, b, GET(4) + 0x6ed9eba1, 11)
127	STEP(H, b, c, d, a, GET(12) + 0x6ed9eba1, 15)
128	STEP(H, a, b, c, d, GET(2) + 0x6ed9eba1, 3)
129	STEP(H, d, a, b, c, GET(10) + 0x6ed9eba1, 9)
130	STEP(H, c, d, a, b, GET(6) + 0x6ed9eba1, 11)
131	STEP(H, b, c, d, a, GET(14) + 0x6ed9eba1, 15)
132	STEP(H, a, b, c, d, GET(1) + 0x6ed9eba1, 3)
133	STEP(H, d, a, b, c, GET(9) + 0x6ed9eba1, 9)
134	STEP(H, c, d, a, b, GET(5) + 0x6ed9eba1, 11)
135	STEP(H, b, c, d, a, GET(13) + 0x6ed9eba1, 15)
136	STEP(H, a, b, c, d, GET(3) + 0x6ed9eba1, 3)
137	STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
138	STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
139	STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)
140
141	a += saved_a;
142	b += saved_b;
143	c += saved_c;
144	d += saved_d;
145
146	ptr += 64;
147	} while (size -= 64);
148
149	ctx->a = a;
150	ctx->b = b;
151	ctx->c = c;
152	ctx->d = d;
153
154	return ptr;
155	}
156
157	void MD4_Init(MD4_CTX *ctx)
158	{
159	ctx->a = 0x67452301;
160	ctx->b = 0xefcdab89;
161	ctx->c = 0x98badcfe;
162	ctx->d = 0x10325476;
163
164	ctx->lo = 0;
165	ctx->hi = 0;
166	}
167
168	void MD4_Update(MD4_CTX ctx, void data, unsigned long size)
169	{
170	MD4_u32plus saved_lo;
171	unsigned long used, free;
172
173	saved_lo = ctx->lo;
174	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
175	ctx->hi++;
176	ctx->hi += size >> 29;
177
178	used = saved_lo & 0x3f;
179
180	if (used) {
181	free = 64 - used;
182
183	if (size < free) {
184	memcpy(&ctx->buffer[used], data, size);
185	return;
186	}
187
188	memcpy(&ctx->buffer[used], data, free);
189
190	data = (unsigned char *)data + free;
191	size -= free;
192	body(ctx, ctx->buffer, 64);
193	}
194
195	if (size >= 64) {
196	data = body(ctx, data, size & ~(unsigned long)0x3f);
197	size &= 0x3f;
198	}
199
200	memcpy(ctx->buffer, data, size);
201	}
202
203	void MD4_Final(unsigned char result, MD4_CTX ctx)
204	{
205	unsigned long used, free;
206
207	used = ctx->lo & 0x3f;
208
209	ctx->buffer[used++] = 0x80;
210
211	free = 64 - used;
212
213	if (free < 8) {
214	memset(&ctx->buffer[used], 0, free);
215	body(ctx, ctx->buffer, 64);
216	used = 0;
217	free = 64;
218	}
219
220	memset(&ctx->buffer[used], 0, free - 8);
221
222
223	ctx->lo <<= 3;
224	#ifndef ARCH_LITTLE_ENDIAN
225	ctx->buffer[56] = ctx->lo;
226	ctx->buffer[57] = ctx->lo >> 8;
227	ctx->buffer[58] = ctx->lo >> 16;
228	ctx->buffer[59] = ctx->lo >> 24;
229	ctx->buffer[60] = ctx->hi;
230	ctx->buffer[61] = ctx->hi >> 8;
231	ctx->buffer[62] = ctx->hi >> 16;
232	ctx->buffer[63] = ctx->hi >> 24;
233	#else
234	((unsigned long *)ctx->buffer)[14] = ctx->lo;
235	((unsigned long *)ctx->buffer)[15] = ctx->hi;
236	#endif
237
238	body(ctx, ctx->buffer, 64);
239
240	#ifndef ARCH_LITTLE_ENDIAN
241	result[0] = ctx->a;
242	result[1] = ctx->a >> 8;
243	result[2] = ctx->a >> 16;
244	result[3] = ctx->a >> 24;
245	result[4] = ctx->b;
246	result[5] = ctx->b >> 8;
247	result[6] = ctx->b >> 16;
248	result[7] = ctx->b >> 24;
249	result[8] = ctx->c;
250	result[9] = ctx->c >> 8;
251	result[10] = ctx->c >> 16;
252	result[11] = ctx->c >> 24;
253	result[12] = ctx->d;
254	result[13] = ctx->d >> 8;
255	result[14] = ctx->d >> 16;
256	result[15] = ctx->d >> 24;
257	#else
258	((unsigned long *)result)[0] = ctx->a;
259	((unsigned long *)result)[1] = ctx->b;
260	((unsigned long *)result)[2] = ctx->c;
261	((unsigned long *)result)[3] = ctx->d;
262	#endif
263
264	memset(ctx, 0, sizeof(*ctx));
265	}
266
267	//this function has been added by bartavelle at bandecon.com
268	void mdfour(unsigned char out, unsigned char in, int n)
269	{
270	MD4_CTX ctx;
271	MD4_Init(&ctx);
272	MD4_Update(&ctx, in, n);
273	MD4_Final(out, &ctx);
274	}
275
276	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md4.h (+39 lines)
	1	/*
	2	* This is an OpenSSL-compatible implementation of the RSA Data Security,
	3	* Inc. MD4 Message-Digest Algorithm (RFC 1320).
	4	*
	5	* Written by Solar Designer <solar at openwall.com> in 2005, and placed
	6	* in the public domain. See md4.c for more information.
	7	*/
	8
	9	#ifdef HAVE_OPENSSL
	10	#include <openssl/md4.h>
	11	#elif !defined(_MD4_H)
	12	#define _MD4_H
	13
	14	/* Any 32-bit or wider unsigned integer data type will do */
	15	typedef unsigned long MD4_u32plus;
	16
	17	typedef struct {
	18	MD4_u32plus lo, hi;
	19	MD4_u32plus a, b, c, d;
	20	unsigned char buffer[64];
	21	MD4_u32plus block[16];
	22	} MD4_CTX;
	23
	24	extern void MD4_Init(MD4_CTX *ctx);
	25	extern void MD4_Update(MD4_CTX ctx, void data, unsigned long size);
	26	extern void MD4_Final(unsigned char result, MD4_CTX ctx);
	27
	28	//added by bartavelle
	29	extern void mdfour(unsigned char out, unsigned char in, int n);
	30
	31	#if (MMX_COEF == 2)
	32	extern int mdfourmmx(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	33	#endif
	34
	35	#if (MMX_COEF == 4)
	36	extern int mdfoursse2(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	37	#endif
	38
	39	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md5-mmx.S (+307 lines)
		1	#include "arch.h"
		2
		3	// extern int mdfourmmx(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
		4
		5	#ifdef UNDERSCORES
		6	#define mdfivemmx _mdfivemmx
		7	#endif
		8	.globl mdfivemmx
		9	.globl mdfivemmx_noinit_sizeupdate
		10	.globl mdfivemmx_noinit_uniformsizeupdate
		11	.globl mdfivemmx_nosizeupdate
		12
		13	.data
		14	.align(16)
		15	#if (MMX_COEF == 2)
		16	const_init_a: ; .long 0x67452301 ; .long 0x67452301
		17	const_init_b: ; .long 0xefcdab89 ; .long 0xefcdab89
		18	const_init_c: ; .long 0x98badcfe ; .long 0x98badcfe
		19	const_init_d: ; .long 0x10325476 ; .long 0x10325476
		20	storea: ; .long 0 ; .long 0
		21	storeb: ; .long 0 ; .long 0
		22	storec: ; .long 0 ; .long 0
		23	stored: ; .long 0 ; .long 0
		24	#define REGMM0 %mm0
		25	#define REGMM1 %mm1
		26	#define REGMM2 %mm2
		27	#define REGMM3 %mm3
		28	#define REGMM4 %mm4
		29	#define REGMM5 %mm5
		30	#define REGMM6 %mm6
		31	#define REGMM7 %mm7
		32	#define MMXMOVE movq
		33	#include "stages_mmx_md5.S"
		34	#else
		35	const_init_a: ; .long 0x67452301 ; .long 0x67452301 ; .long 0x67452301 ; .long 0x67452301
		36	const_init_b: ; .long 0xefcdab89 ; .long 0xefcdab89 ; .long 0xefcdab89 ; .long 0xefcdab89
		37	const_init_c: ; .long 0x98badcfe ; .long 0x98badcfe ; .long 0x98badcfe ; .long 0x98badcfe
		38	const_init_d: ; .long 0x10325476 ; .long 0x10325476 ; .long 0x10325476 ; .long 0x10325476
		39	storea: ; .long 0 ; .long 0 ; .long 0 ; .long 0
		40	storeb: ; .long 0 ; .long 0 ; .long 0 ; .long 0
		41	storec: ; .long 0 ; .long 0 ; .long 0 ; .long 0
		42	stored: ; .long 0 ; .long 0 ; .long 0 ; .long 0
		43	#define REGMM0 %xmm0
		44	#define REGMM1 %xmm1
		45	#define REGMM2 %xmm2
		46	#define REGMM3 %xmm3
		47	#define REGMM4 %xmm4
		48	#define REGMM5 %xmm5
		49	#define REGMM6 %xmm6
		50	#define REGMM7 %xmm7
		51	#define MMXMOVE movapd
		52	#include "stages_sse2_md5.S"
		53	#endif
		54
		55
		56	#define ctxa REGMM0
		57	#define ctxb REGMM1
		58	#define ctxc REGMM2
		59	#define ctxd REGMM3
		60	#define tmp1 REGMM4
		61	#define tmp2 REGMM5
		62	#define tmp3 REGMM6
		63	#define tmp4 REGMM7
		64
65
66	//#define F_MMX(x, y, z) (z ^ (x & (y ^ z)))
67
68	#define F(x,y,z) \
69	MMXMOVE y, tmp1; \
70	pxor z, tmp1; \
71	pand x, tmp1; \
72	pxor z, tmp1
73
74	//#define G_MMX(x, y, z) (y ^ (z & (x ^ y)))
75
76	#define G(x,y,z) \
77	MMXMOVE y, tmp1; \
78	pxor x, tmp1; \
79	pand z, tmp1; \
80	pxor y, tmp1
81
82	//#define H_MMX(x, y, z) (x ^ y ^ z)
83	#define H(x,y,z) \
84	MMXMOVE x, tmp1; \
85	pxor y, tmp1; \
86	pxor z, tmp1
87
88	//#define I(x, y, z) (y ^ (x \| ~z))
89	#define I(x, y, z) \
90	MMXMOVE z, tmp1; \
91	pandn tmp4, tmp1; \
92	por x, tmp1; \
93	pxor y, tmp1;
94
95
96	//#define STEP_MMX(f, a, b, c, d, x, s) \
97	// (a) += f((b), (c), (d)) + (x); \
98	// (a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s))));
99
100	//#define STEP(f, a, b, c, d, x, t, s) \
101	// (a) += f((b), (c), (d)) + (x) + (t); \
102	// (a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s)))); \
103	// (a) += (b);
104
105
106	#define STEP(f, a, b, c, d, x, t, s) \
107	f(b, c, d); \
108	paddd (x4MMX_COEF)(%edx), tmp1; \
109	paddd t, a; \
110	paddd tmp1, a; \
111	MMXMOVE a, tmp3; \
112	psrld $(32-s), tmp3; \
113	pslld $s, a; \
114	por tmp3, a; \
115	paddd b, a
116
117	#define STEPD(f, a, b, c, d, x, t, s) \
118	f(b, c, d); \
119	paddd (x4MMX_COEF)(%edx), tmp1; \
120	paddd t, a; \
121	paddd tmp1, a; \
122	MMXMOVE a, tmp3; \
123	psrld $(32-s), tmp3; \
124	pslld $s, a; \
125	por tmp3, a; \
126	paddd b, a
127
128
129	.text
130	/*
131	* Try to do some asm md4 w/ mmx
132	* %eax ptr -> out
133	* %edx ptr -> in
134	* %ecx n
135	*/
136
137	init:
138	MMXMOVE const_init_a, ctxa
139	MMXMOVE const_init_b, ctxb
140	MMXMOVE const_init_c, ctxc
141	MMXMOVE const_init_d, ctxd
142	ret;
143
144	sizeupdate:
145	#if (MMX_COEF == 2)
146	shl $3, %ecx
147	mov %ecx, %ebx
148	and $0xffff, %ecx
149	shrl $16, %ebx
150	mov %ecx, (144MMX_COEF)(%edx)
151	mov %ebx, (144MMX_COEF+4)(%edx)
152	#else
153	mov %ecx, %ebx
154	shr $8, %ecx
155	and $0xff, %ebx
156	shl $3, %ebx
157	mov %ebx, (14*16)(%edx)
158
159	mov %ecx, %ebx
160	shr $8, %ecx
161	and $0xff, %ebx
162	shl $3, %ebx
163	mov %ebx, (14*16+4)(%edx)
164
165	mov %ecx, %ebx
166	shr $8, %ecx
167	and $0xff, %ebx
168	shl $3, %ebx
169	mov %ebx, (14*16+8)(%edx)
170
171	and $0xff, %ecx
172	shl $3, %ecx
173	mov %ecx, (14*16+12)(%edx)
174	#endif
175	ret
176
177	uniformsizeupdate:
178	shl $3, %ecx
179	mov %ecx, (144MMX_COEF)(%edx)
180	mov %ecx, (144MMX_COEF+4)(%edx)
181	#if (MMX_COEF == 4)
182	mov %ecx, (144MMX_COEF+8)(%edx)
183	mov %ecx, (144MMX_COEF+12)(%edx)
184	#endif
185	ret
186
187	//entry points
188	mdfivemmx_noinit_sizeupdate:
189	pusha
190	call sizeupdate
191	jmp mdfivemmx_noinit
192
193	mdfivemmx_noinit_uniformsizeupdate:
194	pusha
195	call uniformsizeupdate
196	jmp mdfivemmx_noinit
197
198	mdfivemmx:
199	pusha
200	call sizeupdate
201	call init
202	jmp mdfivemmx_noinit
203
204	mdfivemmx_nosizeupdate:
205	pusha
206	call init
207	jmp mdfivemmx_noinit
208	//end entry points
209
210	mdfivemmx_noinit:
211	pcmpeqd tmp4, tmp4;
212	MMXMOVE ctxa, storea
213	MMXMOVE ctxb, storeb
214	MMXMOVE ctxc, storec
215	MMXMOVE ctxd, stored
216
217	STEP(F, ctxa, ctxb, ctxc, ctxd, 0, const_stage_1, 7)
218	STEP(F, ctxd, ctxa, ctxb, ctxc, 1, const_stage_2, 12)
219	STEP(F, ctxc, ctxd, ctxa, ctxb, 2, const_stage_3, 17)
220	STEP(F, ctxb, ctxc, ctxd, ctxa, 3, const_stage_4, 22)
221	STEP(F, ctxa, ctxb, ctxc, ctxd, 4, const_stage_5, 7)
222	STEP(F, ctxd, ctxa, ctxb, ctxc, 5, const_stage_6, 12)
223	STEP(F, ctxc, ctxd, ctxa, ctxb, 6, const_stage_7, 17)
224	STEP(F, ctxb, ctxc, ctxd, ctxa, 7, const_stage_8, 22)
225	STEP(F, ctxa, ctxb, ctxc, ctxd, 8, const_stage_9, 7)
226	STEP(F, ctxd, ctxa, ctxb, ctxc, 9, const_stage_10, 12)
227	STEP(F, ctxc, ctxd, ctxa, ctxb, 10, const_stage_11, 17)
228	STEP(F, ctxb, ctxc, ctxd, ctxa, 11, const_stage_12, 22)
229	STEP(F, ctxa, ctxb, ctxc, ctxd, 12, const_stage_13, 7)
230	STEP(F, ctxd, ctxa, ctxb, ctxc, 13, const_stage_14, 12)
231	STEP(F, ctxc, ctxd, ctxa, ctxb, 14, const_stage_15, 17)
232	STEP(F, ctxb, ctxc, ctxd, ctxa, 15, const_stage_16, 22)
233
234	STEP(G, ctxa, ctxb, ctxc, ctxd, 1, const_stage_17, 5)
235	STEP(G, ctxd, ctxa, ctxb, ctxc, 6, const_stage_18, 9)
236	STEP(G, ctxc, ctxd, ctxa, ctxb, 11, const_stage_19, 14)
237	STEP(G, ctxb, ctxc, ctxd, ctxa, 0, const_stage_20, 20)
238	STEP(G, ctxa, ctxb, ctxc, ctxd, 5, const_stage_21, 5)
239	STEP(G, ctxd, ctxa, ctxb, ctxc, 10, const_stage_22, 9)
240	STEP(G, ctxc, ctxd, ctxa, ctxb, 15, const_stage_23, 14)
241	STEP(G, ctxb, ctxc, ctxd, ctxa, 4, const_stage_24, 20)
242	STEP(G, ctxa, ctxb, ctxc, ctxd, 9, const_stage_25, 5)
243	STEP(G, ctxd, ctxa, ctxb, ctxc, 14, const_stage_26, 9)
244	STEP(G, ctxc, ctxd, ctxa, ctxb, 3, const_stage_27, 14)
245	STEP(G, ctxb, ctxc, ctxd, ctxa, 8, const_stage_28, 20)
246	STEP(G, ctxa, ctxb, ctxc, ctxd, 13, const_stage_29, 5)
247	STEP(G, ctxd, ctxa, ctxb, ctxc, 2, const_stage_30, 9)
248	STEP(G, ctxc, ctxd, ctxa, ctxb, 7, const_stage_31, 14)
249	STEP(G, ctxb, ctxc, ctxd, ctxa, 12, const_stage_32, 20)
250
251	STEP(H, ctxa, ctxb, ctxc, ctxd, 5, const_stage_33, 4)
252	STEP(H, ctxd, ctxa, ctxb, ctxc, 8, const_stage_34, 11)
253	STEP(H, ctxc, ctxd, ctxa, ctxb, 11, const_stage_35, 16)
254	STEP(H, ctxb, ctxc, ctxd, ctxa, 14, const_stage_36, 23)
255	STEP(H, ctxa, ctxb, ctxc, ctxd, 1, const_stage_37, 4)
256	STEP(H, ctxd, ctxa, ctxb, ctxc, 4, const_stage_38, 11)
257	STEP(H, ctxc, ctxd, ctxa, ctxb, 7, const_stage_39, 16)
258	STEP(H, ctxb, ctxc, ctxd, ctxa, 10, const_stage_40, 23)
259	STEP(H, ctxa, ctxb, ctxc, ctxd, 13, const_stage_41, 4)
260	STEP(H, ctxd, ctxa, ctxb, ctxc, 0, const_stage_42, 11)
261	STEP(H, ctxc, ctxd, ctxa, ctxb, 3, const_stage_43, 16)
262	STEP(H, ctxb, ctxc, ctxd, ctxa, 6, const_stage_44, 23)
263	STEP(H, ctxa, ctxb, ctxc, ctxd, 9, const_stage_45, 4)
264	STEP(H, ctxd, ctxa, ctxb, ctxc, 12, const_stage_46, 11)
265	STEP(H, ctxc, ctxd, ctxa, ctxb, 15, const_stage_47, 16)
266	STEP(H, ctxb, ctxc, ctxd, ctxa, 2, const_stage_48, 23)
267
268	STEP(I, ctxa, ctxb, ctxc, ctxd, 0, const_stage_49, 6)
269	STEP(I, ctxd, ctxa, ctxb, ctxc, 7, const_stage_50, 10)
270	STEP(I, ctxc, ctxd, ctxa, ctxb, 14, const_stage_51, 15)
271	STEP(I, ctxb, ctxc, ctxd, ctxa, 5, const_stage_52, 21)
272	STEP(I, ctxa, ctxb, ctxc, ctxd, 12, const_stage_53, 6)
273	STEP(I, ctxd, ctxa, ctxb, ctxc, 3, const_stage_54, 10)
274	STEP(I, ctxc, ctxd, ctxa, ctxb, 10, const_stage_55, 15)
275	STEP(I, ctxb, ctxc, ctxd, ctxa, 1, const_stage_56, 21)
276	STEP(I, ctxa, ctxb, ctxc, ctxd, 8, const_stage_57, 6)
277	STEP(I, ctxd, ctxa, ctxb, ctxc, 15, const_stage_58, 10)
278	STEP(I, ctxc, ctxd, ctxa, ctxb, 6, const_stage_59, 15)
279	STEP(I, ctxb, ctxc, ctxd, ctxa, 13, const_stage_60, 21)
280	STEP(I, ctxa, ctxb, ctxc, ctxd, 4, const_stage_61, 6)
281	STEP(I, ctxd, ctxa, ctxb, ctxc, 11, const_stage_62, 10)
282	STEP(I, ctxc, ctxd, ctxa, ctxb, 2, const_stage_63, 15)
283	STEP(I, ctxb, ctxc, ctxd, ctxa, 9, const_stage_64, 21)
284
285	paddd storea, ctxa
286	paddd storeb, ctxb
287	paddd storec, ctxc
288	paddd stored, ctxd
289
290	MMXMOVE ctxa, 0(%eax)
291	MMXMOVE ctxa, storea
292	MMXMOVE ctxb, (4*MMX_COEF)(%eax)
293	MMXMOVE ctxb, storeb
294	MMXMOVE ctxc, (8*MMX_COEF)(%eax)
295	MMXMOVE ctxc, storec
296	MMXMOVE ctxd, (12*MMX_COEF)(%eax)
297	MMXMOVE ctxd, stored
298
299	popa
300
301	emms
302
303	ret
304
305	#ifdef __ELF__
306	.section .note.GNU-stack,"",@progbits
307	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md5.c (+274 lines)
		1	/*
		2	* This is an OpenSSL-compatible implementation of the RSA Data Security,
		3	* Inc. MD5 Message-Digest Algorithm.
		4	*
		5	* Written by Solar Designer <solar@openwall.com> in 2001, and placed in
		6	* the public domain. There's absolutely no warranty.
		7	*
		8	* This differs from Colin Plumb's older public domain implementation in
		9	* that no 32-bit integer data type is required, there's no compile-time
		10	* endianness configuration, and the function prototypes match OpenSSL's.
		11	* The primary goals are portability and ease of use.
		12	*
		13	* This implementation is meant to be fast, but not as fast as possible.
		14	* Some known optimizations are not included to reduce source code size
		15	* and avoid compile-time configuration.
		16	*/
		17
		18	#ifndef HAVE_OPENSSL
		19
		20	#include <string.h>
		21
		22	#include "md5.h"
		23
		24	/*
		25	* The basic MD5 functions.
		26	*
		27	* F is optimized compared to its RFC 1321 definition just like in Colin
		28	* Plumb's implementation.
		29	*/
		30	#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
		31	#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
		32	#define H(x, y, z) ((x) ^ (y) ^ (z))
		33	#define I(x, y, z) ((y) ^ ((x) \| ~(z)))
		34
		35	/*
		36	* The MD5 transformation for all four rounds.
		37	*/
		38	#define STEP(f, a, b, c, d, x, t, s) \
		39	(a) += f((b), (c), (d)) + (x) + (t); \
		40	(a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s)))); \
		41	(a) += (b);
		42
		43	/*
		44	* SET reads 4 input bytes in little-endian byte order and stores them
		45	* in a properly aligned word in host byte order.
		46	*
		47	* The check for little-endian architectures which tolerate unaligned
		48	* memory accesses is just an optimization. Nothing will break if it
		49	* doesn't work.
		50	*/
		51	#if defined(__i386__) \|\| defined(__vax__)
		52	#define SET(n) \
		53	((MD5_u32plus )&ptr[(n) * 4])
		54	#define GET(n) \
		55	SET(n)
		56	#else
		57	#define SET(n) \
		58	(ctx->block[(n)] = \
		59	(MD5_u32plus)ptr[(n) * 4] \| \
		60	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) \| \
		61	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) \| \
		62	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
		63	#define GET(n) \
		64	(ctx->block[(n)])
65	#endif
66
67	/*
68	* This processes one or more 64-byte data blocks, but does NOT update
69	* the bit counters. There're no alignment requirements.
70	*/
71	static void body(MD5_CTX ctx, void *data, unsigned long size)
72	{
73	unsigned char *ptr;
74	MD5_u32plus a, b, c, d;
75	MD5_u32plus saved_a, saved_b, saved_c, saved_d;
76
77	ptr = data;
78
79	a = ctx->a;
80	b = ctx->b;
81	c = ctx->c;
82	d = ctx->d;
83
84	do {
85	saved_a = a;
86	saved_b = b;
87	saved_c = c;
88	saved_d = d;
89
90	/* Round 1 */
91	STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
92	STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
93	STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
94	STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
95	STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
96	STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
97	STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
98	STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
99	STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
100	STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
101	STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
102	STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
103	STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
104	STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
105	STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
106	STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
107
108	/* Round 2 */
109	STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
110	STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
111	STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
112	STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
113	STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
114	STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
115	STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
116	STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
117	STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
118	STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
119	STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
120	STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
121	STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
122	STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
123	STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
124	STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
125
126	/* Round 3 */
127	STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
128	STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
129	STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
130	STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
131	STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
132	STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
133	STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
134	STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
135	STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
136	STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
137	STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
138	STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
139	STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
140	STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
141	STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
142	STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
143
144	/* Round 4 */
145	STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
146	STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
147	STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
148	STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
149	STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
150	STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
151	STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
152	STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
153	STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
154	STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
155	STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
156	STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
157	STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
158	STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
159	STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
160	STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
161
162	a += saved_a;
163	b += saved_b;
164	c += saved_c;
165	d += saved_d;
166
167	ptr += 64;
168	} while (size -= 64);
169
170	ctx->a = a;
171	ctx->b = b;
172	ctx->c = c;
173	ctx->d = d;
174
175	return ptr;
176	}
177
178	void MD5_Init(MD5_CTX *ctx)
179	{
180	ctx->a = 0x67452301;
181	ctx->b = 0xefcdab89;
182	ctx->c = 0x98badcfe;
183	ctx->d = 0x10325476;
184
185	ctx->lo = 0;
186	ctx->hi = 0;
187	}
188
189	void MD5_Update(MD5_CTX ctx, void data, unsigned long size)
190	{
191	MD5_u32plus saved_lo;
192	unsigned long used, free;
193
194	saved_lo = ctx->lo;
195	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
196	ctx->hi++;
197	ctx->hi += size >> 29;
198
199	used = saved_lo & 0x3f;
200
201	if (used) {
202	free = 64 - used;
203
204	if (size < free) {
205	memcpy(&ctx->buffer[used], data, size);
206	return;
207	}
208
209	memcpy(&ctx->buffer[used], data, free);
210	data = (unsigned char *)data + free;
211	size -= free;
212	body(ctx, ctx->buffer, 64);
213	}
214
215	if (size >= 64) {
216	data = body(ctx, data, size & ~(unsigned long)0x3f);
217	size &= 0x3f;
218	}
219
220	memcpy(ctx->buffer, data, size);
221	}
222
223	void MD5_Final(unsigned char result, MD5_CTX ctx)
224	{
225	unsigned long used, free;
226
227	used = ctx->lo & 0x3f;
228
229	ctx->buffer[used++] = 0x80;
230
231	free = 64 - used;
232
233	if (free < 8) {
234	memset(&ctx->buffer[used], 0, free);
235	body(ctx, ctx->buffer, 64);
236	used = 0;
237	free = 64;
238	}
239
240	memset(&ctx->buffer[used], 0, free - 8);
241
242	ctx->lo <<= 3;
243	ctx->buffer[56] = ctx->lo;
244	ctx->buffer[57] = ctx->lo >> 8;
245	ctx->buffer[58] = ctx->lo >> 16;
246	ctx->buffer[59] = ctx->lo >> 24;
247	ctx->buffer[60] = ctx->hi;
248	ctx->buffer[61] = ctx->hi >> 8;
249	ctx->buffer[62] = ctx->hi >> 16;
250	ctx->buffer[63] = ctx->hi >> 24;
251
252	body(ctx, ctx->buffer, 64);
253
254	result[0] = ctx->a;
255	result[1] = ctx->a >> 8;
256	result[2] = ctx->a >> 16;
257	result[3] = ctx->a >> 24;
258	result[4] = ctx->b;
259	result[5] = ctx->b >> 8;
260	result[6] = ctx->b >> 16;
261	result[7] = ctx->b >> 24;
262	result[8] = ctx->c;
263	result[9] = ctx->c >> 8;
264	result[10] = ctx->c >> 16;
265	result[11] = ctx->c >> 24;
266	result[12] = ctx->d;
267	result[13] = ctx->d >> 8;
268	result[14] = ctx->d >> 16;
269	result[15] = ctx->d >> 24;
270
271	memset(ctx, 0, sizeof(*ctx));
272	}
273
274	#endif

Line 0 Link Here

(-)john-1.7.0.1/src/md5.h (+35 lines)
	1	/*
	2	* This is an OpenSSL-compatible implementation of the RSA Data Security,
	3	* Inc. MD5 Message-Digest Algorithm.
	4	*
	5	* Written by Solar Designer <solar@openwall.com> in 2001, and placed in
	6	* the public domain. See md5.c for more information.
	7	*/
	8
	9	#ifdef HAVE_OPENSSL
	10	#include <openssl/md5.h>
	11	#elif !defined(_MD5_H)
	12	#define _MD5_H
	13
	14	/* Any 32-bit or wider unsigned integer data type will do */
	15	typedef unsigned long MD5_u32plus;
	16
	17	typedef struct {
	18	MD5_u32plus lo, hi;
	19	MD5_u32plus a, b, c, d;
	20	unsigned char buffer[64];
	21	MD5_u32plus block[16];
	22	} MD5_CTX;
	23
	24	extern void MD5_Init(MD5_CTX *ctx);
	25	extern void MD5_Update(MD5_CTX ctx, void data, unsigned long size);
	26	extern void MD5_Final(unsigned char result, MD5_CTX ctx);
	27
	28	#ifdef MMX_COEF
	29	extern int mdfivemmx(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	30	extern int mdfivemmx_nosizeupdate(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	31	extern int mdfivemmx_noinit_sizeupdate(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	32	extern int mdfivemmx_noinit_uniformsizeupdate(unsigned char out, unsigned char in, int n) __attribute__((regparm(3)));
	33	#endif
	34
	35	#endif