help needed with edit control & encryption
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, [email protected]
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
