help needed with edit control & encryption

willc0de4food · 03-16-2006, 02:47 PM

hey, i'm having some big problems with this for some reason and i dont know why

but my problem is that whenever i use these functions to encrypt/decrypt the text of a static control (or if i encrypt/save the text to a file and then load/decrypt it), it doesn't quite work. i've tried two ways with the same encryption functions. when i've encrypted/saved the text to a file, usually it'll decrypt some or most of the text, but then the end and usually a few characters at the beginning will be garbled. i'm finding with just encrypting/decrypting as a menu option isn't working for decryption at all. and sometimes when i try to decrypt, it simply immediately closes the program. i found that if i add an int main to these encryption functions and get input from the user to encrypt/decrypt, it works exactly as it should. i find that curious. here's the encryption functions i'm using:

Code:

// advanced encryption standard
// author: karl malbrain, karl_m@acm.org

typedef unsigned char uchar;

#include <stdio.h>
#include <string.h>
#include <memory.h>
#include <shibby.h>

#define Nb 4			// number of bytes in a columns eg. number of rows
#define Nk 4			// number of columns in a key eg. size of key is Nk*Nb = 16
#define Nr 10			// number of rounds in encription

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

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

// Modular Multiplication Tables
//
// based on: Xtime2[x] = (x & 0x80 ? 0x1b : 0) ^ (x + x)
// Xtime4[x] = Xtime2[Xtime2[x]]

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

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

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

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

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

// rotates a column row1 to row0, row2 to row1 and so on...
unsigned RotWord (unsigned tmp)
{
	return tmp << 8 | (tmp >> 24);
}

// runs a column through s-box (forward)
unsigned SubWord (unsigned tmp)
{
unsigned ans = 0;

	ans = Sbox[tmp & 0xff];
	tmp >>= 8;
	ans |= Sbox[tmp & 0xff] << 8;
	tmp >>= 8;
	ans |= Sbox[tmp & 0xff] << 16;
	tmp >>= 8;
	return ans |= Sbox[tmp & 0xff] << 24;
}

// runs 4 columns through forward s-box
void SubBytes (uchar *state)
{
int idx;

	for( idx = 0; idx < Nb * 4; idx++ )
		 state[idx] = Sbox[state[idx]];
}

// run 4 columns through inverse s-box
void InvSubBytes (uchar *state)
{
int idx;

	for( idx = 0; idx < Nb * 4; idx++ )
		 state[idx] = InvSbox[state[idx]];
}

// exchanges columns in each of 4 rows
// row0 - unchanged, row1- shifted left 1, 
// row2 - shifted left 2 and row3 - shifted left 3
void ShiftRows (uchar *state)
{
uchar tmp;

	// rotate row 1
	tmp = state[2], state[2] = state[6];
	state[6] = state[10], state[10] = state[14], state[14] = tmp;

	// rotate row 2
	tmp = state[1], state[1] = state[9], state[9] = tmp;
	tmp = state[5], state[5] = state[13], state[13] = tmp;

	// rotate row 3
	tmp = state[12], state[12] = state[8];
	state[8] = state[4], state[4] = state[0], state[0] = tmp;
}

// restores columns in each of 4 rows
// row0 - unchanged, row1- shifted right 1, 
// row2 - shifted right 2 and row3 - shifted right 3
void InvShiftRows (uchar *state)
{
uchar tmp;

	// restore row 1
	tmp = state[14], state[14] = state[10];
	state[10] = state[6], state[6] = state[2], state[2] = tmp;

	// restore row 2
	tmp = state[1], state[1] = state[9], state[9] = tmp;
	tmp = state[5], state[5] = state[13], state[13] = tmp;

	// restore row 3
	tmp = state[0], state[0] = state[4];
	state[4] = state[8], state[8] = state[12], state[12] = tmp;
}

// recombine and mix each row in a column
void MixColumns (uchar *state)
{
uchar newstate[4 * Nb];

	// mixing column 1
	newstate[3] = Xtime2[state[3]] ^ state[2] ^ Xtime2[state[2]] ^ state[1] ^ state[0];
	newstate[2] = state[3] ^ Xtime2[state[2]] ^ state[1] ^ Xtime2[state[1]] ^ state[0];
	newstate[1] = state[3] ^ state[2] ^ Xtime2[state[1]] ^ state[0] ^ Xtime2[state[0]];
	newstate[0] = state[3] ^ Xtime2[state[3]] ^ state[2] ^ state[1] ^ Xtime2[state[0]];

	// mixing column 2
	newstate[7] = Xtime2[state[7]] ^ state[6] ^ Xtime2[state[6]] ^ state[5] ^ state[4];
	newstate[6] = state[7] ^ Xtime2[state[6]] ^ state[5] ^ Xtime2[state[5]] ^ state[4];
	newstate[5] = state[7] ^ state[6] ^ Xtime2[state[5]] ^ state[4] ^ Xtime2[state[4]];
	newstate[4] = state[7] ^ Xtime2[state[7]] ^ state[6] ^ state[5] ^ Xtime2[state[4]];

	// mixing column 3
	newstate[11] = Xtime2[state[11]] ^ state[10] ^ Xtime2[state[10]] ^ state[9] ^ state[8];
	newstate[10] = state[11] ^ Xtime2[state[10]] ^ state[9] ^ Xtime2[state[9]] ^ state[8];
	newstate[9] = state[11] ^ state[10] ^ Xtime2[state[9]] ^ state[8] ^ Xtime2[state[8]];
	newstate[8] = state[11] ^ Xtime2[state[11]] ^ state[10] ^ state[9] ^ Xtime2[state[8]];

	// mixing column 4
	newstate[15] = Xtime2[state[15]] ^ state[14] ^ Xtime2[state[14]] ^ state[13] ^ state[12];
	newstate[14] = state[15] ^ Xtime2[state[14]] ^ state[13] ^ Xtime2[state[13]] ^ state[12];
	newstate[13] = state[15] ^ state[14] ^ Xtime2[state[13]] ^ state[12] ^ Xtime2[state[12]];
	newstate[12] = state[15] ^ Xtime2[state[15]] ^ state[14] ^ state[13] ^ Xtime2[state[12]];

	memcpy (state, newstate, sizeof(newstate));
}

// restore and un-mix each row in a column
void InvMixColumns (uchar *state)
{
uchar newstate[4 * Nb];

	// restore column 1
	newstate[3] = XtimeE[state[3]] ^ XtimeB[state[2]] ^ XtimeD[state[1]] ^ Xtime9[state[0]];
	newstate[2] = Xtime9[state[3]] ^ XtimeE[state[2]] ^ XtimeB[state[1]] ^ XtimeD[state[0]];
	newstate[1] = XtimeD[state[3]] ^ Xtime9[state[2]] ^ XtimeE[state[1]] ^ XtimeB[state[0]];
	newstate[0] = XtimeB[state[3]] ^ XtimeD[state[2]] ^ Xtime9[state[1]] ^ XtimeE[state[0]];

	// restore column 2
	newstate[7] = XtimeE[state[7]] ^ XtimeB[state[6]] ^ XtimeD[state[5]] ^ Xtime9[state[4]];
	newstate[6] = Xtime9[state[7]] ^ XtimeE[state[6]] ^ XtimeB[state[5]] ^ XtimeD[state[4]];
	newstate[5] = XtimeD[state[7]] ^ Xtime9[state[6]] ^ XtimeE[state[5]] ^ XtimeB[state[4]];
	newstate[4] = XtimeB[state[7]] ^ XtimeD[state[6]] ^ Xtime9[state[5]] ^ XtimeE[state[4]];

	// restore column 3
	newstate[11] = XtimeE[state[11]] ^ XtimeB[state[10]] ^ XtimeD[state[9]] ^ Xtime9[state[8]];
	newstate[10] = Xtime9[state[11]] ^ XtimeE[state[10]] ^ XtimeB[state[9]] ^ XtimeD[state[8]];
	newstate[9]  = XtimeD[state[11]] ^ Xtime9[state[10]] ^ XtimeE[state[9]] ^ XtimeB[state[8]];
	newstate[8]  = XtimeB[state[11]] ^ XtimeD[state[10]] ^ Xtime9[state[9]] ^ XtimeE[state[8]];

	// restore column 4
	newstate[15] = XtimeE[state[15]] ^ XtimeB[state[14]] ^ XtimeD[state[13]] ^ Xtime9[state[12]];
	newstate[14] = Xtime9[state[15]] ^ XtimeE[state[14]] ^ XtimeB[state[13]] ^ XtimeD[state[12]];
	newstate[13] = XtimeD[state[15]] ^ Xtime9[state[14]] ^ XtimeE[state[13]] ^ XtimeB[state[12]];
	newstate[12] = XtimeB[state[15]] ^ XtimeD[state[14]] ^ Xtime9[state[13]] ^ XtimeE[state[12]];

	memcpy (state, newstate, sizeof(newstate));
}

// encrypt/decrypt columns of the key
void AddRoundKey (unsigned *state, unsigned *key)
{
int idx;

	for( idx = 0; idx < Nb; idx++ )
		state[idx] ^= key[idx];
}

unsigned Rcon[11] = {
0x00000000, 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000};

// produce Nk bytes for each round
void ExpandKey (uchar *key, unsigned *expkey)
{
unsigned tmp, idx;

	for( idx = 0; idx < Nk; idx++ ) {
		expkey[idx] =  key[4 * idx + 3];
		expkey[idx] |= key[4 * idx + 2] << 8;
		expkey[idx] |= key[4 * idx + 1] << 16;
		expkey[idx] |= key[4 * idx + 0] << 24;
	}

	for( idx = Nk; idx < Nb * (Nr + 1); idx++ ) {
		tmp = expkey[idx - 1];
		if( !(idx % Nk) )
			tmp = SubWord (RotWord(tmp)) ^ Rcon[idx/Nk];

		expkey[idx] = expkey[idx - Nk] ^ tmp;
	}
}

// encrypt one 128 bit block
void Encrypt (uchar *in, unsigned *expkey, uchar *out)
{
unsigned state[Nb], round, idx;

	for( idx = 0; idx < Nb; idx++ ) {
		state[idx] = *in++ << 24;
		state[idx] |= *in++ << 16;
		state[idx] |= *in++ << 8;
		state[idx] |= *in++;
	}

	AddRoundKey (state, expkey);

	for( round = 1; round < Nr + 1; round++ ) {
		SubBytes((uchar *)state);
		ShiftRows ((uchar *)state);
		if( round < Nr )
			MixColumns ((uchar *)state);
		AddRoundKey (state, expkey + round * Nb);
	}

	for( idx = 0; idx < Nb; idx++ ) {
		*out++ = state[idx] >> 24;
		*out++ = state[idx] >> 16;
		*out++ = state[idx] >> 8;
		*out++ = state[idx];
	}
}

void Decrypt (uchar *in, unsigned *expkey, uchar *out)
{
unsigned state[Nb], idx, round;

	for( idx = 0; idx < Nb; idx++ ) {
		state[idx] = *in++ << 24;
		state[idx] |= *in++ << 16;
		state[idx] |= *in++ << 8;
		state[idx] |= *in++;
	}

	AddRoundKey (state, expkey + Nr * Nb);
	round = Nr - 1;

	do {
		InvShiftRows((uchar *)state);
		InvSubBytes((uchar *)state);
		AddRoundKey (state, expkey + round * Nb);
		if( round )
			InvMixColumns ((uchar *)state);
	} while( round-- );

	for( idx = 0; idx < Nb; idx++ ) {
		*out++ = state[idx] >> 24;
		*out++ = state[idx] >> 16;
		*out++ = state[idx] >> 8;
		*out++ = state[idx];
	}
}

and then here's the code for encrypt/save open/decrypt:

Code:

BOOL LoadFile(HWND hEdit, LPSTR pszFileName)
{
   HANDLE hFile;
   BOOL bSuccess = FALSE;
   DWORD dwFileSize, dwRead;
   unsigned expKey[129];
   char *decrypted, *encrypted;
   char str[17] = {0}, temp[17] = {0};
   int i = 0, x = 0, length = 0;
   unsigned expkey[128];

   hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
      OPEN_EXISTING, 0, 0);
   if(hFile != INVALID_HANDLE_VALUE)
   {
      
      dwFileSize = GetFileSize(hFile, NULL);
      if(dwFileSize != 0xFFFFFFFF)
      {
         LPSTR pszFileText;
         pszFileText = malloc((dwFileSize + 1) * sizeof(LPSTR));
         decrypted = malloc((dwFileSize + 1) * sizeof(char));
         encrypted = malloc((dwFileSize + 1) * sizeof(char));
         if(pszFileText != NULL)
         {
            if(ReadFile(hFile, pszFileText, dwFileSize, &dwRead, NULL))
            {
               pszFileText[dwFileSize] = 0; // Null terminator
               strcpy(encrypted, pszFileText);
               while (encrypted[i] != 0 && i <= dwFileSize)
               {
                     for (x = 0; x <= 15; x++)
                     {
                         str[x] = encrypted[i];
                         ++i;
                     }
                     Decrypt(str, expkey, temp);
                     strcat(decrypted, temp);
               }      
               length = strlen(decrypted);
               if(SetWindowText(hEdit, decrypted))
                  bSuccess = TRUE; // It worked!
            }
            free(pszFileText);
            free(decrypted);
            free(encrypted);
         }
      }
      CloseHandle(hFile);
   }
   return bSuccess;
}

BOOL SaveFile(HWND hEdit, LPSTR pszFileName)
{
   HANDLE hFile;
   BOOL bSuccess = FALSE;
   unsigned expKey[129];
   char *encrypted;
   char str[17] = {0}, temp[17] = {0};
   int i = 0, x = 0, length = 0;
   unsigned expkey[128];
   DWORD dwWritten, dwTextLength;

   hFile = CreateFile(pszFileName, GENERIC_WRITE, 0, 0,
      CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
   if(hFile != INVALID_HANDLE_VALUE)
   {
      dwTextLength = GetWindowTextLength(hEdit);
      if(dwTextLength > 0)                  // No need to bother if there's no text.
      {
         LPSTR pszText;
         pszText = malloc((dwTextLength + 1) * sizeof(LPSTR));
         encrypted = malloc((dwTextLength + 1) * sizeof(char));
         if(pszText != NULL)
         {
            if(GetWindowText(hEdit, pszText, dwTextLength + 1))
            {
               while (/*pszText[i] != 0 && */i <= dwTextLength)
               {
                     for (x = 0; x <= 15; x++)
                     {
                         str[x] = pszText[i];
                         ++i;
                     }
                     Encrypt(str, expkey, temp);
                     strcat(encrypted, temp);
               }
                     
               length = strlen(encrypted);
               if (WriteFile(hFile, encrypted, length, &dwWritten, NULL))
                  bSuccess = TRUE;
            }
            free(pszText);
            free(encrypted);
         }
      }
      CloseHandle(hFile);
   }
   return bSuccess;
}

and my functions for when encrypt/decrypt is a menu option:

Code:

void EncEdit(HWND hwnd)
{
    TCHAR *txt, *encrypted;
    TCHAR str[17] = {0}, temp[17] = {0};
    int length = GetWindowTextLength(GetDlgItem(hwnd, IDC_MAIN_TEXT)) + 1;
    int i = 0, x = 0;
    unsigned expkey[128];
    
    if (length > 0)
    {
        txt = malloc((length + 1) * sizeof(TCHAR));
        encrypted = malloc((length + 1) * sizeof(TCHAR));
        
        GetDlgItemText(hwnd, IDC_MAIN_TEXT, txt, length);
        
        while (txt[i] != 0)
        {
            for (x = 0; x <= 15; x++)
            {
                str[x] = txt[i];
                ++i;
            }
            Encrypt(str, expkey, temp);
            strcat(encrypted, temp);
        }
        
        SetDlgItemText(hwnd, IDC_MAIN_TEXT, encrypted);
        free(txt);
        free(encrypted);
    }
    else
    {
        MessageBox(NULL, "There was no text entered.\nIf you want to encrypt something,\nplease provide the text to do so.",
          "Error", MB_OK | MB_ICONEXCLAMATION);
    }
}
void DecEdit(HWND hwnd)
{
    TCHAR *txt, *decrypted;
    TCHAR str[17] = {0}, temp[17] = {0};
    int length = GetWindowTextLength(GetDlgItem(hwnd, IDC_MAIN_TEXT)) + 1;
    int i = 0, x = 0;
    unsigned expkey[128];
    
    if (length > 0)
    {
        txt = malloc((length + 1) * sizeof(TCHAR));
        decrypted = malloc((length + 1) * sizeof(TCHAR));
        
        GetDlgItemText(hwnd, IDC_MAIN_TEXT, txt, length);
        
        while (txt[i] != 0)
        {
            for (x = 0; x <= 15; x++)
            {
                str[x] = txt[i];
                ++i;
            }
            Decrypt(str, expkey, temp);
            strcat(decrypted, temp);
        }
        
        SetDlgItemText(hwnd, IDC_MAIN_TEXT, decrypted);
        free(txt);
        free(decrypted);
    }
    else
    {
        MessageBox(NULL, "There was no text entered.\nIf you want to encrypt something,\nplease provide the text to do so.",
          "Error", MB_OK | MB_ICONEXCLAMATION);
    }
}

i added the second functions to a dif. text editor because i didn't want any of the extra's i'd added to the first program, i wanted it as bare as i could get it so thats why the ID's of the edit's are different.
any ideas whats going wrong? thanks

JaWiB · 03-16-2006, 06:38 PM

Code:

 while (/*pszText[i] != 0 && */i <= dwTextLength)
               {
                     for (x = 0; x <= 15; x++)
                     {
                         str[x] = pszText[i];
                         ++i;
                     }
                     Encrypt(str, expkey, temp);
                     strcat(encrypted, temp);
               }

What happens here if the text isn't a multiple of 16? You'll overrun the bounds of your pszText array

willc0de4food · 03-16-2006, 08:21 PM

hmm...thats true. i forgot about that fact, lol

and the first part of the while wasn't supposed to be commented out, i was just trying different things.

here's my update while() statement:

Code:

while (pszText[i] != 0 && i <= dwTextLength)
               {
                     /* the Encrypt() and Decrypt() functions can only take strings
                      * with a max size of 16 chars at a time.
                      */
                     for (x = 0; x <= 15; x++)
                     {
                         /* so we dont overrun the bounds of pszText, test to see
                          * if the current position is null before copying.
                          */
                         if (pszText[i] != 0)
                         {
                             str[x] = pszText[i];
                             ++i;
                         }
                         else
                             break;
                     }
                     Encrypt(str, expkey, temp);
                     strcat(encrypted, temp);
                     /* re-initialize str so theres nothing remaining for the next run */
                     x = 0;
                     while (x <= 15)
                     {
                           str[x] = 0;
                           ++x;
                     }
               }

03-16-2006, 06:38 PM	#2
JaWiB carry on Join Date: Feb 2003 Location: Seattle, WA Posts: 1,971	Code: while (/pszText[i] != 0 && /i <= dwTextLength) { for (x = 0; x <= 15; x++) { str[x] = pszText[i]; ++i; } Encrypt(str, expkey, temp); strcat(encrypted, temp); } What happens here if the text isn't a multiple of 16? You'll overrun the bounds of your pszText array __________________ "Think not but that I know these things; or think I know them not: not therefore am I short Of knowing what I ought." -John Milton, Paradise Regained (1671) "Work hard and it might happen." -XSquared
JaWiB is offline

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

Similar Threads
Thread	Thread Starter	Forum	Replies	Last Post
Appending text to an edit control	dit6a9	Windows Programming	3	08-13-2004 09:52 PM
endless edit control	ZerOrDie	Windows Programming	3	03-21-2003 02:51 AM
Controlling an edit control	master5001	Windows Programming	2	10-16-2001 03:08 PM
Edit control	The15th	Windows Programming	2	09-25-2001 12:36 PM
Rich edit control example Win API	Echidna	Windows Programming	1	09-17-2001 02:12 AM