moo.cpp

DES/DES3 with operators of CBC and OFB

#include "StdAfx.h"
#include "moo.h"

#include "des.h"



/*MOO.cpp*/

// file pointers for plaintext, encrypttext, decrypttext respectively
FILE *pfp = NULL, *pfe = NULL, *pfd = NULL;
unit8 des_nkeys = 0;
#define buf_size 1024


inline void EXCLUSIVE( unit8 x[8], unit8 y[8], unit8 z[8] )
{
	x[0] = y[0] ^ z[0];
	x[1] = y[1] ^ z[1];
	x[2] = y[2] ^ z[2];
	x[3] = y[3] ^ z[3];
	x[4] = y[4] ^ z[4];
	x[5] = y[5] ^ z[5];
	x[6] = y[6] ^ z[6];
	x[7] = y[7] ^ z[7];
}



// Pre-ciphertext block or Initial vector for the first time

static unit32 pcb[2] =
{
	0x00000000,0x00000000
};


void block_fill( unit8* string, unit32& len )
{

}


/* CBC MODE OF OPERATION */

static des_context ctx;
static des3_context ctx3;


// Update the pre-cipher block 

void cbc_set_pcb( unit8 p[8] )
{
	pcb[0] = (unit32)p[0]<<24 | (unit32)p[1]<<16 | (unit32)p[2]<<8 | (unit32)p[3];
	pcb[1] = (unit32)p[4]<<24 | (unit32)p[5]<<16 | (unit32)p[6]<<8 | (unit32)p[7];
}



/* CBC_DES */


// Set initial values: iv-initial vector; key-keys for encryption; nkeys-the count of keys

bool cbc_des_init( unit32* iv, unit8 key[], unit8 nkeys )
{
	if( iv != NULL )
	{
		pcb[0] = iv[0];	pcb[1] = iv[1];
	}

	switch( nkeys )
	{
	case 1:
		des_set_key( &ctx, key );
		break;
	case 2:
		des3_set_2keys( &ctx3, key, ( key + 8 ) );
		break;
	case 3:
		des3_set_3keys( &ctx3, key, ( key + 8 ), ( key + 16 ) );
	default:
		perror( "Error the count of keys!\n" );
		return false;
	}
	des_nkeys = nkeys;
	return true;
}

// Open plaintext file and a file for encrypting

bool set_encrypt_file( char* pfile, char* efile )
{
	bool errCode = 0;
	errCode = fopen_s( &pfp, pfile, "rb" );

	if( !errCode )
		errCode = fopen_s( &pfe, efile, "wb" );
	
	return !errCode;
}


// Open encrypting file and decrypting file

bool set_decrypt_file( char* efile, char* dfile )
{
	bool errCode = 0;
	errCode = fopen_s( &pfe, efile, "rb" );

	if( !errCode )
		errCode = fopen_s( &pfd, dfile, "wb" );

	return !errCode;
}



/* Encrypt routine */

bool cbc_des_encode_file(  char* inputfile, char* outputfile  )
{
	
	FILE *infile, *outfile;

	if( fopen_s( &infile, inputfile, "rb" ) )
		return false;

	if( fopen_s( &outfile, outputfile, "wb" ) )
		return false;

	bool suc = cbc_des_encode( infile, outfile );

	fclose( infile );
	fclose( outfile );
	return suc;
}



void cbc_des_encode( unit8* string, unit32 len)
{
	unit8 etext[1024];
	unit8 pt[8];
	unit32 i,j;

	for( i=0,j=0; i < len; i+= 8 )
	{
		//CBC( ( string + i ), pt );
		EXCLUSIVE( pt, ( string + i ), (unit8*)pcb );
		des_encrypt( &ctx, pt, (etext+j) );
		cbc_set_pcb( etext+j );
		j += 8;
		if( j >= 1024 )
		{
			fwrite( etext, 1, j, pfe );  // flush the buffer
			j = 0;
		}
	}
	if( j < 1024 )
		fwrite( etext, 1, j, pfe );
}



void cbc_des3_encode( unit8* string, unit32 len )
{
	unit8 etext[1024];
	unit32 i,j;
	unit8 pt[8];

	for( i=0,j=0; i < len; i+= 8 )
	{
		EXCLUSIVE( pt, ( string + i ), (unit8*)pcb );
		des3_encrypt( &ctx3, pt, (etext+j) );
		cbc_set_pcb( etext+j );
		j += 8;
		if( j >= 1024 )
		{
			fwrite( etext, 1, j, pfe );  // flush the buffer
			j = 0;
		}
	}
	if( j < 1024 )
		fwrite( etext, 1, j, pfe );

}


bool cbc_des_encode( FILE* infile, FILE* outfile )
{
	unit32 len;
	unit8 buffer[buf_size];

	pfp = infile;
	pfe = outfile;
	while( 1 )
	{
		len = fread( buffer, 1, buf_size, infile );
		if( ferror( infile ) )
			return false;
		if( len < buf_size )
			block_fill( buffer, len );
		switch( des_nkeys )
		{
		case 1:
			cbc_des_encode( buffer, len );
			break;
		case 2:
		case 3:
			cbc_des3_encode( buffer, len );
			break;
		default:
			perror("Don't specify keys!\n");
			return false;
		}
		if( len < buf_size )
			break;
	}
	
	pfe = pfp = NULL;
	return true;

}



// Decrypt routine 

void cbc_des_decode( unit8* string, unit32 len)
{
	unit8 dtext[1024];
	unit8 tb[8];
	unit32 i, j;
	
	for( i=0, j=0; i < len; i += 8 )
	{
		des_decrypt( &ctx, (string+i), tb );
		//CBC( tb, ( dtext+j ) );
		EXCLUSIVE( ( dtext + j ), tb, (unit8*)pcb );
		cbc_set_pcb( string + i );
		j += 8;
		if( j >= 1024 )
		{
			fwrite( dtext, 1, j, pfd );
			j = 0;
		}
	}

	if( j < 1024 )
		fwrite( dtext, 1, j, pfd );

}


void cbc_des3_decode( unit8* string, unit32 len )
{
	unit8 dtext[1024];
	unit32 i, j;
	unit8 tb[8];

	for( i=0,j=0; i < len; i+= 8 )
	{
		des3_decrypt( &ctx3, (string+i), tb );
		//CBC( tb, (dtext+j) );
		EXCLUSIVE( (dtext+j), tb, (unit8*)pcb );
		cbc_set_pcb( string + i );
		j += 8;
		if( j >= 1024 )
		{
			fwrite( dtext, 1, j, pfd );  // flush the buffer
			j = 0;
		}
	}
	if( j < 1024 )
		fwrite( dtext, 1, j, pfd );

}



bool cbc_des_decode_file( char* inputfile ,char* outputfile)
{
	//unit8 buffer[1024];
	//unit32 len;
	
	FILE *infile, *outfile;

	if( fopen_s( &infile, inputfile, "rb" ) )
		return false;

	if( fopen_s( &outfile, outputfile, "wb" ) )
		return false;

/*
	while( len = fread( buffer, 1, 1024, pfe ) )
		cbc_des_decode( buffer, len );
*/
	bool suc = cbc_des_decode( infile, outfile );

	fclose( infile );	
	fclose( outfile );

	return suc;
}


bool cbc_des_decode( FILE* infile, FILE* outfile )
{
	unit32 len;
	unit8 buffer[buf_size];

	pfe = infile;
	pfd = outfile;
	while( 1 )
	{
		len = fread( buffer, 1, buf_size, infile );
		if( ferror( infile ) )
			return false;
		if( len < buf_size )
			block_fill( buffer, len );
		switch( des_nkeys )
		{
		case 1:
			cbc_des_decode( buffer, len );
			break;
		case 2:
		case 3:
			cbc_des3_decode( buffer, len );
		default:
			perror("Don't specify keys!\n");
			return false;
		}

		if( len < buf_size )
			break;
	}
	
	pfe = pfd = NULL;
	return true;

}




/* OFB MODE OF OPERATION */

static unit8 pul = 8;    // default length of a transmitting unit  


// a mask that has n-bit 1 right
inline  unit8 mask8right( unit8 n )
{
	unit8 mask = 0, submask = 1;
	for( unit8 k = 0; k < n; k ++, submask = (submask << 1) )
		mask |= submask;

	return mask;
}



// draw-out pul bits from i-th bit
inline void pickup( unit8 x[], unit8 y[], unit8 i, unit8 n )
{
	unit8 c = n;
	unit8 mask = mask8right( 8 - i );
	short k = 0;
	while(1)
	{
		x[k] = ( ( y[k] & mask ) << i ) | ( ( y[k+1] & (~mask) ) >> ( 8 - i ) );
		if( c > 8 )
		{
			c -= 8;  k++ ;
		}
		else 
			break;	
	}
}

// draw-in pul bits from i-th bit
inline void putdown( unit8 x[], unit8 y[], unit8 i, unit8 n )
{
	unit8 c = n;
	unit8 mask = mask8right( 8 - i );
	short k = 0;
	while( 1 )
	{
		x[k] = x[k] & ( ~mask );
		x[k] |= ( y[k] >> i );
		x[k+1] = ( y[k] << ( 8 - i ) );
		if( c > 8 )
		{
			c -= 8;  k++;
		}
		else
			break;
	}
}

// Set initialization 
bool ofb_des_init( unit32* iv, unit8 key[], unit8 nkeys, unit8 j )
{

	pul = j;
	if ( iv != NULL )
	{
		pcb[0] = iv[0]; pcb[1] = iv[1];	
	}

	switch( nkeys )
	{
	case 1:
		des_set_key( &ctx, key );
		break;
	case 2:
		des3_set_2keys( &ctx3, key, ( key + 8 ) );
		break;
	case 3:
		des3_set_3keys( &ctx3, key, ( key + 8 ), ( key + 16 ) );
		break;
	default:
		perror( "Error the count of keys!\n" );
		return false;
	}

	des_nkeys = nkeys;

	return true;
}


// Reset the pre-cipher block

void ofb_set_pcb( unit32 p[2] )
{
	unit32 t[2];
	t[0] = ( pcb[0] << pul ) | ( pcb[1] >> ( 32 - pul ) );
	t[1] = ( pcb[1] << pul ) | ( p[0] >> ( 32 - pul ) );

	pcb[0] = t[0];  pcb[1] = t[1];
}




/* Encrypt Routines */

void ofb_des_encode( unit8 string[], unit32 len )
{
	unit8 pt[8], ct[8];
	unit32 i, j;
	unit8 n;
	unit8 cb[8];
	unit8 buffer[buf_size];
	unit32 count = ( len << 3 );
	for( i = 0, j = 0; i < count; i += pul )
	{
		n = ( ( count - i ) < pul ) ? ( count - i ) : pul;
		pickup( pt, ( string + ( i/8 ) ), ( i%8 ), n );
		des_encrypt( &ctx, (unit8*)pcb, cb );
		
		EXCLUSIVE( ct, cb, pt );
		putdown( ( buffer + j/8 ), ct, j%8, n );
		ofb_set_pcb( (unit32*)cb );		

		j += n;
		if( j >= ( buf_size << 3 ) )
		{
			fwrite( buffer, 1, (j>>3), pfe );
			j = 0;
		}
	}
	if( j < ( buf_size << 3 ) )
		fwrite( buffer, 1, (j>>3), pfe );
}


void ofb_des3_encode( unit8 string[], unit32 len )
{
	unit8 pt[8], ct[8];
	unit32 i, j;
	unit8 n;
	unit8 cb[8];
	unit8 buffer[buf_size];
	unit32 count = ( len << 3 );
	for( i = 0, j = 0; i < count; i += pul )
	{
		n = ( ( count - i ) < pul ) ? ( count - i ) : pul;
		pickup( pt, ( string + ( i/8 ) ), ( i%8 ), n );
		des3_encrypt( &ctx3, (unit8*)pcb, cb );
		
		EXCLUSIVE( ct, cb, pt );
		putdown( ( buffer + j/8 ), ct, j%8, n );
		ofb_set_pcb( (unit32*)cb );		

		j += n;
		if( j >= ( buf_size << 3 ) )
		{
			fwrite( buffer, 1, (j>>3), pfe );
			j = 0;
		}
	}
	if( j < ( buf_size << 3 ) )
		fwrite( buffer, 1, (j>>3), pfe );
}


bool ofb_des_encode( FILE* infile, FILE* outfile )
{
	unit32 len;
	unit8 buffer[buf_size];
	
	pfp = infile;
	pfe = outfile;
	
	while( 1 )
	{
		len = fread( buffer, 1, buf_size, infile );
		if( ferror( infile ) )
			return false;
		switch( des_nkeys )
		{
		case 1:
			ofb_des_encode( buffer, len );
			break;
		case 2:
		case 3:
			ofb_des3_encode( buffer, len );
			break;
		default:
			perror( "Dont' specify nkeys!\n" );
			return false;
		}

		if( len < buf_size )
			break;
	}
	
	pfe = pfp =  NULL;
	return true;

}

bool ofb_des_encode_file( char* inputfile, char* outputfile )
{
	FILE *infile, *outfile;


	if( fopen_s( &infile, inputfile, "rb" ) )
		return false;
	if( fopen_s( &outfile, outputfile, "wb" ) )
		return false;

	bool suc = ofb_des_encode( infile, outfile );

	fclose( infile );
	fclose( outfile );

	return suc;
}


/* Decrypt Routines */


void ofb_des_decode( unit8 string[], unit32 len )
{
	unit8 pt[8], ct[8];
	unit8 n;
	unit32 i, j;
	unit8 cb[8];
	unit8 buffer[buf_size];
	unit32 count = ( len << 3 );
	for( i=0, j=0; i < count; i += pul )
	{
		n = ( ( count - i ) < pul ) ? ( count - i ) : pul;
		pickup( pt, ( string + ( i/8 ) ), ( i%8 ), n );
		
		des_encrypt( &ctx, (unit8*)pcb, cb );

		EXCLUSIVE( ct, cb, pt );
		putdown( ( buffer + j/8 ), ct, j%8, n );
		ofb_set_pcb( (unit32*)cb );

		j += n;
		if( j >= ( buf_size << 3 ) )
		{
			fwrite( buffer, 1, (j>>3), pfd );
			j = 0;
		}
	}
	if( j < ( buf_size << 3 ) )
		fwrite( buffer, 1, (j>>3), pfd );
}


void ofb_des3_decode( unit8 string[], unit32 len )
{
	unit8 pt[8], ct[8];
	unit8 n;
	unit32 i, j;
	unit8 cb[8];
	unit8 buffer[buf_size];
	unit32 count = ( len << 3 );
	for( i=0, j=0; i < count; i += pul )
	{
		n = ( ( count - i ) < pul ) ? ( count - i ) : pul;
		pickup( pt, ( string + ( i/8 ) ), ( i%8 ), n );
		
		des3_encrypt( &ctx3, (unit8*)pcb, cb );

		EXCLUSIVE( ct, cb, pt );
		putdown( ( buffer + j/8 ), ct, j%8, n );
		ofb_set_pcb( (unit32*)cb );

		j += n;
		if( j >= ( buf_size << 3 ) )
		{
			fwrite( buffer, 1, (j>>3), pfd );
			j = 0;
		}
	}
	if( j < ( buf_size << 3 ) )
		fwrite( buffer, 1, (j>>3), pfd );
}


bool ofb_des_decode( FILE* infile, FILE* outfile )
{
	unit32 len;
	unit8 buffer[buf_size];

	pfe = infile;
	pfd = outfile;

	while( 1 )
	{
		len = fread( buffer, 1, buf_size, infile );
		if( ferror( infile ) )
			return false;
		switch( des_nkeys )
		{
		case 1:
			ofb_des_decode( buffer, len );
			break;
		case 2:
		case 3:
			ofb_des3_decode( buffer, len );
			break;
		default:
			perror( "Don't specify nkeys!\n" );
			return false;
		}
		if( len < buf_size )
			break;
	}

	pfe = pfd = NULL;
	return true;
}


bool ofb_des_decode_file( char* inputfile, char* outputfile )
{
	FILE *infile, *outfile;

	if( fopen_s( &infile, inputfile, "rb" ) )
		return false;
	if( fopen_s( &outfile, outputfile, "wb" ) )
		return false;

	bool suc = ofb_des_decode( infile, outfile );
	
	fclose( infile );
	fclose( outfile );

	return suc;

}