openssl 설치기와 질문입니다. qt(mingw32) + window7(64bit)

#include <stdio.h>
#include <string.h>
 
#include <openssl/aes.h>
 
int main(int argc, char *argv[])
{
	unsigned char plaintext[] = "Hello World!";
	unsigned char key[16]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F };
	unsigned char ciphertext[16];
	unsigned char decryptedtext[16];
	AES_KEY ekey, dkey;
 
	AES_set_encrypt_key(key,128,&ekey);
	AES_set_decrypt_key(key,128,&dkey);
 
	printf("Plain Text : %s\n",plaintext);
 
	AES_encrypt(plaintext, ciphertext,&ekey);
	printf("Ciphertext : ");
	for(int i=0 ; i<16 ; i++)
		printf("%02x",ciphertext[i]);
	printf("\n");
 
	AES_decrypt(ciphertext, decryptedtext,&dkey);
	printf("Decryptedtext : %s \n",decryptedtext);
 
	return 0;
}

LIBS += -lcrypto
 
CONFIG+=console
 
SOURCES += main.cpp

C:\c++qt_test\opensslaes-build-desktop\debug>opensslaes.exe
Plain Text : Hello World!
Ciphertext : ebb278425bfe07b9e9af0793ac1bf033
Decryptedtext : Hello World!

/**
  AES encryption/decryption demo program using OpenSSL EVP apis
  gcc -Wall openssl_aes.c -lcrypto
 
  this is public domain code.
 
  Saju Pillai (saju.pillai@gmail.com)
**/
 
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/evp.h>
#include <openssl/aes.h>
 
/**
 * Create an 256 bit key and IV using the supplied key_data. salt can be added for taste.
 * Fills in the encryption and decryption ctx objects and returns 0 on success
 **/
int aes_init(unsigned char *key_data, int key_data_len, unsigned char *salt, EVP_CIPHER_CTX *e_ctx,
			 EVP_CIPHER_CTX *d_ctx)
{
  int i, nrounds = 5;
  unsigned char key[32], iv[32];
 
  /*
   * Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash the supplied key material.
   * nrounds is the number of times the we hash the material. More rounds are more secure but
   * slower.
   */
  i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt, key_data, key_data_len, nrounds, key, iv);
  if (i != 32) {
	printf("Key size is %d bits - should be 256 bits\n", i);
	return -1;
  }
 
  EVP_CIPHER_CTX_init(e_ctx);
  EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, key, iv);
  EVP_CIPHER_CTX_init(d_ctx);
  EVP_DecryptInit_ex(d_ctx, EVP_aes_256_cbc(), NULL, key, iv);
 
  return 0;
}
 
/*
 * Encrypt *len bytes of data
 * All data going in & out is considered binary (unsigned char[])
 */
unsigned char *aes_encrypt(EVP_CIPHER_CTX *e, unsigned char *plaintext, int *len)
{
  /* max ciphertext len for a n bytes of plaintext is n + AES_BLOCK_SIZE -1 bytes */
  int c_len = *len + AES_BLOCK_SIZE, f_len = 0;
  unsigned char *ciphertext = (unsigned char *)malloc(c_len);
 
  /* allows reusing of 'e' for multiple encryption cycles */
  EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL);
 
  /* update ciphertext, c_len is filled with the length of ciphertext generated,
	*len is the size of plaintext in bytes */
  EVP_EncryptUpdate(e, ciphertext, &c_len, plaintext, *len);
 
  /* update ciphertext with the final remaining bytes */
  EVP_EncryptFinal_ex(e, ciphertext+c_len, &f_len);
 
  *len = c_len + f_len;
  return ciphertext;
}
 
/*
 * Decrypt *len bytes of ciphertext
 */
unsigned char *aes_decrypt(EVP_CIPHER_CTX *e, unsigned char *ciphertext, int *len)
{
  /* plaintext will always be equal to or lesser than length of ciphertext*/
  int p_len = *len, f_len = 0;
  unsigned char *plaintext = (unsigned char *)malloc(p_len);
 
  EVP_DecryptInit_ex(e, NULL, NULL, NULL, NULL);
  EVP_DecryptUpdate(e, plaintext, &p_len, ciphertext, *len);
  EVP_DecryptFinal_ex(e, plaintext+p_len, &f_len);
 
  *len = p_len + f_len;
  return plaintext;
}
 
int main(int argc, char **argv)
{
  /* "opaque" encryption, decryption ctx structures that libcrypto uses to record
	 status of enc/dec operations */
  EVP_CIPHER_CTX en, de;
 
  /* 8 bytes to salt the key_data during key generation. This is an example of
	 compiled in salt. We just read the bit pattern created by these two 4 byte
	 integers on the stack as 64 bits of contigous salt material -
	 ofcourse this only works if sizeof(int) >= 4 */
  unsigned int salt[] = {12345, 54321};
  unsigned char *key_data;
  int key_data_len, i;
  char *input[] = {"a", "abcd", "this is a test", "this is a bigger test",
				   "\nWho are you ?\nI am the 'Doctor'.\n'Doctor' who ?\nPrecisely!",
				   NULL};
 
  /* the key_data is read from the argument list */
  key_data = (unsigned char *)argv[1];
  key_data_len = strlen(argv[1]);
 
  /* gen key and iv. init the cipher ctx object */
  if (aes_init(key_data, key_data_len, (unsigned char *)&salt, &en, &de)) {
	printf("Couldn't initialize AES cipher\n");
	return -1;
  }
 
  /* encrypt and decrypt each input string and compare with the original */
  for (i = 0; input[i]; i++) {
	char *plaintext;
	unsigned char *ciphertext;
	int olen, len;
 
	/* The enc/dec functions deal with binary data and not C strings. strlen() will
	   return length of the string without counting the '\0' string marker. We always
	   pass in the marker byte to the encrypt/decrypt functions so that after decryption
	   we end up with a legal C string */
	olen = len = strlen(input[i])+1;
 
	ciphertext = aes_encrypt(&en, (unsigned char *)input[i], &len);
	plaintext = (char *)aes_decrypt(&de, ciphertext, &len);
 
	if (strncmp(plaintext, input[i], olen))
	  printf("FAIL: enc/dec failed for \"%s\"\n", input[i]);
	else
	  printf("OK: enc/dec ok for \"%s\"\n", plaintext);
 
	free(ciphertext);
	free(plaintext);
  }
 
  EVP_CIPHER_CTX_cleanup(&en);
  EVP_CIPHER_CTX_cleanup(&de);
 
  return 0;
}