View difference between Paste ID: pGt34TcV and 20GVEtHN

-/* Changelog
+/* 		Pass finder for SHA256(SHA256(password)+salt))
  *Changelog
  * Version 1.00
  * Initial version
  * Version 1.01
  * Speeded up approximately 500 times.
  * Now instead of writing all passwords from dictionary and their hashes to result file
- * "Parole: password Hash: 5e884898da280410e88a656f8dc6292773603d0d6aabbdd625jd72nhkd1542d
+
  * e.g
  * User: [creeperdaddy] Pass: [123456]
  * Added status, shows amount of SHA256 operations, updates every tenth thousand operation.
  * Added Command line options -u [file with user name:salt:sha256] -p [dictionary] -r [result file]
  * Points out the problem, if no input files given.
  * Version 1.02
  * Multi threading support (Up to 8 cores)
  * Added delimiter option
- * Pass finder for SHA256(SHA256(password)+salt))
+ * Added skip option.
- * Input
+
- * SHATEST.exe -u dbdump.txt -p twitter-banned.txt -r twitter-banned.txt.res
+
- * 1. File containing Username:Salt:SHA256 of password
+ * Usage: SHADEC.exe -u userfile [-d delimiter] {-p passfile|-P passfile} -1|2|4|8
- * e.g creeperdaddy:633d06d3d95c64ac:349b5849410e88a67ce4fbd938b9e6f8ba53bd9a5167d9787cbfa2eeb520a1d1
+ * [-s skip_number] [-r resultfile [-o]]
- * 2. Dictionary
+ *      Pass finder for sha256(sha256(pass)+seed))
- * e.g twitter-banned.txt
+ *      User file format is username<delimiter>seed<delimiter>hash_as_hex_string
- * 3. Output file
+ *      Default delimiter ':' (can be changed by -d)
  *      Default output to stdout (if -r not specified)
  *      -1248 Limit core usage to 1/2/4/8. default - maximum available
  *      -s skip first nums of pass (to continue)
  *      -o overwrite output file (default - append)
  *      -u and either -p or -P parameters are mandatory
  *      -p loads pass into memory (program uses more memory)
  *      -P keep pass file open in time of calculation
  *
   *  FIPS-180-2 compliant SHA-256 implementation
  *
  *  Copyright (C) 2001-2003  Christophe Devine
  *
  *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 
 #include <omp.h>
 
 #include "sha256.h"
 
 #define GET_UINT32(n,b,i)                       \
 {                                               \
     (n) = ( (uint32) (b)[(i)    ] << 24 )       \
         | ( (uint32) (b)[(i) + 1] << 16 )       \
         | ( (uint32) (b)[(i) + 2] <<  8 )       \
         | ( (uint32) (b)[(i) + 3]       );      \
 }
 
 #define PUT_UINT32(n,b,i)                       \
 {                                               \
     (b)[(i)    ] = (uint8) ( (n) >> 24 );       \
     (b)[(i) + 1] = (uint8) ( (n) >> 16 );       \
     (b)[(i) + 2] = (uint8) ( (n) >>  8 );       \
     (b)[(i) + 3] = (uint8) ( (n)       );       \
 }
 
 void sha256_starts( sha256_context *ctx )
 {
     ctx->total[0] = 0;
     ctx->total[1] = 0;
 
     ctx->state[0] = 0x6A09E667;
     ctx->state[1] = 0xBB67AE85;
     ctx->state[2] = 0x3C6EF372;
     ctx->state[3] = 0xA54FF53A;
     ctx->state[4] = 0x510E527F;
     ctx->state[5] = 0x9B05688C;
     ctx->state[6] = 0x1F83D9AB;
     ctx->state[7] = 0x5BE0CD19;
 }
 
 void sha256_process( sha256_context *ctx, uint8 data[64] )
 {
     uint32 temp1, temp2, W[64];
     uint32 A, B, C, D, E, F, G, H;
 
     GET_UINT32( W[0],  data,  0 );
     GET_UINT32( W[1],  data,  4 );
     GET_UINT32( W[2],  data,  8 );
     GET_UINT32( W[3],  data, 12 );
     GET_UINT32( W[4],  data, 16 );
     GET_UINT32( W[5],  data, 20 );
     GET_UINT32( W[6],  data, 24 );
     GET_UINT32( W[7],  data, 28 );
     GET_UINT32( W[8],  data, 32 );
     GET_UINT32( W[9],  data, 36 );
     GET_UINT32( W[10], data, 40 );
     GET_UINT32( W[11], data, 44 );
     GET_UINT32( W[12], data, 48 );
     GET_UINT32( W[13], data, 52 );
     GET_UINT32( W[14], data, 56 );
     GET_UINT32( W[15], data, 60 );
 
 #define  SHR(x,n) ((x & 0xFFFFFFFF) >> n)
 #define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
 
 #define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
 #define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))
 
 #define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
 #define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
 
 #define F0(x,y,z) ((x & y) | (z & (x | y)))
 #define F1(x,y,z) (z ^ (x & (y ^ z)))
 
 #define R(t)                                    \
 (                                               \
     W[t] = S1(W[t -  2]) + W[t -  7] +          \
            S0(W[t - 15]) + W[t - 16]            \
 )
 
 #define P(a,b,c,d,e,f,g,h,x,K)                  \
 {                                               \
     temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
     temp2 = S2(a) + F0(a,b,c);                  \
     d += temp1; h = temp1 + temp2;              \
 }
 
     A = ctx->state[0];
     B = ctx->state[1];
     C = ctx->state[2];
     D = ctx->state[3];
     E = ctx->state[4];
     F = ctx->state[5];
     G = ctx->state[6];
     H = ctx->state[7];
 
     P( A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98 );
     P( H, A, B, C, D, E, F, G, W[ 1], 0x71374491 );
     P( G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF );
     P( F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5 );
     P( E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B );
     P( D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1 );
     P( C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4 );
     P( B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5 );
     P( A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98 );
     P( H, A, B, C, D, E, F, G, W[ 9], 0x12835B01 );
     P( G, H, A, B, C, D, E, F, W[10], 0x243185BE );
     P( F, G, H, A, B, C, D, E, W[11], 0x550C7DC3 );
     P( E, F, G, H, A, B, C, D, W[12], 0x72BE5D74 );
     P( D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE );
     P( C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7 );
     P( B, C, D, E, F, G, H, A, W[15], 0xC19BF174 );
     P( A, B, C, D, E, F, G, H, R(16), 0xE49B69C1 );
     P( H, A, B, C, D, E, F, G, R(17), 0xEFBE4786 );
     P( G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6 );
     P( F, G, H, A, B, C, D, E, R(19), 0x240CA1CC );
     P( E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F );
     P( D, E, F, G, H, A, B, C, R(21), 0x4A7484AA );
     P( C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC );
     P( B, C, D, E, F, G, H, A, R(23), 0x76F988DA );
     P( A, B, C, D, E, F, G, H, R(24), 0x983E5152 );
     P( H, A, B, C, D, E, F, G, R(25), 0xA831C66D );
     P( G, H, A, B, C, D, E, F, R(26), 0xB00327C8 );
     P( F, G, H, A, B, C, D, E, R(27), 0xBF597FC7 );
     P( E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3 );
     P( D, E, F, G, H, A, B, C, R(29), 0xD5A79147 );
     P( C, D, E, F, G, H, A, B, R(30), 0x06CA6351 );
     P( B, C, D, E, F, G, H, A, R(31), 0x14292967 );
     P( A, B, C, D, E, F, G, H, R(32), 0x27B70A85 );
     P( H, A, B, C, D, E, F, G, R(33), 0x2E1B2138 );
     P( G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC );
     P( F, G, H, A, B, C, D, E, R(35), 0x53380D13 );
     P( E, F, G, H, A, B, C, D, R(36), 0x650A7354 );
     P( D, E, F, G, H, A, B, C, R(37), 0x766A0ABB );
     P( C, D, E, F, G, H, A, B, R(38), 0x81C2C92E );
     P( B, C, D, E, F, G, H, A, R(39), 0x92722C85 );
     P( A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1 );
     P( H, A, B, C, D, E, F, G, R(41), 0xA81A664B );
     P( G, H, A, B, C, D, E, F, R(42), 0xC24B8B70 );
     P( F, G, H, A, B, C, D, E, R(43), 0xC76C51A3 );
     P( E, F, G, H, A, B, C, D, R(44), 0xD192E819 );
     P( D, E, F, G, H, A, B, C, R(45), 0xD6990624 );
     P( C, D, E, F, G, H, A, B, R(46), 0xF40E3585 );
     P( B, C, D, E, F, G, H, A, R(47), 0x106AA070 );
     P( A, B, C, D, E, F, G, H, R(48), 0x19A4C116 );
     P( H, A, B, C, D, E, F, G, R(49), 0x1E376C08 );
     P( G, H, A, B, C, D, E, F, R(50), 0x2748774C );
     P( F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5 );
     P( E, F, G, H, A, B, C, D, R(52), 0x391C0CB3 );
     P( D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A );
     P( C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F );
     P( B, C, D, E, F, G, H, A, R(55), 0x682E6FF3 );
     P( A, B, C, D, E, F, G, H, R(56), 0x748F82EE );
     P( H, A, B, C, D, E, F, G, R(57), 0x78A5636F );
     P( G, H, A, B, C, D, E, F, R(58), 0x84C87814 );
     P( F, G, H, A, B, C, D, E, R(59), 0x8CC70208 );
     P( E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA );
     P( D, E, F, G, H, A, B, C, R(61), 0xA4506CEB );
     P( C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7 );
     P( B, C, D, E, F, G, H, A, R(63), 0xC67178F2 );
 
     ctx->state[0] += A;
     ctx->state[1] += B;
     ctx->state[2] += C;
     ctx->state[3] += D;
     ctx->state[4] += E;
     ctx->state[5] += F;
     ctx->state[6] += G;
     ctx->state[7] += H;
 }
 
 void sha256_update( sha256_context *ctx, uint8 *input, uint32 length )
 {
     uint32 left, fill;
 
     if( ! length ) return;
 
     left = ctx->total[0] & 0x3F;
     fill = 64 - left;
 
     ctx->total[0] += length;
     ctx->total[0] &= 0xFFFFFFFF;
 
     if( ctx->total[0] < length )
         ctx->total[1]++;
 
     if( left && length >= fill )
     {
         memcpy( (void *) (ctx->buffer + left),
                 (void *) input, fill );
         sha256_process( ctx, ctx->buffer );
         length -= fill;
         input  += fill;
         left = 0;
     }
 
     while( length >= 64 )
     {
         sha256_process( ctx, input );
         length -= 64;
         input  += 64;
     }
 
     if( length )
     {
         memcpy( (void *) (ctx->buffer + left),
                 (void *) input, length );
     }
 }
 
 static uint8 sha256_padding[64] =
 {
  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
 void sha256_finish( sha256_context *ctx, uint8 digest[32] )
 {
     uint32 last, padn;
     uint32 high, low;
     uint8 msglen[8];
 
     high = ( ctx->total[0] >> 29 )
          | ( ctx->total[1] <<  3 );
     low  = ( ctx->total[0] <<  3 );
 
     PUT_UINT32( high, msglen, 0 );
     PUT_UINT32( low,  msglen, 4 );
 
     last = ctx->total[0] & 0x3F;
     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
 
     sha256_update( ctx, sha256_padding, padn );
     sha256_update( ctx, msglen, 8 );
 
     PUT_UINT32( ctx->state[0], digest,  0 );
-/*
+
- * those are the standard FIPS-180-2 test vectors
+
     PUT_UINT32( ctx->state[3], digest, 12 );
-/*
+
-static char *msg[] =
+
     PUT_UINT32( ctx->state[6], digest, 24 );
-    "abc",
+
-    "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+
-    NULL
+
 typedef struct ufilest {
 	char* uname;
-static char *val[] =
+
 	char* hash;
-    "ba7816bf8f01cfea414140de5dae2223" \
+	char  found;
-    "b00361a396177a9cb410ff61f20015ad",
+
-    "248d6a61d20638b8e5c026930c3e6039" \
+
-    "a33ce45964ff2167f6ecedd419db06c1",
+
-    "cdc76e5c9914fb9281a1c7e284d73e67" \
+
-    "f1809a48a497200e046d39ccc7112cd0"
+
 	char* pass;
-*/
+
 	struct pfilest *next;
 } pfilest;
 
 #define HELPTEXT "Usage: %s -u userfile [-d delimiter] {-p passfile|-P passfile} -1|2|4|8 [-s skip_number] [-r resultfile [-o]]\n" \
 				 "\tPass finder for sha256(sha256(pass)+seed))\n" \
 				 "\tUser file format is username<delimiter>seed<delimiter>hash_as_hex_string\n" \
 				 "\tDefault delimiter \':\' (can be changed by -d)\n" \
                  "\tDefault output to stdout (if -r not specified)\n" \
 				 "\t-1248 Limit core usage to 1/2/4/8. default - maximum available\n" \
 				 "\t-s skip first nums of pass (to continue)\n" \
 				 "\t-o overwrite output file (default - append)\n" \
 				 "\t-u and either -p or -P parameters are mandatory\n" \
 				 "\t-p loads pass into memory (program use more memory)\n" \
 				 "\t-P keep pass file open in time of calculation\n"
 
 
 unsigned char ctox(char c){
 	unsigned char rc = 0;
 	if( c >= '0' && c <= '9' ) rc = c - '0';
 	else if (c >= 'A' && c <= 'F') rc = c - 'A' + 10;
 	else if (c >= 'a' && c <= 'f') rc = c - 'a' + 10;
 	return rc;
 }
 
 unsigned char stox(char *s, unsigned char (*t)[32]){
 	int i;
-	return 0;
+
 		(*t)[i] = ctox(*(s+i*2))<<4 | ctox(*(s+i*2+1));
 	return 0;
 }
 
 void print_help(char *arg){
      fprintf(stderr,HELPTEXT,arg);
 }
 
 int insert_u(char * buffer, struct ufilest ** cu, struct ufilest ** pu, char divider ){
-   		perror("Malloc error for user file");
+
 	char *pt,*pb;
 	size_t msize;
 	msize = sizeof(struct ufilest);
   	*cu = (struct ufilest *)malloc(msize);
    	if ( ! *cu ) {
    		perror("Malloc error for user file");
    		// Delete structure
    		return(255);
    	}
    	pb = buffer;
 	pt = &tmp[0];
 	while( *pb && *pb != divider ) *(pt++) = *(pb++); *pt = '\0'; pb++;
 	msize = (strlen(tmp)+1)*sizeof(char);
 	(*cu)->uname = (char *) malloc(msize);
 	strcpy((*cu)->uname,tmp);
 	pt = &tmp[0];
 	while( *pb && *pb != divider ) *(pt++) = *(pb++); *pt = '\0'; pb++;
 	msize = (strlen(tmp)+1)*sizeof(char);
 	(*cu)->seed = (char *) malloc(msize);
 	strcpy((*cu)->seed,tmp);
 	pt = &tmp[0];
 	while( *pb && *pb != divider ) *(pt++) = *(pb++); *pt = '\0'; pb++;
 	msize = (strlen(tmp)+1)*sizeof(char);
 	(*cu)->hash = (char *) malloc(msize);
 	strcpy((*cu)->hash,tmp);
 	stox(tmp,&((*cu)->sha256));
 	(*cu)->found = 0;
 	(*cu)->next = NULL;
 	if( (*pu) ) (*pu)->next = *cu;
 	return 0;
 }
 
 
 int insert_p(char * buffer, struct pfilest ** cp, struct pfilest ** pp ){
-
+
 	char tmp[1000];
 	char *pt,*pb;
 	size_t msize;
-   		perror("Malloc error for user file");
+
     unsigned char sha256[32];
 
 
 	msize = sizeof(struct pfilest);
   	*cp = (struct pfilest *)malloc(msize);
    	if ( ! *cp ) {
    		perror("Malloc error for user file");
    		// Delete structure
    		return(255);
-
+
    	pb = buffer;
 	pt = &tmp[0];
 	while( *pb ) *(pt++) = *(pb++); *pt = '\0'; pb++;
 	msize = (strlen(tmp)+1)*sizeof(char);
 	(*cp)->pass = (char *) malloc(msize);
 	strcpy((*cp)->pass,tmp);
 
     sha256_starts( &ct2 );
     sha256_update( &ct2, (uint8 *) buffer, strlen(buffer) );
     sha256_finish( &ct2, sha256 );
 
     msize = 65*sizeof(char);
 	(*cp)->hash = (char *) malloc(msize);
-void myprint(int redir, FILE * fu, char * buffer){
+
-	if( redir ) {
+
-	   fprintf(fu,buffer);
+
-	} else {
+
-	   fprintf(stdout,buffer);
+
 }
 
 inline void myprint(int redir, FILE * fu, char * buffer){
     if (redir == 1) fprintf(fu,buffer);
 	else printf(buffer);
 }
 
-    FILE *fu;
+inline void print_progress(int thr,unsigned long * cnt2){
-    int i, j, c;
+	switch(thr){
-    char output[255];
+		case 1: printf("Passwords: %09lu\r",*(cnt2)); break;
   		case 2: printf("Passwords: %09lu %09lu\r",*(cnt2),*(cnt2+1)); break;
-    unsigned char buf[1000];
+  		case 4: printf("Passwords: %09lu %09lu %09lu %09lu\r",*(cnt2),*(cnt2+1),*(cnt2+2),*(cnt2+3)); break;
-    unsigned char sha256sum[32];
+  		case 8: printf("Passwords: %09lu %09lu %09lu %09lu %09lu %09lu %09lu %09lu\r",*(cnt2),*(cnt2+1),*(cnt2+2),*(cnt2+3),*(cnt2+4),*(cnt2+5),*(cnt2+6),*(cnt2+7)); break;
-    unsigned long cnt2;
+
 }
-    char inputline[1000];
+
-    char separator = ':';
+void process_memory_pass(int tid,int numt,struct pfilest * sp,struct pfilest * cp,struct pfilest * pp,struct ufilest * su,struct ufilest * cu,struct ufilest * pu,unsigned long *cnt2, FILE *fu, int c){
 	int i,j;
 	char output[160],buf[160];
-    struct pfilest *cp = NULL, *pp = NULL, *sp = NULL;
+	unsigned char sha256sum[32];
     sha256_context ctx;
-    int digit_optind = 0;
+   	cp = sp;
    	while( cp ){
-    int this_option_optind;
+  		cu = su;
   		++(*(cnt2+tid));
-    while ( (c = getopt(argc, argv, "p:P:u:U:r:R:")) != -1) {
+  		if( tid == 0 || (*cnt2) % 1000 == 0 ){
-        this_option_optind = optind ? optind : 1;
+  			print_progress(numt,cnt2);
   		}
     	while( cu ){
-        case 'P':
+  	        if( ! cu->found ){
        	        strcpy(buf,cp->hash);
            	    strcat(buf,cu->seed);
                	sha256_starts( &ctx );
-        case 'R':
+                sha256_update( &ctx, (uint8 *) buf, strlen(buf) );
    	            sha256_finish( &ctx, sha256sum );
            	    j = 1;
                	for( i = 0; i < 32; i++ )
-        case 'U':
+                   	if( cu->sha256[i] != sha256sum[i] ) {
                        	j = 0; break;
                 }
    	            if( j ){
-        	printf("Usage: %s -u userfile -p passfile [-r resultfile]\n\tPass finder for sha256(sha256(pass)+seed))\n\tDefault output to stdout (if -r not specified)",argv[0]);
+       	            sprintf(output,"User: [%s] Pass: [%s]\n",cu->uname,cp->pass);
            	        myprint(c,fu,output);
                	    cu->found = 1;
                	}
               	}
     			cu = cu->next;
     		}
-    if( argc < 3 ){
+    		cp = cp->next;
-        printf("Usage: %s -u userfile -p passfile [-r resultfile]\n\tPass finder for sha256(sha256(pass)+seed))\n\tDefault output to stdout (if -r not specified)",argv[0]);
+
-        exit(EXIT_FAILURE);
+	    cp = sp;
     	while( cp ){
-    if ( access(popt,R_OK) ) { printf("RO access password file %s - denied of file doesn\'t exist\n",popt); exit(EXIT_FAILURE); }
+	    	pp = cp;
-    if ( access(uopt,R_OK) ) { printf("RO access user file %s - denied of file doesn\'t exist\n",uopt); exit(EXIT_FAILURE); }
+    		cp = cp->next;
 	    	free(pp->hash);
     		free(pp->pass);
-    while (fgets(inputline, 1000, fu) != NULL) {
+    		free(pp);
-    	i = strlen(inputline)-1;
+
-    	while( i && ( inputline[i] == '\n' || inputline[i] == '\r' ) ) inputline[i--] = '\0';
+
-    	i = 0;
+
 
-    	insert_u(inputline,&cu,&pu,separator);
+void process_disk_pass(int tid,int numt,int bst, char * inputline, struct ufilest * su,struct ufilest * cu,struct ufilest * pu,unsigned long *cnt2, FILE *fu, int c){
 	int i,j;
 	char cph[81],output[160];
 	unsigned char sha256sum[32];
-
+
-	printf("************ User list\n");
+
 	if( bst ){
  		i = strlen(inputline)-1;
    		while( i && ( inputline[i] == '\n' || inputline[i] == '\r' ) ) inputline[i--] = '\0';
   		++(*(cnt2+tid));
   		if( tid == 0 || (*cnt2) % 1000 == 0 ){
-
+  			print_progress(numt,cnt2);
 			}
-    if( ! (fu = fopen(popt,"rt")) ){ perror("Can\'t open password file\n"); 	exit(EXIT_FAILURE); }
+   		sha256_starts( &ctx );
-    while (fgets(inputline, 1000, fu) != NULL) {
+   		sha256_update( &ctx, (uint8 *) inputline, strlen(inputline) );
-    	i = strlen(inputline)-1;
+   		sha256_finish( &ctx, sha256sum );
-    	while( i && ( inputline[i] == '\n' || inputline[i] == '\r' ) ) inputline[i--] = '\0';
+   		for( i = 0; i < 32; i++ ) sprintf( &cph[i*2], "%02x", sha256sum[i] );
-    	i = 0;
+   		cph[64] = '\0';
-    	pp = cp;
+   		cu = su;
-    	insert_p(inputline,&cp,&pp);
+
-    	if( ! sp ) sp = cp;
+   	        if( ! cu->found ){
    	        	strcpy(&cph[64],cu->seed);
-	fclose(fu); fu = NULL;
+               	sha256_starts( &ctx );
                 sha256_update( &ctx, (uint8 *) cph, strlen(cph) );
-	printf("************ Pass list\n");
+   	            sha256_finish( &ctx, sha256sum );
            	    j = 1;
                	for( i = 0; i < 32; i++ )
                    	if( cu->sha256[i] != sha256sum[i] ) {
                        	j = 0; break;
-//    }
+                    }
    	            if( j ){
        	            sprintf(output,"User: [%s] Pass: [%s]\n",cu->uname,inputline);
-  		if( ! (fu = fopen(ropt,"w")) ) {  perror("Can\'t open result file\n"); 	exit(EXIT_FAILURE); }
+           	        myprint(c,fu,output);
                	    cu->found = 1;
-  	c = fu ? 1 : 0;
+                   	}
                	}
-    myprint(c,fu,"Start\n");
+   			cu = cu->next;
    		}
-    cp = sp;
+   }
-    while( cp ){
+
 }
-    	cu = su;
+
 
-       		strcpy(buf,cp->hash);
+
-    		strcat(buf,cu->seed);
+
-    		sha256_starts( &ctx );
+    FILE *fu,*fp;
-    		sha256_update( &ctx, (uint8 *) buf, strlen(buf) );
+    int i, j, c ;
-    		sha256_finish( &ctx, sha256sum );
+    unsigned long cnt2,cnt2p[8],skipline = 0;
-    		if( (++cnt2 % 10000) == 0 ) printf("%lu\r",cnt2);
+
-    		j = 1;
+
-    		for( i = 0; i < 32; i++ )
+    time_t stt,ent;
-    		   if( cu->sha256[i] != sha256sum[i] ) {
+
-    		   	  j = 0; break;
+    int tid,maxtid,maxpar = 8;
-    		   }
+    int overwrite = 0;
-    		if( j ){
+
-    		   sprintf(output,"User: [%s] Pass: [%s]\n",cu->uname,cp->pass);
+    char inputline[8][1000];
-    		   myprint(c,fu,output);
+    char separator = ':',bst[8];
 
-    		cu = cu->next;
+
     struct pfilest *cp[8], *pp[8], *sp[8];
-    	cp = cp->next;
+
     int ptype = 0;
     char *ropt = 0, *popt = 0, *uopt = 0;
 
-    cp = sp;
+    for(i = 0; i < 8; i++ ){ cp[i] = NULL; sp[i] = NULL; pp[i] = NULL; cnt2p[i] = 0; }
-    while( cp ){
+
-	    pp = cp;
+    while ( (c = getopt(argc, argv, "p:P:u:r:R:1248s:od:")) != -1) {
-    	cp = cp->next;
+
-    	free(pp->hash);
+        case '1':
-    	free(pp->pass);
+		case '2':
-    	free(pp);
+		case '4':
 		case '8':
 			maxpar = c - '0';
 			break;
 		case 'o':
 		    overwrite = 1;
 		    break;
         case 'p':
             popt = optarg;
             ptype = 1;
             break;
         case 'P':
-
+
-
+            ptype = 2;
-    if( c )fclose(fu);
+
-    system("PAUSE");
+
         case 'R':
             ropt = optarg;
             break;
         case 'u':
             uopt = optarg;
             break;
         case 's':
             skipline = atol(optarg);
             break;
         case 'd':
             separator = optarg[0];
             break;
         case '?':
         	print_help(argv[0]);
         	return(0);
             break;
         default:
             printf ("?? getopt returned character code 0x%x ??\n", c);
         }
     }
     if( argc < 3 || uopt == NULL || popt == NULL){
         print_help(argv[0]);
         exit(EXIT_FAILURE);
     }
 
     maxtid = omp_get_max_threads();
     printf("\nMaximum available threads detected: %2d\n",maxtid);
     if( maxtid > 8 ) maxtid = 8;
     if( maxpar < maxtid ) maxtid = maxpar;
     omp_set_num_threads(maxtid);
     printf("Maximum number of threads for use: %2d\n",maxtid);
 
     if ( access(popt,R_OK) ) { fprintf(stderr,"RO access password file %s - denied of file doesn\'t exist\n",popt); exit(EXIT_FAILURE); }
     if ( access(uopt,R_OK) ) { fprintf(stderr,"RO access user file %s - denied of file doesn\'t exist\n",uopt); exit(EXIT_FAILURE); }
 
     if( ! (fu = fopen(uopt,"rt")) ){ perror("Can\'t open user file\n"); 	exit(EXIT_FAILURE); }
     cnt2  = 0;
     stt = time(NULL);
     while (fgets(inputline[0], 1000, fu) != NULL) {
     	i = strlen(inputline[0])-1;
     	while( i && ( inputline[0][i] == '\n' || inputline[0][i] == '\r' ) ) inputline[0][i--] = '\0';
     	i = 0; if( (++cnt2 % 100) == 0 )printf("Users: %9ld\r",cnt2);
     	pu = cu;
     	insert_u(inputline[0],&cu,&pu,separator);
     	if( ! su ) su = cu;
 	}
 	fclose(fu);
     ent = time(NULL);
 	printf("\nTotal %ld users (%ld seconds)\n",cnt2,ent-stt);
 //	cu = su;
 //	while( cu ) {
 //	  printf("User: %s Seed: %s Hash %s Hash2 %02x %02x\n",cu->uname,cu->seed,cu->hash,cu->sha256[0], cu->sha256[1]);
 //	  cu = cu->next;
 //    }
 
 
     if( ! (fp = fopen(popt,"rt")) ){ perror("Can\'t open password file\n"); 	exit(EXIT_FAILURE); }
 
     if( ptype == 1 ){
     	cnt2 = 0;
     	j = 0;
 	    stt = time(NULL);
 	    if( skipline > 0){
 	        while( skipline >= ++cnt2 && fgets(inputline[0], 1000, fp) != NULL );
 	        printf("First %ld paswords skipped\n",cnt2-1);
 	        cnt2 = 0;
 	        }
     	while (fgets(inputline[0], 1000, fp) != NULL) {
     		i = strlen(inputline[0])-1;
     		while( i && ( inputline[0][i] == '\n' || inputline[0][i] == '\r' ) ) inputline[0][i--] = '\0';
 			if( (++cnt2 % 100) == 0 )printf("Passwords read: %9ld\r",cnt2);
     		pp[j] = cp[j];
     		insert_p(inputline[0],&cp[j],&pp[j]);
     		if( ! sp[j] ) sp[j] = cp[j];
     		++j; j %= 8;
 		}
 		fclose(fp); fp = NULL;
         ent = time(NULL);
 	    printf("\nTotal %ld passwords loaded (%ld seconds)\n",cnt2,ent-stt);
 	}
 
 //	cp = sp;
 //	while( cp ) {
 //	  printf("Pass: %s Hash %s\n",cp->pass,cp->hash);
 //	  cp = cp->next;
 //    }
 
     if( ropt ){
     	if( overwrite ){
     		if( ! (fu = fopen(ropt,"w")) ) {  perror("Can\'t open result file\n"); 	exit(EXIT_FAILURE); }
     	} else {
     		if( ! (fu = fopen(ropt,"a")) ) {  perror("Can\'t open result file\n"); 	exit(EXIT_FAILURE); }
     	}
   	}
   	c = ropt ? 1 : 0;
 
     printf("Start processes\n");
     cnt2 = 0;
     stt = time(NULL);
     if( ptype == 1 ){
     	#pragma omp parallel default(none) shared(sp,cp,pp,su,cu,pu,fu,c,cnt2p,maxtid) private (tid)
     	{
     		tid = omp_get_thread_num();
 	    	#pragma omp sections
 			{
     			#pragma omp section
 	    		{ process_memory_pass(tid,maxtid,sp[0],cp[0],pp[0],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
     			{ process_memory_pass(tid,maxtid,sp[1],cp[1],pp[1],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
 	    		{ process_memory_pass(tid,maxtid,sp[2],cp[2],pp[2],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
     			{ process_memory_pass(tid,maxtid,sp[3],cp[3],pp[3],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
 	    		{ process_memory_pass(tid,maxtid,sp[4],cp[4],pp[4],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
     			{ process_memory_pass(tid,maxtid,sp[5],cp[5],pp[5],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
 	    		{ process_memory_pass(tid,maxtid,sp[6],cp[6],pp[6],su,cu,pu,cnt2p,fu,c); }
     			#pragma omp section
     			{ process_memory_pass(tid,maxtid,sp[7],cp[7],pp[7],su,cu,pu,cnt2p,fu,c); }
 	    	}
 	    }
 	}
     else if ( ptype == 2 ){
     	cnt2 = 0;
 	    if( skipline > 0){
 	        while( skipline >= ++cnt2 && fgets(inputline[0], 1000, fp) != NULL );
 	        printf("First %ld paswords skipped\n",cnt2-1);
 	        cnt2 = 0;
 	        }
     	while( feof(fp) == 0 ){
     		for( i = 0; i<8; i++ ) bst[i] = (int)fgets(inputline[i], 1000, fp);
 	    	#pragma omp parallel default(none) shared(su,cu,pu,fu,c,cnt2p,maxtid,bst,inputline) private (tid)
     			{
     			tid = omp_get_thread_num();
 	    		#pragma omp sections
 	    			{
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[0],inputline[0], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[1],inputline[1], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[2],inputline[2], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[3],inputline[3], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[4],inputline[4], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[5],inputline[5], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[6],inputline[6], su,cu,pu,cnt2p,fu,c); }
 	    			#pragma omp section
 	    			{ process_disk_pass(tid,maxtid,bst[7],inputline[7], su,cu,pu,cnt2p,fu,c); }
     				}
     			}
 
     	}
     	fclose(fp);
 
     }
     ent = time(NULL);
 	print_progress(maxtid,cnt2p);
    	printf("\nTotal %ld passwords processed (%ld seconds)\n",cnt2p[0]+cnt2p[1]+cnt2p[2]+cnt2p[3]+cnt2p[4]+cnt2p[5]+cnt2p[6]+cnt2p[7]+cnt2,ent-stt);
 
     cu = su;
     while( cu ){
     	pu = cu;
     	cu = cu->next;
     	free(pu->hash);
     	free(pu->seed);
     	free(pu->uname);
     	free(pu);
     }
 
     printf("End process                      \n");
     if( c )fclose(fu);
 //    system("PAUSE");
     return( 0 );
 }