help needed with edit control & encryption

This is a discussion on help needed with edit control & encryption within the Windows Programming forums, part of the Platform Specific Boards category; hey, i'm having some big problems with this for some reason and i dont know why but my problem is ...

  1. #1
    Shibby willc0de4food's Avatar
    Join Date
    Mar 2005
    Location
    MI
    Posts
    378

    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, 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
    Registered Linux User #380033. Be counted: http://counter.li.org

  2. #2
    carry on JaWiB's Avatar
    Join Date
    Feb 2003
    Location
    Seattle, WA
    Posts
    1,972
    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

  3. #3
    Shibby willc0de4food's Avatar
    Join Date
    Mar 2005
    Location
    MI
    Posts
    378
    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;
                         }
                   }
    Last edited by willc0de4food; 03-16-2006 at 08:36 PM.
    Registered Linux User #380033. Be counted: http://counter.li.org

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Appending text to an edit control
    By dit6a9 in forum Windows Programming
    Replies: 3
    Last Post: 08-13-2004, 10:52 PM
  2. endless edit control
    By ZerOrDie in forum Windows Programming
    Replies: 3
    Last Post: 03-21-2003, 02:51 AM
  3. Controlling an edit control
    By master5001 in forum Windows Programming
    Replies: 2
    Last Post: 10-16-2001, 04:08 PM
  4. Edit control
    By The15th in forum Windows Programming
    Replies: 2
    Last Post: 09-25-2001, 01:36 PM
  5. Rich edit control example Win API
    By Echidna in forum Windows Programming
    Replies: 1
    Last Post: 09-17-2001, 03:12 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21