MSVC++ DLL/LIB project - A cryptographic library for exchanging traffic with a web server
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Debug
Release
cryptone
lib32
lib64
x64
.gitattributes
.gitignore
LICENSE
README.md
cryptone.sln
cryptone.suo

README.md

Cryptone

MSVC++ DLL/LIB project - A cryptographic library for exchanging traffic with a web server
Used lib/dll OpenSSL 1.1.0 and Zlib 1.2.7

crypton.dll use:
Functions: AES-256 Encrypt/Decrypt binary message/binary data (any size)
Functions RSA-2048/sha256 Generate Private/Public/Certificate to memory or to files
Functions: RSA-2048/sha256 Crypt/Decrypt message (max 240 byte message)
Functions: RSA-2048/sha256 Crypt/Decrypt any binary file size to output file
Functions: Zlib stream deflate(zip)/inflate(unzip) message/binary data
Functions: Convert char*->HexChar*/HexChar*->char*, example "123"->"313233", "313233"->"123"
Functions: char*->base64, base64->char*

/*
AES-256 Encrypt data by 
using openssl lib with given keys:
	unsigned char * key256 = (unsigned char *)"11112222333344445555666677778888"; // îáÿçàòåëüíî 32 ñèìâîëà (256 áèò)
	unsigned char * iv128 = (unsigned char *)"1111333355557777"; // îáÿçàòåëüíî 16 ñèìâîëîâ (128 áèò)
return crypted in unsigned char*
*/
unsigned char* aes256_encryptC(unsigned char* data, int dataLen, unsigned char * key, unsigned char * iv, int &cryptedlen);
/*
AES-256 Decrypt data by 
using openssl lib with given keys:
	unsigned char * key256 = (unsigned char *)"11112222333344445555666677778888"; // îáÿçàòåëüíî 32 ñèìâîëà (256 áèò)
	unsigned char * iv128 = (unsigned char *)"1111333355557777"; // îáÿçàòåëüíî 16 ñèìâîëîâ (128 áèò)
	return decrypted in unsigned char*
*/
unsigned char* aes256_decryptC(unsigned char* cipher, int cipherLen, unsigned char * key, unsigned char * iv, int &decryptLen);
//Generate new RSA-2048/sha256 keys Private/Public/Certificate and save it to files
//Set IfFilesExistsNotRewriteset to false for overwrite files
//if Error return false
bool GenRSAKeysPhp( char* privateFile, char* publicFile, char* CertificateFile, bool IfFilesExistsNotRewrite );
//Generate new RSA-2048/sha256 RSA key Private/Public/Certificate and save it memory
//if Error return false
bool GenRSAKeysToMem( unsigned char** PrivateKeyStr, unsigned char** PublicKeyStr, unsigned char** CertificateKeyStr );
//Ecrypt data by RSA-2048/sha256 Public key
// unsigned char *encrypted - must be allocated before call public_encrypt()
// return encrypted size or -1 if error
int public_encrypt( unsigned char * data,int data_len,unsigned char * key, unsigned char *encrypted );
//Decrypt data by RSA-2048/sha256 Private key
// unsigned char *decrypted - must be allocated before call private_decrypt()
// return encrypted size or -1 if error
int private_decrypt( unsigned char * enc_data,int data_len,unsigned char * key, unsigned char *decrypted );
//Encrypt data by RSA-2048/sha256 Private Key
// unsigned char *encrypted - must be allocated before call private_encrypt()
// return encrypted size or -1 if error
int private_encrypt( unsigned char * data,int data_len,unsigned char * key, unsigned char *encrypted );
//Dencrypt data by RSA-2048/sha256 Public Key
// unsigned char *decrypted - must be allocated before call public_decrypt()
// return encrypted size or -1 if error
int public_decrypt( unsigned char * enc_data,int data_len,unsigned char * key, unsigned char *decrypted );
//Encrypt any size InFile with RSA-2048/sha256 Private key and put it in the OutFile 
//On error return 0, if ok return 1
DWORD CryptFilePrivate256( char* FileName, char* NewFileName, unsigned char *privateKey );
//Encrypt any size InFile with RSA-2048/sha256 Public key and put it in the OutFile 
//On error return 0, if ok return 1
DWORD CryptFilePublic256( char* FileName, char* NewFileName, unsigned char *publicKey )
//Dencrypt any size InFile with RSA-2048/sha256 Private key and put it in the OutFile 
//On error return 0, if ok return 1
DWORD DeCryptFilePrivate256( char* FileName, char* NewFileName, unsigned char *privateKey );
//Dencrypt any size InFile with RSA-2048/sha256 Public key and put it in the OutFile 
//On error return 0, if ok return 1
DWORD DeCryptFilePublic256( char* FileName, char* NewFileName, unsigned char *publicKey );
//Compress char*, gzip style using zlib with given compression level
//return compressed data with size in "unzippedLen" or NULL if error
char* compress_stringC( char* strData, int strDataLen, int &zippedLen );
//Decompress char* data by len
//return decompressed data with size in "unzippedLen" or NULL if error
char* decompress_stringC( char* strData, int strDataLen, int &unzippedLen );
//Convert char* hex hex format->char*, for example "313233" in hex -> "123"
//return char* text or NULL if error
char* charHex2char( unsigned char* data, int dataLen );
//Convert char* -> char* in hex format, for example "123" -> "313233" in hex
//return char* text or NULL if error
char* char2charHex ( unsigned char* zip, int size );
//Encode base64 for char* and return new char*
//return base64 string or NULL if error
char* base64Encode( const unsigned char *message, const size_t length );
//Decode base64 for char* and return new char*
//return decoded data size and data in "buffer", On Error return NULL in "buffer"
int base64Decode( const char *b64message, const size_t length, unsigned char **buffer );

Example use:

#include "stdafx.h"
#include <stdio.h>	
#include <windows.h>
#include <math.h>
#include <iostream>
#include <vector>
#include <assert.h>
#include <string.h>
#include <errno.h>
#include <ctime>
#include <string>
#include <iostream>
#include <algorithm>
#include <stdexcept>

typedef unsigned char* ( *aes256_encryptCExp )(  unsigned char* data, int dataLen, unsigned char * key, unsigned char * iv, int &cryptedlen );
typedef unsigned char* ( *aes256_decryptCExp )( unsigned char* cipher, int cipherLen, unsigned char * key, unsigned char * iv, int &decryptLen );
typedef char* ( *base64EncodeExp )( const unsigned char *message, const size_t length );
typedef int   ( *base64DecodeExp )( const char *b64message, const size_t length, unsigned char **buffer );
typedef char* ( *charHex2charExp )( unsigned char* data, int dataLen );
typedef char* ( *char2charHexExp )( unsigned char* data, int dataLen );
typedef char* ( *compress_stringCExp )( char* strData, int strDataLen, int &zippedLen );
typedef char* ( *decompress_stringCExp )( char* strData, int strDataLen, int &unzippedLen );
typedef bool ( *GenRSAKeysPhpExp )( char* privateFile, char* publicFile, char* CertificateFile, bool IfFilesExistsNotRewrite );
typedef bool ( *GenRSAKeysToMemExp )( unsigned char** PrivateKeyStr, unsigned char** PublicKeyStr, unsigned char** CertificateKeyStr );
typedef int ( *public_encryptExp )( unsigned char * data,int data_len,unsigned char * key, unsigned char *encrypted );
typedef int ( *private_decryptExp )( unsigned char * enc_data,int data_len,unsigned char * key, unsigned char *decrypted );
typedef int ( *private_encryptExp )( unsigned char * data,int data_len,unsigned char * key, unsigned char *encrypted );
typedef int ( *public_decryptExp )(unsigned char * enc_data,int data_len,unsigned char * key, unsigned char *decrypted );
typedef DWORD ( *CryptFilePrivate256Exp )( char* FileName, char* NewFileName, unsigned char *privateKey );
typedef DWORD ( *DeCryptFilePrivate256Exp )( char* FileName, char* NewFileName, unsigned char *privateKey );
typedef DWORD ( *CryptFilePublic256Exp )( char* FileName, char* NewFileName, unsigned char *publicKey );
typedef DWORD ( *DeCryptFilePublic256Exp )( char* FileName, char* NewFileName, unsigned char *publicKey );


int _tmain(int argc, _TCHAR* argv[])
{
	aes256_encryptCExp aes256_encryptC = 0;
	aes256_decryptCExp aes256_decryptC = 0;
	base64EncodeExp base64Encode = 0;
	base64DecodeExp base64Decode = 0;
	charHex2charExp charHex2char = 0;
	char2charHexExp char2charHex = 0;
	compress_stringCExp compress_stringC = 0;
	decompress_stringCExp decompress_stringC = 0;
	GenRSAKeysPhpExp GenRSAKeysPhp = 0;
	GenRSAKeysToMemExp GenRSAKeysToMem = 0;
	public_encryptExp public_encrypt = 0;
	private_decryptExp private_decrypt = 0;
	private_encryptExp private_encrypt = 0;
	public_decryptExp public_decrypt = 0;

	CryptFilePrivate256Exp CryptFilePrivate256 = 0;
	DeCryptFilePrivate256Exp DeCryptFilePrivate256 = 0;
	CryptFilePublic256Exp CryptFilePublic256 = 0;
	DeCryptFilePublic256Exp DeCryptFilePublic256 = 0;

	char* cryptone = "cryptone.dll";
	HMODULE hModule = LoadLibraryA(cryptone);
	if(hModule == NULL) 
	{
		printf("Error[%d] load [%s] dll\r\n", GetLastError(), cryptone);
		return 0;
	}

	aes256_encryptC = (aes256_encryptCExp)GetProcAddress(hModule, "aes256_encryptC");
	if(aes256_encryptC == NULL) return 0;
	aes256_decryptC = (aes256_decryptCExp)GetProcAddress(hModule, "aes256_decryptC");
	if(aes256_decryptC == NULL) return 0;
	base64Encode = (base64EncodeExp)GetProcAddress(hModule, "base64Encode");
	if(base64Encode == NULL) return 0;
	base64Decode = (base64DecodeExp)GetProcAddress(hModule, "base64Decode");
	if(base64Decode == NULL) return 0;
	charHex2char = (charHex2charExp)GetProcAddress(hModule, "charHex2char");
	if(charHex2char == NULL) return 0;
	char2charHex = (char2charHexExp)GetProcAddress(hModule, "char2charHex");
	if(char2charHex == NULL) return 0;
	compress_stringC = (compress_stringCExp)GetProcAddress(hModule, "compress_stringC");
	if(compress_stringC == NULL) return 0;
	decompress_stringC = (decompress_stringCExp)GetProcAddress(hModule, "decompress_stringC");
	if(decompress_stringC == NULL) return 0;
	GenRSAKeysPhp = (GenRSAKeysPhpExp)GetProcAddress(hModule, "GenRSAKeysPhp");
	if(GenRSAKeysPhp == NULL) return 0;
	GenRSAKeysToMem = (GenRSAKeysToMemExp)GetProcAddress(hModule, "GenRSAKeysToMem");
	if(GenRSAKeysToMem == NULL) return 0;
	public_encrypt = (public_encryptExp)GetProcAddress(hModule, "public_encrypt");
	if(public_encrypt == NULL) return 0;
	private_decrypt = (private_decryptExp)GetProcAddress(hModule, "private_decrypt");
	if(private_decrypt == NULL) return 0;
	private_encrypt = (private_encryptExp)GetProcAddress(hModule, "private_encrypt");
	if(private_encrypt == NULL) return 0;
	public_decrypt = (public_decryptExp)GetProcAddress(hModule, "public_decrypt");
	if(public_decrypt == NULL) return 0;

	CryptFilePrivate256 = (CryptFilePrivate256Exp)GetProcAddress(hModule, "CryptFilePrivate256");
	if(CryptFilePrivate256 == NULL) return 0;
	DeCryptFilePrivate256 = (DeCryptFilePrivate256Exp)GetProcAddress(hModule, "DeCryptFilePrivate256");
	if(DeCryptFilePrivate256 == NULL) return 0;
	CryptFilePublic256 = (CryptFilePublic256Exp)GetProcAddress(hModule, "CryptFilePublic256");
	if(CryptFilePublic256 == NULL) return 0;
	DeCryptFilePublic256 = (DeCryptFilePublic256Exp)GetProcAddress(hModule, "DeCryptFilePublic256");
	if(DeCryptFilePublic256 == NULL) return 0;

	//Generate RSA keys and save it to files example
	char* PriName = "Private.pem";
	char* PubName = "Public.pem";
	char* CerName = "Certif.pem";
	bool bFlag = false; // if set true - overwrite and generate new public/private keys
    if(GenRSAKeysPhp(PriName, PubName, CerName, bFlag) == false ) return 0;
	
	//Generate RSA keys and save it to memory example
	unsigned char* PrivateKeyStr = NULL;
	unsigned char* PublicKeyStr = NULL;
	unsigned char* CertificateKeyStr = NULL;
    if(GenRSAKeysToMem( &PrivateKeyStr, &PublicKeyStr, &CertificateKeyStr ) == false ) return 0;
	VirtualFree( PrivateKeyStr, 0, MEM_RELEASE );
	VirtualFree( PublicKeyStr, 0, MEM_RELEASE );
	VirtualFree( CertificateKeyStr, 0, MEM_RELEASE );


	//Generate new RSA keys and Encrypt UserFile(any size) with privateKey -> Decrypt UserFile with publicKey and save it to file example
	unsigned char* PrivateKeyStr111 = NULL;
	unsigned char* PublicKeyStr111 = NULL;
	unsigned char* CertificateKeyStr111 = NULL;
	if(GenRSAKeysToMem( &PrivateKeyStr111, &PublicKeyStr111, &CertificateKeyStr111 ) == false ) return 0;
	int fileSize1 = 20548;
	char fileData1[20548];
	memset(fileData1, 'A', fileSize1 );
	char* inFileName1 = "inFile1.txt";
	char* outFileName1 = "outFile1.txt";
	char* outFileName21 = "outFile21.txt";
	FILE* pFile11 = fopen( inFileName1, "wb" );
	fwrite( fileData1, 1, fileSize1, pFile11 );
	if ( ferror( pFile11 ) )
	{
		fclose( pFile11 );
		VirtualFree( PrivateKeyStr111, 0, MEM_RELEASE );
		VirtualFree( PublicKeyStr111, 0, MEM_RELEASE );
		VirtualFree( CertificateKeyStr111, 0, MEM_RELEASE );
		return 0;
	}
	fclose( pFile11 );
	if( CryptFilePublic256( inFileName1, outFileName1, PublicKeyStr111 ) == 0 ) return 0;
	if( DeCryptFilePrivate256( outFileName1, outFileName21, PrivateKeyStr111 ) == 0 ) return 0;
	VirtualFree( PrivateKeyStr111, 0, MEM_RELEASE );
	VirtualFree( PublicKeyStr111, 0, MEM_RELEASE );
	VirtualFree( CertificateKeyStr111, 0, MEM_RELEASE );


	//Generate new RSA keys and Encrypt UserFile(any size) with privateKey -> Decrypt UserFile with publicKey and save it to file example
	unsigned char* PrivateKeyStr11 = NULL;
	unsigned char* PublicKeyStr11 = NULL;
	unsigned char* CertificateKeyStr11 = NULL;
	if(GenRSAKeysToMem( &PrivateKeyStr11, &PublicKeyStr11, &CertificateKeyStr11 ) == false ) return 0;
	int fileSize = 20548;
	char fileData[20548];
	memset(fileData, 'A', fileSize );
	char* inFileName = "inFile.txt";
	char* outFileName = "outFile.txt";
	char* outFileName2 = "outFile2.txt";
	FILE* pFile1 = fopen( inFileName, "wb" );
	fwrite( fileData, 1, fileSize, pFile1 );	
	if ( ferror( pFile1 ) )
	{
		fclose( pFile1 );
		VirtualFree( PrivateKeyStr11, 0, MEM_RELEASE );
		VirtualFree( PublicKeyStr11, 0, MEM_RELEASE );
		VirtualFree( CertificateKeyStr11, 0, MEM_RELEASE );
		return 0;
	}
	fclose( pFile1 );
	if( CryptFilePrivate256( inFileName, outFileName, PrivateKeyStr11 ) == 0 ) return 0;
	if( DeCryptFilePublic256( outFileName, outFileName2, PublicKeyStr11 ) == 0 ) return 0;
	VirtualFree( PrivateKeyStr11, 0, MEM_RELEASE );
	VirtualFree( PublicKeyStr11, 0, MEM_RELEASE );
	VirtualFree( CertificateKeyStr11, 0, MEM_RELEASE );


	//Generate new RSA keys and Encrypt UserData(240 byte max) with privateKey -> Decrypt UserData with publicKey and save it to memory example
	unsigned char* PrivateKeyStr1 = NULL;
	unsigned char* PublicKeyStr1 = NULL;
	unsigned char* CertificateKeyStr1 = NULL;
	if(GenRSAKeysToMem( &PrivateKeyStr1, &PublicKeyStr1, &CertificateKeyStr1 ) == false ) return 0;
	char* uncrypteddata1 = "Hello, world!";
	char* crypteddata1 = (char*)VirtualAlloc(  NULL, 256, MEM_COMMIT, PAGE_READWRITE );
	if(crypteddata1 == NULL) return 0;
	int uncrypteddatalen1 = strlen(uncrypteddata1);
	int icryptedlen1 = private_encrypt( (unsigned char*)uncrypteddata1, uncrypteddatalen1, PrivateKeyStr1, (unsigned char*)crypteddata1 );
	if (icryptedlen1 <= 0) return 0;
	char* decrypteddata1 = (char*)VirtualAlloc(  NULL, 256, MEM_COMMIT, PAGE_READWRITE );
	if(decrypteddata1 == NULL) return 0;
	int idecryptedlen1 = public_decrypt( (unsigned char*)crypteddata1, icryptedlen1, PublicKeyStr1, (unsigned char*)decrypteddata1 );
	if (idecryptedlen1 <= 0) return 0;
	VirtualFree( PrivateKeyStr1, 0, MEM_RELEASE );
	VirtualFree( PublicKeyStr1, 0, MEM_RELEASE );
	VirtualFree( CertificateKeyStr1, 0, MEM_RELEASE );


	//Generate new RSA keys and Encrypt UserData(240 byte max) with publicKey -> Decrypt UserData with privateKey and save it to memory example
	unsigned char* PrivateKeyStr2 = NULL;
	unsigned char* PublicKeyStr2 = NULL;
	unsigned char* CertificateKeyStr2 = NULL;
	if(GenRSAKeysToMem( &PrivateKeyStr2, &PublicKeyStr2, &CertificateKeyStr2 ) == false ) return 0;
	char* uncrypteddata2 = "Hello, world!";
	char* crypteddata2 = (char*)VirtualAlloc(  NULL, 256, MEM_COMMIT, PAGE_READWRITE );
	if(crypteddata2 == NULL) return 0;
	int uncrypteddatalen2 = strlen(uncrypteddata2);
	int icryptedlen2 = public_encrypt( (unsigned char*)uncrypteddata2, uncrypteddatalen2, PublicKeyStr2, (unsigned char*)crypteddata2 );
	if (icryptedlen2 <= 0) return 0;
	char* decrypteddata2 = (char*)VirtualAlloc(  NULL, 256, MEM_COMMIT, PAGE_READWRITE );
	if(decrypteddata2 == NULL) return 0;
	int idecryptedlen2 = private_decrypt( (unsigned char*)crypteddata2, icryptedlen2, PrivateKeyStr2, (unsigned char*)decrypteddata2 );
	if (idecryptedlen2 <= 0) return 0;
	VirtualFree( PrivateKeyStr2, 0, MEM_RELEASE );
	VirtualFree( PublicKeyStr2, 0, MEM_RELEASE );
	VirtualFree( CertificateKeyStr2, 0, MEM_RELEASE );

	//Data zip -> unzip example
	char* zipSrc = "Hello, world:, but when I did this I started getting issues with Valgrind reporting reachable blocks at the end of the program, originating from.";
	int zipSrcLen = strlen(zipSrc);
	int zippedLen = 0;
	int unzippedLen = 0;
	char* ZippedChars = compress_stringC ( zipSrc, zipSrcLen, zippedLen );
	if(ZippedChars == NULL) return 0;
	char* unZippedChars = decompress_stringC( ZippedChars, zippedLen, unzippedLen );
	if(unZippedChars == NULL) return 0;
	VirtualFree( ZippedChars, 0, MEM_RELEASE );
	VirtualFree( unZippedChars, 0, MEM_RELEASE );

	//data -> hexeddata and hexeddata -> data example
	char* dataz = "123456789";
	char* hexed = char2charHex ( (unsigned char*) dataz, strlen(dataz) );
	if(hexed == NULL) return 0;
	char* dehexed = charHex2char( (unsigned char*) hexed, strlen(hexed) );
	if(dehexed == NULL) return 0;
	VirtualFree( hexed, 0, MEM_RELEASE );
	VirtualFree( dehexed, 0, MEM_RELEASE );


	//Aes crypt->decrypt any size data example
	unsigned char * key256 = (unsigned char *)"11112222333344445555666677778888"; // 32 byte (256 bit)
	unsigned char * iv128 = (unsigned char *)"1111333355557777"; // 16 byte (128 bit)
	//example data
	char* data = "helloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAworld";
	int dataLen = strlen(data);
	int cryptedLen = 0;
	int decryptedLen = 0;
	unsigned char *cpp_cipher = aes256_encryptC((unsigned char *)data, dataLen, key256, iv128, cryptedLen);
	if(cpp_cipher == NULL)
	{
		VirtualFree( cpp_cipher, 0, MEM_RELEASE );
		return 0;
	}
	char* base64 = base64Encode( cpp_cipher, cryptedLen );
	if(base64 == NULL)
	{
		VirtualFree( cpp_cipher, 0, MEM_RELEASE );	
		return 0;
	}
	VirtualFree( cpp_cipher, 0, MEM_RELEASE );	
	FILE* pFile = fopen("enc.dat", "wb");
	fwrite(base64, 1, strlen(base64),pFile);
	if ( ferror( pFile ) )
	{
		fclose(pFile);
		VirtualFree( base64, 0, MEM_RELEASE );
		return 0;
	}
	fclose(pFile);	
	unsigned char* debase64 = NULL;
	size_t sLen = strlen(base64);
	int iLen = base64Decode(base64, sLen, &debase64);
	if(debase64 == NULL)
	{
		VirtualFree( base64, 0, MEM_RELEASE );
		return 0;
	}
	VirtualFree( base64, 0, MEM_RELEASE );
	unsigned char *php_cipher = aes256_decryptC(debase64, iLen, key256, iv128, decryptedLen);
	VirtualFree( debase64, 0, MEM_RELEASE );
	if(php_cipher == NULL) return 0;
	FILE* pFileg = fopen("dec.dat", "wb");
	fwrite((char*)php_cipher, 1, decryptedLen, pFileg);
	if ( ferror( pFileg ) )
	{
		fclose(pFileg);
		VirtualFree( php_cipher, 0, MEM_RELEASE );
		return 0;
	}
	fclose(pFileg);
	VirtualFree( php_cipher, 0, MEM_RELEASE );

	return 0;
}