xtunnelscvsdes.cpp

xtunnel nat/fw traversal source code

      {
		   raw0 = raw1++;
		   *cook	 = (*raw0 & 0x00fc0000L) << 6;
		   *cook	|= (*raw0 & 0x00000fc0L) << 10;
		   *cook	|= (*raw1 & 0x00fc0000L) >> 10;
		   *cook++	|= (*raw1 & 0x00000fc0L) >> 6;
		   *cook	 = (*raw0 & 0x0003f000L) << 12;
		   *cook	|= (*raw0 & 0x0000003fL) << 16;
		   *cook	|= (*raw1 & 0x0003f000L) >> 4;
		   *cook++	|= (*raw1 & 0x0000003fL);
		}
	   usekey(dough);
	}

   void cpkey(register unsigned long *into)
   {
	   register unsigned long *from, *endp;

	   from = KnL, endp = &KnL[32];
	   while( from < endp )
         *into++ = *from++;
	}

   void usekey(register unsigned long *from)
   {
	   register unsigned long *to, *endp;

	   to = KnL, endp = &KnL[32];
	   while( to < endp ) *to++ = *from++;
   }

   //void des(unsigned char *inblock, unsigned char *outblock)
   void des( char *inblock, char *outblock)
   {
	   unsigned long work[2];

	   scrunch(inblock, work);
	   desfunc(work, KnL);
	   unscrun(work, outblock);
   }

   //void scrunch(register unsigned char *outof, register unsigned long *into)
   void scrunch(register char *outof, register unsigned long *into)
   {
	   *into 	 = (*outof++ & 0xffL) << 24;
	   *into 	|= (*outof++ & 0xffL) << 16;
	   *into 	|= (*outof++ & 0xffL) << 8;
	   *into++ |= (*outof++ & 0xffL);
	   *into 	 = (*outof++ & 0xffL) << 24;
	   *into 	|= (*outof++ & 0xffL) << 16;
	   *into 	|= (*outof++ & 0xffL) << 8;
	   *into	|= (*outof   & 0xffL);
	}

   //void unscrun(register unsigned long *outof, register unsigned char *into)
   void unscrun(register unsigned long *outof, register char *into)
   {
#if TARGET_OS_WINDOWS
#pragma warning(push)
#pragma warning(disable : 4244)
#endif // TARGET_OS_WINDOWS
	   *into++ = (*outof >> 24) & 0xffL;
	   *into++ = (*outof >> 16) & 0xffL;
	   *into++ = (*outof >>  8) & 0xffL;
	   *into++ =  *outof++	 & 0xffL;
	   *into++ = (*outof >> 24) & 0xffL;
	   *into++ = (*outof >> 16) & 0xffL;
	   *into++ = (*outof >>  8) & 0xffL;
	   *into   =  *outof	 & 0xffL;
#if TARGET_OS_WINDOWS
#pragma warning(pop)
#endif // TARGET_OS_WINDOWS
	}

   void desfunc(register unsigned long *block, register unsigned long *keys)
   {
	   register unsigned long fval, work, right, leftt;
	   register int round;
	   
	   leftt = block[0];
	   right = block[1];
	   work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
	   right ^= work;
	   leftt ^= (work << 4);
	   work = ((leftt >> 16) ^ right) & 0x0000ffffL;
	   right ^= work;
	   leftt ^= (work << 16);
	   work = ((right >> 2) ^ leftt) & 0x33333333L;
	   leftt ^= work;
	   right ^= (work << 2);
	   work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
	   leftt ^= work;
	   right ^= (work << 8);
	   right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
	   work = (leftt ^ right) & 0xaaaaaaaaL;
	   leftt ^= work;
	   right ^= work;
	   leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;
	   
	   for( round = 0; round < 8; round++ ) {
		   work  = (right << 28) | (right >> 4);
		   work ^= *keys++;
		   fval  = SP7[ work		 & 0x3fL];
		   fval |= SP5[(work >>  8) & 0x3fL];
		   fval |= SP3[(work >> 16) & 0x3fL];
		   fval |= SP1[(work >> 24) & 0x3fL];
		   work  = right ^ *keys++;
		   fval |= SP8[ work		 & 0x3fL];
		   fval |= SP6[(work >>  8) & 0x3fL];
		   fval |= SP4[(work >> 16) & 0x3fL];
		   fval |= SP2[(work >> 24) & 0x3fL];
		   leftt ^= fval;
		   work  = (leftt << 28) | (leftt >> 4);
		   work ^= *keys++;
		   fval  = SP7[ work		 & 0x3fL];
		   fval |= SP5[(work >>  8) & 0x3fL];
		   fval |= SP3[(work >> 16) & 0x3fL];
		   fval |= SP1[(work >> 24) & 0x3fL];
		   work  = leftt ^ *keys++;
		   fval |= SP8[ work		 & 0x3fL];
		   fval |= SP6[(work >>  8) & 0x3fL];
		   fval |= SP4[(work >> 16) & 0x3fL];
		   fval |= SP2[(work >> 24) & 0x3fL];
		   right ^= fval;
		   }
		   
	   right = (right << 31) | (right >> 1);
	   work = (leftt ^ right) & 0xaaaaaaaaL;
	   leftt ^= work;
	   right ^= work;
	   leftt = (leftt << 31) | (leftt >> 1);
	   work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
	   right ^= work;
	   leftt ^= (work << 8);
	   work = ((leftt >> 2) ^ right) & 0x33333333L;
	   right ^= work;
	   leftt ^= (work << 2);
	   work = ((right >> 16) ^ leftt) & 0x0000ffffL;
	   leftt ^= work;
	   right ^= (work << 16);
	   work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
	   leftt ^= work;
	   right ^= (work << 4);
	   *block++ = right;
	   *block = leftt;
	   return;
   }

#ifdef D2_DES

			      /* unsigned char[16] */
   //void des2key(unsigned char *hexkey, short mode)		/* stomps on Kn3 too */
   void des2key( char *hexkey, short mode)		/* stomps on Kn3 too */
   {
	   short revmod;

	   revmod = (mode == EN0) ? DE1 : EN0;
	   deskey(&hexkey[8], revmod);
	   cpkey(KnR);
	   deskey(hexkey, mode);
	   cpkey(Kn3);					/* Kn3 = KnL */
	}
	
          /* unsigned char[8] */
   //void Ddes(unsigned char *from, unsigned char *into)
   void Ddes( char *from,  char *into)
   {
	   unsigned long work[2];

	   scrunch(from, work);
	   desfunc(work, KnL);
	   desfunc(work, KnR);
	   desfunc(work, Kn3);
	   unscrun(work, into);
	}

              /* unsigned char[16] */  /* unsigned char[16] */
   //void D2des(unsigned char *from, unsigned char *into)
   void D2des( char *from, char *into)
   {
	   unsigned long *right, *l1, swap;
	   unsigned long leftt[2], bufR[2];
	   
	   right = bufR;
	   l1 = &leftt[1];
	   scrunch(from, leftt);
	   scrunch(&from[8], right);
	   desfunc(leftt, KnL);
	   desfunc(right, KnL);
	   swap = *l1;
	   *l1 = *right;
	   *right = swap;
	   desfunc(leftt, KnR);
	   desfunc(right, KnR);
	   swap = *l1;
	   *l1 = *right;
	   *right = swap;
	   desfunc(leftt, Kn3);
	   desfunc(right, Kn3);
	   unscrun(leftt, into);
	   unscrun(right, &into[8]);
	}

                /* NULL-terminated  */ /* unsigned char[8] */
   //void makekey(register char *aptr, register unsigned char *kptr)
   void makekey(register char *aptr, register  char *kptr)
   {
	   //register unsigned char *store;
	   register char *store;
	   register int first, i;
	   unsigned long savek[96];

	   cpDkey(savek);
	   des2key(Df_Key, EN0);
	   for( i = 0; i < 8; i++ ) kptr[i] = Df_Key[i];
	   first = 1;
	   while( (*aptr != '\0') || first )
      {
		   store = kptr;
		   for( i = 0; i < 8 && (*aptr != '\0'); i++ )
         {
			   *store++ ^= *aptr & 0x7f;
			   *aptr++ = '\0';
			}
		   Ddes(kptr, kptr);
		   first = 0;
		}
	   useDkey(savek);
	}

                /* NULL-terminated   */ /* unsigned char[16] */
   //void make2key(register char *aptr, register unsigned char *kptr)
   void make2key(register char *aptr, register char *kptr)
   {
	   //register unsigned char *store;
	   register char *store;
	   register int first, i;
	   unsigned long savek[96];

	   cpDkey(savek);
	   des2key(Df_Key, EN0);
	   for( i = 0; i < 16; i++ ) kptr[i] = Df_Key[i];
	   first = 1;
	   while( (*aptr != '\0') || first ) {
		   store = kptr;
		   for( i = 0; i < 16 && (*aptr != '\0'); i++ ) {
			   *store++ ^= *aptr & 0x7f;
			   *aptr++ = '\0';
			   }
		   D2des(kptr, kptr);
		   first = 0;
		   }
	   useDkey(savek);
	   return;
   }

#ifndef D3_DES	/* D2_DES only */
#ifdef  D2_DES	/* iff D2_DES! */

               /* unsigned long[64] */
   void cp2key(register unsigned long *into)
   {
	   register unsigned long *from, *endp;

	   cpkey(into);
	   into = &into[32];
	   from = KnR, endp = &KnR[32];
	   while( from < endp ) *into++ = *from++;
   }

               /* unsigned long[64] */
   void use2key(register unsigned long *from)				/* stomps on Kn3 too */
   {
	   register unsigned long *to, *endp;

	   usekey(from);
	   from = &from[32];
	   to = KnR, endp = &KnR[32];
	   while( to < endp ) *to++ = *from++;
	   cpkey(Kn3);					/* Kn3 = KnL */
   }

#endif	/* iff D2_DES */
#else	/* D3_DES too */

               /* unsigned char[24] */
   //void des3key(unsigned char *hexkey, short mode)
   void des3key( char *hexkey, short mode)
   {
	   //unsigned char *first, *third;
	   char *first, *third;
	   short revmod;

	   if( mode == EN0 )
      {
		   revmod = DE1;
		   first = hexkey;
		   third = &hexkey[16];
		}
	   else
      {
		   revmod = EN0;
		   first = &hexkey[16];
		   third = hexkey;
		}
	   deskey(&hexkey[8], revmod);
	   cpkey(KnR);
	   deskey(third, mode);
	   cpkey(Kn3);
	   deskey(first, mode);
	}

               /* unsigned long[96] */
   void cp3key(register unsigned long *into)
   {
	   register unsigned long *from, *endp;

	   cpkey(into);
	   into = &into[32];
	   from = KnR, endp = &KnR[32];
	   while( from < endp ) *into++ = *from++;
	   from = Kn3, endp = &Kn3[32];
	   while( from < endp ) *into++ = *from++;
	}

      /* unsigned long[96] */
   void use3key(register unsigned long *from)
   {
	   register unsigned long *to, *endp;

	   usekey(from);
	   from = &from[32];
	   to = KnR, endp = &KnR[32];
	   while( to < endp ) *to++ = *from++;
	   to = Kn3, endp = &Kn3[32];
	   while( to < endp ) *to++ = *from++;
	   return;
   }
                     /* unsigned char[24] */ /* unsigned char[24] */
   //void D3des(unsigned char *from, unsigned char *into)	/* amateur theatrics */
   void D3des( char *from,  char *into)	/* amateur theatrics */
   {
	   unsigned long swap, leftt[2], middl[2], right[2];
	   
	   scrunch(from, leftt);
	   scrunch(&from[8], middl);
	   scrunch(&from[16], right);
	   desfunc(leftt, KnL);
	   desfunc(middl, KnL);
	   desfunc(right, KnL);
	   swap = leftt[1];
	   leftt[1] = middl[0];
	   middl[0] = swap;
	   swap = middl[1];
	   middl[1] = right[0];
	   right[0] = swap;
	   desfunc(leftt, KnR);
	   desfunc(middl, KnR);
	   desfunc(right, KnR);
	   swap = leftt[1];
	   leftt[1] = middl[0];
	   middl[0] = swap;
	   swap = middl[1];
	   middl[1] = right[0];
	   right[0] = swap;
	   desfunc(leftt, Kn3);
	   desfunc(middl, Kn3);
	   desfunc(right, Kn3);
	   unscrun(leftt, into);
	   unscrun(middl, &into[8]);
	   unscrun(right, &into[16]);
	}	
	
                /* NULL-terminated   */   /* unsigned char[24] */
   //void make3key(register char *aptr, register unsigned char *kptr)
   void make3key(register char *aptr, register char *kptr)
   {
	   //register unsigned char *store;
	   register char *store;
	   register int first, i;
	   unsigned long savek[96];

	   cp3key(savek);
	   des3key(Df_Key, EN0);
	   for( i = 0; i < 24; i++ ) kptr[i] = Df_Key[i];
	   first = 1;
	   while( (*aptr != '\0') || first ) {
		   store = kptr;
		   for( i = 0; i < 24 && (*aptr != '\0'); i++ ) {
			   *store++ ^= *aptr & 0x7f;
			   *aptr++ = '\0';
			   }
		   D3des(kptr, kptr);
		   first = 0;
		   }
	   use3key(savek);
	}

#endif	/* D3_DES */
#endif	/* D2_DES */
}; // class CVsInternalDES

/* Validation sets:
 *
 * Single-length key, single-length plaintext -
 * Key    : 0123 4567 89ab cdef
 * Plain  : 0123 4567 89ab cde7
 * Cipher : c957 4425 6a5e d31d
 *
 * Double-length key, single-length plaintext -
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
 * Plain  : 0123 4567 89ab cde7
 * Cipher : 7f1d 0a77 826b 8aff
 *
 * Double-length key, double-length plaintext -
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
 * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
 * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
 *
 * Triple-length key, single-length plaintext -
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
 * Plain  : 0123 4567 89ab cde7
 * Cipher : de0b 7c06 ae5e 0ed5
 *
 * Triple-length key, double-length plaintext -
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
 * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
 * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
 *
 * d3des V5.0a rwo 9208.07 18:44 Graven Imagery
 **********************************************************************/

struct STDESPrivateData
{
public:
   STDESPrivateData(
      const char * szKey,
      bool bEncrypt,
      unsigned long dwDES123,
      unsigned long dwLength123
   );