Win32 Newbie: Cast problem

Question

lukethedrifter 0 Newbie Poster

15 Years Ago

Hello:
Anyone know of an easy way to cast the unsigned char in[16] in the below code to an LPCWSTR using just the CRT? I tried swprintf but it wasn't working. I've been googling this for a week and appreciate the help.

/*  
******************************************************************  
**       Advanced Encryption Standard implementation in C.      **  
**       By Niyaz PK                                            **  
**       E-mail: niyazpk@gmail.com                              **  
**       Downloaded from Website: www.hoozi.com                 **  
******************************************************************  
This is the source code for encryption using the latest AES algorithm.  
******************************************************************  
*/  
  
// Include stdio.h for standard input/output.   
// Used for giving output to the screen.   
#include<stdio.h>   
  
// The number of columns comprising a state in AES. This is a constant in AES. Value=4   
#define Nb 4   
  
// The number of rounds in AES Cipher. It is simply initiated to zero. The actual value is recieved in the program.   
int Nr=0;   
  
// The number of 32 bit words in the key. It is simply initiated to zero. The actual value is recieved in the program.   
int Nk=0;   
  
// in - it is the array that holds the plain text to be encrypted.   
// out - it is the array that holds the output CipherText after encryption.   
// state - the array that holds the intermediate results during encryption.   
unsigned char in[16], out[16], state[4][4];   
  
// The array that stores the round keys.   
unsigned char RoundKey[240];   
  
// The Key input to the AES Program   
unsigned char Key[32];   
  
int getSBoxValue(int num)   
{   
    int sbox[256] =   {   
    //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F   
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0   
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1   
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2   
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3   
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4   
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5   
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6   
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7   
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8   
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9   
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A   
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B   
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C   
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D   
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E   
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; //F   
    return sbox[num];   
}   
  
// The round constant word array, Rcon[i], contains the values given by    
// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(28)   
// Note that i starts at 1, not 0).   
int Rcon[255] = {   
    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,    
    0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,    
    0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,    
    0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,    
    0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,    
    0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,    
    0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,    
    0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,    
    0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,    
    0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,    
    0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,    
    0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,    
    0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,    
    0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,    
    0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,    
    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb  };   
  
// This function produces Nb(Nr+1) round keys. The round keys are used in each round to encrypt the states.    
void KeyExpansion()   
{   
    int i,j;   
    unsigned char temp[4],k;   
       
    // The first round key is the key itself.   
    for(i=0;i<Nk;i++)   
    {   
        RoundKey[i*4]=Key[i*4];   
        RoundKey[i*4+1]=Key[i*4+1];   
        RoundKey[i*4+2]=Key[i*4+2];   
        RoundKey[i*4+3]=Key[i*4+3];   
    }   
  
    // All other round keys are found from the previous round keys.   
    while (i < (Nb * (Nr+1)))   
    {   
        for(j=0;j<4;j++)   
        {   
            temp[j]=RoundKey[(i-1) * 4 + j];   
        }   
        if (i % Nk == 0)   
        {   
            // This function rotates the 4 bytes in a word to the left once.   
            // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]   
  
            // Function RotWord()   
            {   
                k = temp[0];   
                temp[0] = temp[1];   
                temp[1] = temp[2];   
                temp[2] = temp[3];   
                temp[3] = k;   
            }   
  
            // SubWord() is a function that takes a four-byte input word and    
            // applies the S-box to each of the four bytes to produce an output word.   
  
            // Function Subword()   
            {   
                temp[0]=getSBoxValue(temp[0]);   
                temp[1]=getSBoxValue(temp[1]);   
                temp[2]=getSBoxValue(temp[2]);   
                temp[3]=getSBoxValue(temp[3]);   
            }   
  
            temp[0] =  temp[0] ^ Rcon[i/Nk];   
        }   
        else if (Nk > 6 && i % Nk == 4)   
        {   
            // Function Subword()   
            {   
                temp[0]=getSBoxValue(temp[0]);   
                temp[1]=getSBoxValue(temp[1]);   
                temp[2]=getSBoxValue(temp[2]);   
                temp[3]=getSBoxValue(temp[3]);   
            }   
        }   
        RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];   
        RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];   
        RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];   
        RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];   
        i++;   
    }   
}   
  
// This function adds the round key to state.   
// The round key is added to the state by an XOR function.   
void AddRoundKey(int round)    
{   
    int i,j;   
    for(i=0;i<4;i++)   
    {   
        for(j=0;j<4;j++)   
        {   
            state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];   
        }   
    }   
}   
  
// The SubBytes Function Substitutes the values in the   
// state matrix with values in an S-box.   
void SubBytes()   
{   
    int i,j;   
    for(i=0;i<4;i++)   
    {   
        for(j=0;j<4;j++)   
        {   
            state[i][j] = getSBoxValue(state[i][j]);   
  
        }   
    }   
}   
  
// The ShiftRows() function shifts the rows in the state to the left.   
// Each row is shifted with different offset.   
// Offset = Row number. So the first row is not shifted.   
void ShiftRows()   
{   
    unsigned char temp;   
  
    // Rotate first row 1 columns to left       
    temp=state[1][0];   
    state[1][0]=state[1][1];   
    state[1][1]=state[1][2];   
    state[1][2]=state[1][3];   
    state[1][3]=temp;   
  
    // Rotate second row 2 columns to left       
    temp=state[2][0];   
    state[2][0]=state[2][2];   
    state[2][2]=temp;   
  
    temp=state[2][1];   
    state[2][1]=state[2][3];   
    state[2][3]=temp;   
  
    // Rotate third row 3 columns to left   
    temp=state[3][0];   
    state[3][0]=state[3][3];   
    state[3][3]=state[3][2];   
    state[3][2]=state[3][1];   
    state[3][1]=temp;   
}   
  
// xtime is a macro that finds the product of {02} and the argument to xtime modulo {1b}     
#define xtime(x)   ((x<<1) ^ (((x>>7) & 1) * 0x1b))   
  
// MixColumns function mixes the columns of the state matrix   
// The method used may look complicated, but it is easy if you know the underlying theory.   
// Refer the documents specified above.   
void MixColumns()   
{   
    int i;   
    unsigned char Tmp,Tm,t;   
    for(i=0;i<4;i++)   
    {       
        t=state[0][i];   
        Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i] ;   
        Tm = state[0][i] ^ state[1][i] ; Tm = xtime(Tm); state[0][i] ^= Tm ^ Tmp ;   
        Tm = state[1][i] ^ state[2][i] ; Tm = xtime(Tm); state[1][i] ^= Tm ^ Tmp ;   
        Tm = state[2][i] ^ state[3][i] ; Tm = xtime(Tm); state[2][i] ^= Tm ^ Tmp ;   
        Tm = state[3][i] ^ t ; Tm = xtime(Tm); state[3][i] ^= Tm ^ Tmp ;   
    }   
}   
  
// Cipher is the main function that encrypts the PlainText.   
void Cipher()   
{   
    int i,j,round=0;   
  
    //Copy the input PlainText to state array.   
    for(i=0;i<4;i++)   
    {   
        for(j=0;j<4;j++)   
        {   
            state[j][i] = in[i*4 + j];   
        }   
    }   
  
    // Add the First round key to the state before starting the rounds.   
    AddRoundKey(0);    
       
    // There will be Nr rounds.   
    // The first Nr-1 rounds are identical.   
    // These Nr-1 rounds are executed in the loop below.   
    for(round=1;round<Nr;round++)   
    {   
        SubBytes();   
        ShiftRows();   
        MixColumns();   
        AddRoundKey(round);   
    }   
       
    // The last round is given below.   
    // The MixColumns function is not here in the last round.   
    SubBytes();   
    ShiftRows();   
    AddRoundKey(Nr);   
  
    // The encryption process is over.   
    // Copy the state array to output array.   
    for(i=0;i<4;i++)   
    {   
        for(j=0;j<4;j++)   
        {   
            out[i*4+j]=state[j][i];   
        }   
    }   
}   
void main()   
{   
    int i;   
  
    // Receive the length of key here.   
    while(Nr!=128 && Nr!=192 && Nr!=256)   
    {   
        printf("Enter the length of Key(128, 192 or 256 only): ");   
        scanf("%d",&Nr);   
    }   
       
    // Calculate Nk and Nr from the received value.   
    Nk = Nr / 32;   
    Nr = Nk + 6;   
  
  
  
// Part 1 is for demonstrative purpose. The key and plaintext are given in the program itself.   
//     Part 1: ********************************************************   
       
    // The array temp stores the key.   
    // The array temp2 stores the plaintext.   
    unsigned char temp[32] = {0x00  ,0x01  ,0x02  ,0x03  ,0x04  ,0x05  ,0x06  ,0x07  ,0x08  ,0x09  ,0x0a  ,0x0b  ,0x0c  ,0x0d  ,0x0e  ,0x0f};   
    unsigned char temp2[32]= {0x00  ,0x11  ,0x22  ,0x33  ,0x44  ,0x55  ,0x66  ,0x77  ,0x88  ,0x99  ,0xaa  ,0xbb  ,0xcc  ,0xdd  ,0xee  ,0xff};   
       
    // Copy the Key and PlainText   
    for(i=0;i<Nk*4;i++)   
    {   
        Key[i]=temp[i];   
        in[i]=temp2[i];   
    }   
  
//           *********************************************************   
  
  
  
  
// Uncomment Part 2 if you need to read Key and PlainText from the keyboard.   
//     Part 2: ********************************************************   
/*  
    //Clear the input buffer  
    flushall();  
 
    //Recieve the Key from the user  
    printf("Enter the Key in hexadecimal: ");  
    for(i=0;i<Nk*4;i++)  
    {  
        scanf("%x",&Key[i]);  
    }  
 
    printf("Enter the PlainText in hexadecimal: ");  
    for(i=0;i<Nb*4;i++)  
    {  
        scanf("%x",&in[i]);  
    }  
*/  
//             ********************************************************   
  
  
    // The KeyExpansion routine must be called before encryption.   
    KeyExpansion();   
  
    // The next function call encrypts the PlainText with the Key using AES algorithm.   
    Cipher();   
  
    // Output the encrypted text.   
    printf("\nText after encryption:\n");   
    for(i=0;i<Nb*4;i++)   
    {   
        printf("%02x ",out[i]);   
    }   
    printf("\n\n");   
}

c

6 Contributors
11 Replies
224 Views
1 Week Discussion Span
Latest Post 15 Years Ago Latest Post by Ancient Dragon

jephthah 1,888 Posting Maven

15 Years Ago

void main()
flushall()
lol()

googling for a week?

are you exaggerating?

cause i just found it in about 30 seconds.

.

Ancient Dragon 5,243 Achieved Level 70

15 Years Ago

>>memset(wText,0,len);
That only sets the first half of the buffer -- what you want is memset(wText, (len * sizeof(wchar_t)); >>should I create a new pointer to convert from the unsigned char[]?
No, just typecase it: int len = strlen((const char *)in)+1

csurfer 422 Posting Pro

15 Years Ago

Don't pin in the whole code every time.Just extract the erroneous part,that way you too will dive deeper into the code and easy for us to analyze too

Reply to this topic

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.

lukethedrifter 0 Newbie Poster · Answer 1 · 2009-05-30T14:15:32+00:00

void main()
flushall()
lol()

googling for a week?
are you exaggerating?
cause i just found it in about 30 seconds.
.

Yes actually more than that. I did see that link and tried it that way but got compiler errors. I might have posted it in the Windows message loop. My background is mechanical, btw.

Hey, I know you are helping out with me, but I have to say that your quick response to making fun of me makes me think you do not like to help people. If I posted the errors returned by compiler will you look?

lukethedrifter 0 Newbie Poster · Answer 2 · 2009-05-30T23:46:59+00:00

void main()
flushall()
lol()

googling for a week?
are you exaggerating?
cause i just found it in about 30 seconds.

.

Here are the compile errors.

c:\documents and settings\marcus.marcus\my documents\visual studio 2008\projects\aes2\aes2\aes2.cpp(344) : error C2664: 'strlen' : cannot convert parameter 1 from 'unsigned char [16]' to 'const char *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
c:\documents and settings\marcus.marcus\my documents\visual studio 2008\projects\aes2\aes2\aes2.cpp(349) : error C2664: 'MultiByteToWideChar' : cannot convert parameter 3 from 'unsigned char [16]' to 'LPCSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

Here is what I did, just replacing wpurl with in. It looks like in should be a pointer? Should I create a new pointer to convert from the unsigned char[]? Thanks for your help by the way. I am just begining unmanaged code:

int len = strlen(in)+1;
	wchar_t *wText = new wchar_t[len];
	if ( wText == 0 )
		return;
	memset(wText,0,len);
	::MultiByteToWideChar(  CP_ACP, NULL,in, -1, wText,len );

lukethedrifter 0 Newbie Poster · Answer 3 · 2009-06-04T06:44:03+00:00

It is compiling now, but I am getting run time errors. The code is below.

What I did was paste the encryption code on the top of a new project, and created a new function, testAES(), to be called on left mouse button down. I put the memset in that function, but when I click I get the following errors:

Unhandled exception at 0x7c809dea in aes2.exe: 0xC0000005: Access violation reading location 0x00000011.

I know this a RTFM moment, and if you want to just post links to resolve that would be fine. I'm at the end of my rope again! Your help though is greatly appreciated.

// aes2.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "aes2.h"
#include <string>
using std::string;

#define MAX_LOADSTRING 100



// The number of columns comprising a state in AES. This is a constant in AES. Value=4
#define Nb 4

// The number of rounds in AES Cipher. It is simply initiated to zero. The actual value is recieved in the program.
int Nr=0;
string message;

// The number of 32 bit words in the key. It is simply initiated to zero. The actual value is recieved in the program.
int Nk=0;

// in - it is the array that holds the plain text to be encrypted.
// out - it is the array that holds the key for encryption.
// state - the array that holds the intermediate results during encryption.
unsigned char in[16], out[16], state[4][4];

// The array that stores the round keys.
unsigned char RoundKey[240];

// The Key input to the AES Program
unsigned char Key[32];

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

// The round constant word array, Rcon[i], contains the values given by 
// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(28)
// Note that i starts at 1, not 0).
int Rcon[255] = {
	0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 
	0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 
	0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 
	0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 
	0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 
	0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 
	0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 
	0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 
	0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 
	0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 
	0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 
	0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 
	0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 
	0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 
	0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 
	0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb  };

// This function produces Nb(Nr+1) round keys. The round keys are used in each round to encrypt the states. 
void KeyExpansion()
{
	int i,j;
	unsigned char temp[4],k;
	
	// The first round key is the key itself.
	for(i=0;i<Nk;i++)
	{
		RoundKey[i*4]=Key[i*4];
		RoundKey[i*4+1]=Key[i*4+1];
		RoundKey[i*4+2]=Key[i*4+2];
		RoundKey[i*4+3]=Key[i*4+3];
	}

	// All other round keys are found from the previous round keys.
	while (i < (Nb * (Nr+1)))
	{
					for(j=0;j<4;j++)
					{
						temp[j]=RoundKey[(i-1) * 4 + j];
					}
					if (i % Nk == 0)
					{
						// This function rotates the 4 bytes in a word to the left once.
						// [a0,a1,a2,a3] becomes [a1,a2,a3,a0]

						// Function RotWord()
						{
							k = temp[0];
							temp[0] = temp[1];
							temp[1] = temp[2];
							temp[2] = temp[3];
							temp[3] = k;
						}

						// SubWord() is a function that takes a four-byte input word and 
						// applies the S-box to each of the four bytes to produce an output word.

						// Function Subword()
						{
							temp[0]=getSBoxValue(temp[0]);
							temp[1]=getSBoxValue(temp[1]);
							temp[2]=getSBoxValue(temp[2]);
							temp[3]=getSBoxValue(temp[3]);
						}

						temp[0] =  temp[0] ^ Rcon[i/Nk];
					}
					else if (Nk > 6 && i % Nk == 4)
					{
						// Function Subword()
						{
							temp[0]=getSBoxValue(temp[0]);
							temp[1]=getSBoxValue(temp[1]);
							temp[2]=getSBoxValue(temp[2]);
							temp[3]=getSBoxValue(temp[3]);
						}
					}
					RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];
					RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];
					RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];
					RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];
					i++;
	}
}

// This function adds the round key to state.
// The round key is added to the state by an XOR function.
void AddRoundKey(int round) 
{
	int i,j;
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];
		}
	}
}

// The SubBytes Function Substitutes the values in the
// state matrix with values in an S-box.
void SubBytes()
{
	int i,j;
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			state[i][j] = getSBoxValue(state[i][j]);

		}
	}
}

// The ShiftRows() function shifts the rows in the state to the left.
// Each row is shifted with different offset.
// Offset = Row number. So the first row is not shifted.
void ShiftRows()
{
	unsigned char temp;

	// Rotate first row 1 columns to left	
	temp=state[1][0];
	state[1][0]=state[1][1];
	state[1][1]=state[1][2];
	state[1][2]=state[1][3];
	state[1][3]=temp;

	// Rotate second row 2 columns to left	
	temp=state[2][0];
	state[2][0]=state[2][2];
	state[2][2]=temp;

	temp=state[2][1];
	state[2][1]=state[2][3];
	state[2][3]=temp;

	// Rotate third row 3 columns to left
	temp=state[3][0];
	state[3][0]=state[3][3];
	state[3][3]=state[3][2];
	state[3][2]=state[3][1];
	state[3][1]=temp;
}

// xtime is a macro that finds the product of {02} and the argument to xtime modulo {1b}  
#define xtime(x)   ((x<<1) ^ (((x>>7) & 1) * 0x1b))

// MixColumns function mixes the columns of the state matrix
void MixColumns()
{
	int i;
	unsigned char Tmp,Tm,t;
	for(i=0;i<4;i++)
	{	
		t=state[0][i];
		Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i] ;
		Tm = state[0][i] ^ state[1][i] ; Tm = xtime(Tm); state[0][i] ^= Tm ^ Tmp ;
		Tm = state[1][i] ^ state[2][i] ; Tm = xtime(Tm); state[1][i] ^= Tm ^ Tmp ;
		Tm = state[2][i] ^ state[3][i] ; Tm = xtime(Tm); state[2][i] ^= Tm ^ Tmp ;
		Tm = state[3][i] ^ t ; Tm = xtime(Tm); state[3][i] ^= Tm ^ Tmp ;
	}
}

// Cipher is the main function that encrypts the PlainText.
void Cipher()
{
	int i,j,round=0;

	//Copy the input PlainText to state array.
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			state[j][i] = in[i*4 + j];
		}
	}

	// Add the First round key to the state before starting the rounds.
	AddRoundKey(0); 
	
	// There will be Nr rounds.
	// The first Nr-1 rounds are identical.
	// These Nr-1 rounds are executed in the loop below.
	for(round=1;round<Nr;round++)
	{
		SubBytes();
		ShiftRows();
		MixColumns();
		AddRoundKey(round);
	}
	
	// The last round is given below.
	// The MixColumns function is not here in the last round.
	SubBytes();
	ShiftRows();
	AddRoundKey(Nr);

	// The encryption process is over.
	// Copy the state array to output array.
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			out[i*4+j]=state[j][i];
		}
	}
}

std::wstring s2ws(const std::string& s){  
	int len;
	int slength = (int)s.length() + 1;
	len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
	wchar_t* buf = new wchar_t[len];
	MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
	std::wstring r(buf);
	delete[] buf;
	return r;
}

void testAES()
{
	int i;

	/*// Recieve the length of key here.
	while(Nr!=128 && Nr!=192 && Nr!=256)
	{
		printf("Enter the length of Key(128, 192 or 256 only): ");
		scanf("%d",&Nr);
	}*/
	Nr=128;
	
	// Calculate Nk and Nr from the recieved value.
	Nk = Nr / 32;
	Nr = Nk + 6;



// Part 1 is for demonstrative purpose. The key and plaintext are given in the program itself.
// 	Part 1: ********************************************************

	// The array temp stores the key.
	// The array temp2 stores the plaintext.
	unsigned char temp[32] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
	unsigned char temp2[32]= {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff};
	// Copy the Key and PlainText
	for(i=0;i<Nk*4;i++)
	{
		Key[i]=temp[i];
		in[i]=temp2[i];
	}

//	       *********************************************************




// Uncomment Part 2 if you need to read key and plaintext from the keyboard.
// 	Part 2: ********************************************************
/*
	//Clear the input buffer
	flushall();

	//Recieve the key from the user
	printf("Enter the Key in hexadecimal: ");
	for(i=0;i<Nk*4;i++)
	{
		scanf("%x",&Key[i]);
	}

	printf("Enter the PlainText in hexadecimal: ");
	for(i=0;i<Nb*4;i++)
	{
		scanf("%x",&in[i]);
	}
*/
// 	        ********************************************************


	// The KeyExpansion routine must be called before encryption.
	KeyExpansion();

	// The next function call encrypts the PlainText with the Key using AES algorithm.
	Cipher();
	int len = strlen((const char *)in)+1;
	wchar_t *wText = new wchar_t[len];
	memset(wText,0, (len * sizeof(wchar_t)));
  if ( wText == 0 )
    return;
  ::MultiByteToWideChar(  CP_ACP, NULL,(LPCSTR)in[1], -1, wText,len );



	MessageBox(
        NULL,
		wText,
		L"test",
		MB_ICONWARNING | MB_CANCELTRYCONTINUE | MB_DEFBUTTON2
    );
	// Output the encrypted text.
	/*printf("\nText after encryption:\n");
	for(i=0;i<Nb*4;i++)
	{
		printf("%02x ",out[i]);
	}
	printf("\n\n");*/
}







// Global Variables:
HINSTANCE hInst;								// current instance
TCHAR szTitle[MAX_LOADSTRING];					// The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name

// Forward declarations of functions included in this code module:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;

	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_AES2, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_AES2));

	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_AES2));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_AES2);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassEx(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Store instance handle in our global variable

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;

	switch (message)
	{
	case WM_LBUTTONDOWN:    // <-
		testAES();
	break;

	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Parse the menu selections:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);
		// TODO: Add any drawing code here...
		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

ArkM 1,090 Postaholic · Answer 4 · 2009-06-04T15:06:03+00:00

No opened stdin and stdout streams in Win GDI applications (null pointers). You can't use scanf and printf functions in the program.
See, for example: http://blogs.msdn.com/oldnewthing/archive/2009/01/01/9259142.aspx

lukethedrifter 0 Newbie Poster · Answer 5 · 2009-06-06T05:37:15+00:00

I thought all the console stuff was commented out? This isn't stdin, is it?

std::wstring r(buf);

Could you tell me what line you see the console stuff at? It should be commented.

kvprajapati 1,826 Posting Genius Team Colleague · Answer 6 · 2009-06-06T11:20:39+00:00

Why you use (LPCSTR)in[1] (third argument of MultiByteToWideChar)?

int len = strlen((const char *)in)+1;
  wchar_t *wText = new wchar_t[len];
  memset(wText,0, (len * sizeof(wchar_t)));
  if ( wText == 0 )
       return 0;
  ::MultiByteToWideChar(  CP_ACP, NULL,(LPCSTR)in[1], -1, wText,len );

It should be,

(LPCSTR)in
  // or
  (const char *)in

Ancient Dragon 5,243 Achieved Level 70 Team Colleague Featured Poster · Answer 7 · 2009-06-06T17:35:47+00:00

I thought all the console stuff was commented out? This isn't stdin, is it?
std::wstring r(buf);
Could you tell me what line you see the console stuff at? It should be commented.

No -- what you posted is C++, not C. C doesn't know a thing about STL.

Ancient Dragon 5,243 Achieved Level 70 Team Colleague Featured Poster · Answer 8 · 2009-06-06T17:43:21+00:00

Hello:
Anyone know of an easy way to cast the unsigned char in[16] in the below code to an LPCWSTR using just the CRT? I tried swprintf but it wasn't working. I've been googling this for a week and appreciate the help.

Sorry but I should have mentioned this before. Why did it take you over a week to come up this this simple solution? Note that "%S" (capital S) will convert from char* to wchar_t*. There are, of course, other functions that will also do the conversion.

int main(void)
{
    char world[] = "Hello World";
    wchar_t wworld[40];
    swprintf(wworld, L"%S", world);

    return 0;
}