C++/VC/MFC字符串/文件加解密
注意:编译时请先安装PSDK最好是将库引用排在第一个位置
//--------------------------------------------------------------------
// In this and all other sample and example code,
// use the following #define and #include statements listed
// under #includes and #defines.
#include <stdio.h>
#include <windows.h>
#include <wincrypt.h>
#define MY_ENCODING_TYPE (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
#define KEYLENGTH 0x00800000
void HandleError(char *s);
//--------------------------------------------------------------------
// These additional #define statements are required.
#define ENCRYPT_ALGORITHM CALG_RC4
#define ENCRYPT_BLOCK_SIZE 8
// Declare the function EncryptFile. The function definition
// follows main.
BOOL EncryptFile(PCHAR szSource,PCHAR szDestination,PCHAR szPassword);
BOOL DecryptFile(PCHAR szSource,PCHAR szDestination,PCHAR szPassword);
char * EncryptStr(PCHAR szSource,PCHAR szPassword);
char *DecryptStr(PCHAR szSource,PCHAR szPassword);
//--------------------------------------------------------------------
// Begin main.
void main(void)
{
//加密字符串
char *pCh=EncryptStr("ABCDEFGHIJKLMN","123456");//程序授权给XX使用
printf("ABCDEFGHIJKLMN加密后的字符串为:");
printf(pCh);
printf("/r/n");
char pBuff[1024];
memset(&pBuff,0,1024);
memcpy(&pBuff,pCh,strlen(pCh));
//解密字符串
printf(pCh);
printf("解密后的字符串:");
char *pCh2=DecryptStr(pBuff,"123456");
printf(pCh2);
printf("/r/n");
//加密文件
PCHAR szSource;
PCHAR szDestination;
PCHAR szPassword;
char response;
if(!(szSource=(char *)malloc(100)))
HandleError("Memory allocation failed.");
if(!(szDestination=(char *)malloc(100)))
HandleError("Memory allocation failed.");
if(!(szPassword=(char *)malloc(100)))
HandleError("Memory allocation failed.");
printf("Encrypt a file. /n/n");
printf("Enter the name of the file to be encrypted: ");
scanf("%s",szSource);
printf("Enter the name of the output file: ");
scanf("%s",szDestination);
printf("Use a password to encrypt this file? ( y/n ) ");
getchar();
scanf("%c",&response);
if(response == 'y')
{
printf("Enter the password:");
scanf("%s",szPassword);
}
else
{
printf("The key will be generated without using a password. /n");
free(szPassword);
szPassword = NULL;
}
//--------------------------------------------------------------------
// Call EncryptFile to do the actual encryption.
if(EncryptFile(szSource, szDestination, szPassword))
{
printf("Encryption of the file %s was a success. /n", szSource);
printf("The encrypted data is in file %s./n",szDestination);
}
else
{
HandleError("Error encrypting file!");
}
//PCHAR szSource;
//PCHAR szDestination;
//PCHAR szPassword;
//char response;
//解密文件
if(!(szSource=(char *)malloc(100)))
HandleError("Memory allocation failed.");
if(!(szDestination=(char *)malloc(100)))
HandleError("Memory allocation failed.");
if(!(szPassword=(char *)malloc(100)))
HandleError("Memory allocation failed.");
printf("Decrypt a file. /n/n");
printf("Enter the name of the file to be decrypted: ");
scanf("%s",szSource);
printf("Enter the name of the output file: ");
scanf("%s",szDestination);
printf("Was a password used to encrypt this file? ( y/n ) ");
getchar();
scanf("%c",&response);
if(response == 'y')
{
printf("Enter the password:");
scanf("%s",szPassword);
}
else
{
printf("The key will be generated without using a password. /n");
free(szPassword);
szPassword = NULL;
}
if(!DecryptFile(szSource, szDestination, szPassword))
{
printf("/nError decrypting file. /n");
}
else
{
printf("/nDecryption of file %s succeeded. /n", szSource);
printf("The decrypted file is %s ./n",szDestination);
}
} // End of main
//--------------------------------------------------------------------
// Code for the function EncryptFile called by main.
static BOOL EncryptFile(PCHAR szSource,PCHAR szDestination,PCHAR szPassword)
//--------------------------------------------------------------------
// Parameters passed are:
// szSource, the name of the input, a plaintext file.
// szDestination, the name of the output, an encrypted file to be
// created.
// szPassword, either NULL if a password is not to be used or the
// string that is the password.
{
//--------------------------------------------------------------------
// Declare and initialize local variables.
FILE *hSource;
FILE *hDestination;
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
HCRYPTKEY hXchgKey;
HCRYPTHASH hHash;
PBYTE pbKeyBlob;
DWORD dwKeyBlobLen;
PBYTE pbBuffer;
DWORD dwBlockLen;
DWORD dwBufferLen;
DWORD dwCount;
//--------------------------------------------------------------------
// Open source file.
if(hSource = fopen(szSource,"rb"))
{
printf("The source plaintext file, %s, is open. /n", szSource);
}
else
{
HandleError("Error opening source plaintext file!");
}
//--------------------------------------------------------------------
// Open destination file.
if(hDestination = fopen(szDestination,"wb"))
{
printf("Destination file %s is open. /n", szDestination);
}
else
{
HandleError("Error opening destination ciphertext file!");
}
// Get handle to the default provider.
if(CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL,
0))
{
printf("A cryptographic provider has been acquired. /n");
}
else
{
HandleError("Error during CryptAcquireContext!");
}
//--------------------------------------------------------------------
// Create the session key.
if(!szPassword )
{
//---------------------------------------------------------------
// No password was passed.
// Encrypt the file with a random session key and write the key
// to a file.
//---------------------------------------------------------------
// Create a random session key.
if(CryptGenKey(
hCryptProv,
ENCRYPT_ALGORITHM,
KEYLENGTH | CRYPT_EXPORTABLE,
&hKey))
{
printf("A session key has been created. /n");
}
else
{
HandleError("Error during CryptGenKey. /n");
}
//---------------------------------------------------------------
// Get handle to the encrypter's exchange public key.
if(CryptGetUserKey(
hCryptProv,
AT_KEYEXCHANGE,
&hXchgKey))
{
printf("The user public key has been retrieved. /n");
}
else
{
HandleError("User public key is not available /
and may not exist.");
}
//---------------------------------------------------------------
// Determine size of the key BLOB, and allocate memory.
if(CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
NULL,
&dwKeyBlobLen))
{
printf("The key BLOB is %d bytes long. /n",dwKeyBlobLen);
}
else
{
HandleError("Error computing BLOB length! /n");
}
if(pbKeyBlob =(BYTE *)malloc(dwKeyBlobLen))
{
printf("Memory is allocated for the key BLOB. /n");
}
else
{
HandleError("Out of memory. /n");
}
//---------------------------------------------------------------
// Encrypt and export session key into a simple key BLOB.
if(CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
pbKeyBlob,
&dwKeyBlobLen))
{
printf("The key has been exported. /n");
}
else
{
HandleError("Error during CryptExportKey!/n");
}
//---------------------------------------------------------------
// Release key exchange key handle.
CryptDestroyKey(hXchgKey);
hXchgKey = 0;
//---------------------------------------------------------------
// Write size of key BLOB to destination file.
fwrite(&dwKeyBlobLen, sizeof(DWORD), 1, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing header.");
}
else
{
printf("A file header has been written. /n");
}
//--------------------------------------------------------------
// Write key BLOB to destination file.
fwrite(pbKeyBlob, 1, dwKeyBlobLen, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing header");
}
else
{
printf("The key BLOB has been written to the file. /n");
}
}
else
{
//--------------------------------------------------------------------
// The file will be encrypted with a session key derived from a
// password.
// The session key will be recreated when the file is decrypted
// only if the password used to create the key is available.
//--------------------------------------------------------------------
// Create a hash object.
if(CryptCreateHash(hCryptProv, CALG_MD5,0,0,&hHash))
{
printf("A hash object has been created. /n");
}
else
{
HandleError("Error during CryptCreateHash!/n");
}
//--------------------------------------------------------------------
// Hash the password.
if(CryptHashData(
hHash,
(BYTE *)szPassword,
strlen(szPassword),
0))
{
printf("The password has been added to the hash. /n");
}
else
{
HandleError("Error during CryptHashData. /n");
}
//--------------------------------------------------------------------
// Derive a session key from the hash object.
if(CryptDeriveKey(
hCryptProv,
ENCRYPT_ALGORITHM,
hHash,
KEYLENGTH,
&hKey))
{
printf("An encryption key is derived from the password hash. /n");
}
else
{
HandleError("Error during CryptDeriveKey!/n");
}
//--------------------------------------------------------------------
// Destroy the hash object.
CryptDestroyHash(hHash);
hHash = 0;
}
//--------------------------------------------------------------------
// The session key is now ready. If it is not a key derived from a
// password, the session key encrypted with the encrypter's private
// key has been written to the destination file.
//--------------------------------------------------------------------
// Determine number of bytes to encrypt at a time.
// This must be a multiple of ENCRYPT_BLOCK_SIZE.
// ENCRYPT_BLOCK_SIZE is set by a #define statement.
dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;
//--------------------------------------------------------------------
// Determine the block size. If a block cipher is used,
// it must have room for an extra block.
if(ENCRYPT_BLOCK_SIZE > 1)
dwBufferLen = dwBlockLen + ENCRYPT_BLOCK_SIZE;
else
dwBufferLen = dwBlockLen;
//--------------------------------------------------------------------
// Allocate memory.
if(pbBuffer = (BYTE *)malloc(dwBufferLen))
{
printf("Memory has been allocated for the buffer. /n");
}
else
{
HandleError("Out of memory. /n");
}
//--------------------------------------------------------------------
// In a do loop, encrypt the source file and write to the source file.
do
{
//--------------------------------------------------------------------
// Read up to dwBlockLen bytes from the source file.
dwCount = fread(pbBuffer, 1, dwBlockLen, hSource);
if(ferror(hSource))
{
HandleError("Error reading plaintext!/n");
}
//--------------------------------------------------------------------
// Encrypt data.
if(!CryptEncrypt(
hKey,
0,
feof(hSource),
0,
pbBuffer,
&dwCount,
dwBufferLen))
{
HandleError("Error during CryptEncrypt. /n");
}
//--------------------------------------------------------------------
// Write data to the destination file.
fwrite(pbBuffer, 1, dwCount, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing ciphertext.");
}
}
while(!feof(hSource));
//--------------------------------------------------------------------
// End the do loop when the last block of the source file has been
// read, encrypted, and written to the destination file.
//--------------------------------------------------------------------
// Close files.
if(hSource)
fclose(hSource);
if(hDestination)
fclose(hDestination);
//--------------------------------------------------------------------
// Free memory.
if(pbBuffer)
free(pbBuffer);
//--------------------------------------------------------------------
// Destroy session key.
if(hKey)
CryptDestroyKey(hKey);
//--------------------------------------------------------------------
// Release key exchange key handle.
if(hXchgKey)
CryptDestroyKey(hXchgKey);
//--------------------------------------------------------------------
// Destroy hash object.
if(hHash)
CryptDestroyHash(hHash);
//--------------------------------------------------------------------
// Release provider handle.
if(hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return(TRUE);
} // End of Encryptfile
//--------------------------------------------------------------------
// This example uses the function HandleError, a simple error
// handling function, to print an error message to the standard error
// (stderr) file and exit the program.
// For most applications, replace this function with one
// that does more extensive error reporting.
void HandleError(char *s)
{
fprintf(stderr,"An error occurred in running the program. /n");
fprintf(stderr,"%s/n",s);
fprintf(stderr, "Error number %x./n", GetLastError());
fprintf(stderr, "Program terminating. /n");
exit(1);
} // End of HandleError
static BOOL DecryptFile(
PCHAR szSource,
PCHAR szDestination,
PCHAR szPassword)
{
//--------------------------------------------------------------------
// Declare and initialize local variables.
FILE *hSource;
FILE *hDestination;
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
HCRYPTHASH hHash;
PBYTE pbKeyBlob = NULL;
DWORD dwKeyBlobLen;
PBYTE pbBuffer;
DWORD dwBlockLen;
DWORD dwBufferLen;
DWORD dwCount;
BOOL status = FALSE;
//--------------------------------------------------------------------
// Open source file.
if(!(hSource = fopen(szSource,"rb")))
{
HandleError("Error opening ciphertext file!");
}
//--------------------------------------------------------------------
// Open destination file.
if(!(hDestination = fopen(szDestination,"wb")))
{
HandleError("Error opening plaintext file!");
}
//--------------------------------------------------------------------
// Get a handle to the default provider.
if(!CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL,
0))
{
HandleError("Error during CryptAcquireContext!");
}
//--------------------------------------------------------------------
// Check for existence of a password.
if(!szPassword)
{
//--------------------------------------------------------------------
// Decrypt the file with the saved session key.
// Read key BLOB length from source file, and allocate memory.
fread(&dwKeyBlobLen, sizeof(DWORD), 1, hSource);
if(ferror(hSource) || feof(hSource))
{
HandleError("Error reading file header!");
}
if(!(pbKeyBlob = (BYTE *)malloc(dwKeyBlobLen)))
{
HandleError("Memory allocation error.");
}
//--------------------------------------------------------------------
// Read key BLOB from source file.
fread(pbKeyBlob, 1, dwKeyBlobLen, hSource);
if(ferror(hSource) || feof(hSource))
{
HandleError("Error reading file header!/n");
}
//--------------------------------------------------------------------
// Import key BLOB into CSP.
if(!CryptImportKey(
hCryptProv,
pbKeyBlob,
dwKeyBlobLen,
0,
0,
&hKey))
{
HandleError("Error during CryptImportKey!");
}
}
else
{
//--------------------------------------------------------------------
// Decrypt the file with a session key derived from a password.
//--------------------------------------------------------------------
// Create a hash object.
if(!CryptCreateHash(
hCryptProv,
CALG_MD5,
0,
0,
&hHash))
{
HandleError("Error during CryptCreateHash!");
}
//--------------------------------------------------------------------
// Hash in the password data.
if(!CryptHashData(
hHash,
(BYTE *)szPassword,
strlen(szPassword),
0))
{
HandleError("Error during CryptHashData!");
}
//--------------------------------------------------------------------
// Derive a session key from the hash object.
if(!CryptDeriveKey(
hCryptProv,
ENCRYPT_ALGORITHM,
hHash,
KEYLENGTH,
&hKey))
{
HandleError("Error during CryptDeriveKey!");
}
//--------------------------------------------------------------------
// Destroy the hash object.
CryptDestroyHash(hHash);
hHash = 0;
}
//--------------------------------------------------------------------
// The decryption key is now available, either having been imported
// from a BLOB read in from the source file or having been created
// using the password. This point in the program is not reached if
// the decryption key is not available.
//--------------------------------------------------------------------
// Determine the number of bytes to decrypt at a time.
// This must be a multiple of ENCRYPT_BLOCK_SIZE.
dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;
dwBufferLen = dwBlockLen;
//--------------------------------------------------------------------
// Allocate memory.
if(!(pbBuffer = (BYTE *)malloc(dwBufferLen)))
{
HandleError("Out of memory!/n");
}
//--------------------------------------------------------------------
// Decrypt source file, and write to destination file.
do {
//--------------------------------------------------------------------
// Read up to dwBlockLen bytes from source file.
dwCount = fread(
pbBuffer,
1,
dwBlockLen,
hSource);
if(ferror(hSource))
{
HandleError("Error reading ciphertext!");
}
//--------------------------------------------------------------------
// Decrypt data.
if(!CryptDecrypt(
hKey,
0,
feof(hSource),
0,
pbBuffer,
&dwCount))
{
HandleError("Error during CryptDecrypt!");
}
//--------------------------------------------------------------------
// Write data to destination file.
fwrite(
pbBuffer,
1,
dwCount,
hDestination);
if(ferror(hDestination))
{
HandleError("Error writing plaintext!");
}
}
while(!feof(hSource));
status = TRUE;
//--------------------------------------------------------------------
// Close files.
if(hSource)
fclose(hSource);
if(hDestination)
fclose(hDestination);
//--------------------------------------------------------------------
// Free memory.
if(pbKeyBlob)
free(pbKeyBlob);
if(pbBuffer)
free(pbBuffer);
//--------------------------------------------------------------------
// Destroy session key.
if(hKey)
CryptDestroyKey(hKey);
//--------------------------------------------------------------------
// Destroy hash object.
if(hHash)
CryptDestroyHash(hHash);
//--------------------------------------------------------------------
// Release provider handle.
if(hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return status;
} // End of Decryptfile
//--------------------------------------------------------------------
// This example uses the function HandleError, a simple error
// handling function, to print an error message to the standard error
// (stderr) file and exit the program.
// For most applications, replace this function with one
// that does more extensive error reporting.
/*void HandleError(char *s)
{
fprintf(stderr,"An error occurred in running the program. /n");
fprintf(stderr,"%s/n",s);
fprintf(stderr, "Error number %x./n", GetLastError());
fprintf(stderr, "Program terminating. /n");
exit(1);
} // End of HandleError*/
static char* EncryptStr(PCHAR szSource,PCHAR szPassword)
//--------------------------------------------------------------------
// Parameters passed are:
// szSource, the name of the input, a plaintext file.
// szDestination, the name of the output, an encrypted file to be
// created.
// szPassword, either NULL if a password is not to be used or the
// string that is the password.
{
//--------------------------------------------------------------------
// Declare and initialize local variables.
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
HCRYPTKEY hXchgKey;
HCRYPTHASH hHash;
PBYTE pbKeyBlob;
DWORD dwKeyBlobLen;
PBYTE pbBuffer;
DWORD dwBlockLen;
DWORD dwBufferLen;
DWORD dwCount;
static char ChBuff[1024]={0};//=new char(dwCount);
// Get handle to the default provider.
if(CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL,
0))
{
printf("A cryptographic provider has been acquired. /n");
}
else
{
HandleError("Error during CryptAcquireContext!");
}
//--------------------------------------------------------------------
// Create the session key.
if(!szPassword )
{
//---------------------------------------------------------------
// No password was passed.
// Encrypt the file with a random session key and write the key
// to a file.
//---------------------------------------------------------------
// Create a random session key.
if(CryptGenKey(
hCryptProv,
ENCRYPT_ALGORITHM,
KEYLENGTH | CRYPT_EXPORTABLE,
&hKey))
{
printf("A session key has been created. /n");
}
else
{
HandleError("Error during CryptGenKey. /n");
}
//---------------------------------------------------------------
// Get handle to the encrypter's exchange public key.
if(CryptGetUserKey(
hCryptProv,
AT_KEYEXCHANGE,
&hXchgKey))
{
printf("The user public key has been retrieved. /n");
}
else
{
HandleError("User public key is not available /
and may not exist.");
}
//---------------------------------------------------------------
// Determine size of the key BLOB, and allocate memory.
if(CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
NULL,
&dwKeyBlobLen))
{
printf("The key BLOB is %d bytes long. /n",dwKeyBlobLen);
}
else
{
HandleError("Error computing BLOB length! /n");
}
if(pbKeyBlob =(BYTE *)malloc(dwKeyBlobLen))
{
printf("Memory is allocated for the key BLOB. /n");
}
else
{
HandleError("Out of memory. /n");
}
//---------------------------------------------------------------
// Encrypt and export session key into a simple key BLOB.
if(CryptExportKey(
hKey,
hXchgKey,
SIMPLEBLOB,
0,
pbKeyBlob,
&dwKeyBlobLen))
{
printf("The key has been exported. /n");
}
else
{
HandleError("Error during CryptExportKey!/n");
}
//---------------------------------------------------------------
// Release key exchange key handle.
CryptDestroyKey(hXchgKey);
hXchgKey = 0;
//---------------------------------------------------------------
// Write size of key BLOB to destination file.
/*fwrite(&dwKeyBlobLen, sizeof(DWORD), 1, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing header.");
}
else
{
printf("A file header has been written. /n");
}
//--------------------------------------------------------------
// Write key BLOB to destination file.
fwrite(pbKeyBlob, 1, dwKeyBlobLen, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing header");
}
else
{
printf("The key BLOB has been written to the file. /n");
}*/
}
else
{
//--------------------------------------------------------------------
// The file will be encrypted with a session key derived from a
// password.
// The session key will be recreated when the file is decrypted
// only if the password used to create the key is available.
//--------------------------------------------------------------------
// Create a hash object.
if(CryptCreateHash(hCryptProv, CALG_MD5,0,0,&hHash))
{
printf("A hash object has been created. /n");
}
else
{
HandleError("Error during CryptCreateHash!/n");
}
//--------------------------------------------------------------------
// Hash the password.
if(CryptHashData(
hHash,
(BYTE *)szPassword,
strlen(szPassword),
0))
{
printf("The password has been added to the hash. /n");
}
else
{
HandleError("Error during CryptHashData. /n");
}
//--------------------------------------------------------------------
// Derive a session key from the hash object.
if(CryptDeriveKey(
hCryptProv,
ENCRYPT_ALGORITHM,
hHash,
KEYLENGTH,
&hKey))
{
printf("An encryption key is derived from the password hash. /n");
}
else
{
HandleError("Error during CryptDeriveKey!/n");
}
//--------------------------------------------------------------------
// Destroy the hash object.
CryptDestroyHash(hHash);
hHash = 0;
}
//--------------------------------------------------------------------
// The session key is now ready. If it is not a key derived from a
// password, the session key encrypted with the encrypter's private
// key has been written to the destination file.
//--------------------------------------------------------------------
// Determine number of bytes to encrypt at a time.
// This must be a multiple of ENCRYPT_BLOCK_SIZE.
// ENCRYPT_BLOCK_SIZE is set by a #define statement.
dwBlockLen = strlen(szSource) - strlen(szSource) % ENCRYPT_BLOCK_SIZE;
//--------------------------------------------------------------------
// Determine the block size. If a block cipher is used,
// it must have room for an extra block.
if(ENCRYPT_BLOCK_SIZE > 1)
dwBufferLen = dwBlockLen + ENCRYPT_BLOCK_SIZE;
else
dwBufferLen = dwBlockLen;
//--------------------------------------------------------------------
// Allocate memory.
if(pbBuffer = (BYTE *)malloc(dwBufferLen))
{
printf("Memory has been allocated for the buffer. /n");
}
else
{
HandleError("Out of memory. /n");
}
//--------------------------------------------------------------------
// In a do loop, encrypt the source file and write to the source file.
//do
{
//--------------------------------------------------------------------
// Read up to dwBlockLen bytes from the source file.
/*dwCount = fread(pbBuffer, 1, dwBlockLen, hSource);
if(ferror(hSource))
{
HandleError("Error reading plaintext!/n");
}*/
dwBlockLen=strlen(szSource);
dwCount=dwBlockLen;
memset(pbBuffer,0,sizeof(pbBuffer));
memcpy(pbBuffer,szSource,dwBlockLen);
//--------------------------------------------------------------------
// Encrypt data.
if(!CryptEncrypt(
hKey,
0,
TRUE, //feof(hSource),
0,
pbBuffer,
&dwCount,
dwBufferLen))
{
HandleError("Error during CryptEncrypt. /n");
}
memset(&ChBuff,0,1024);
memcpy(ChBuff,pbBuffer,dwCount);
ChBuff[dwCount]='/0';
//printf(ChBuff);
//printf("/r/n");
//DecryptStr(ChBuff,"123456");
//char *chb=ChBuff;
//printf(ChBuff);
//delete []ChBuff;
//ChBuff=NULL;
//memcpy(szSource,pbBuffer,6);
//szSource[0]=(char)pbBuffer[1];
//BYTE b=pbBuffer[1];
//szSource[0]=b;
//--------------------------------------------------------------------
// Write data to the destination file.
//printf(pbBuffer);
/*fwrite(pbBuffer, 1, dwCount, hDestination);
if(ferror(hDestination))
{
HandleError("Error writing ciphertext.");
}*/
}
//while(!feof(hSource));
//--------------------------------------------------------------------
// End the do loop when the last block of the source file has been
// read, encrypted, and written to the destination file.
//--------------------------------------------------------------------
// Close files.
/*if(hSource)
fclose(hSource);
if(hDestination)
fclose(hDestination); */
//--------------------------------------------------------------------
// Free memory.
if(pbBuffer)
free(pbBuffer);
//--------------------------------------------------------------------
// Destroy session key.
if(hKey)
CryptDestroyKey(hKey);
//--------------------------------------------------------------------
// Release key exchange key handle.
if(hXchgKey)
CryptDestroyKey(hXchgKey);
//--------------------------------------------------------------------
// Destroy hash object.
if(hHash)
CryptDestroyHash(hHash);
//--------------------------------------------------------------------
// Release provider handle.
if(hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return (char*)ChBuff;
} // End of Encryptfile
static char* DecryptStr(PCHAR szSource,PCHAR szPassword)
{
//--------------------------------------------------------------------
// Declare and initialize local variables.
HCRYPTPROV hCryptProv;
HCRYPTKEY hKey;
HCRYPTHASH hHash;
PBYTE pbKeyBlob = NULL;
DWORD dwKeyBlobLen;
PBYTE pbBuffer;
DWORD dwBlockLen;
DWORD dwBufferLen;
DWORD dwCount;
static char ChBuff[1024]={0};//=new char(dwCount);
BOOL status = FALSE;
//--------------------------------------------------------------------
// Get a handle to the default provider.
if(!CryptAcquireContext(
&hCryptProv,
NULL,
MS_ENHANCED_PROV,
PROV_RSA_FULL,
0))
{
HandleError("Error during CryptAcquireContext!");
}
//--------------------------------------------------------------------
// Check for existence of a password.
if(!szPassword)
{
//--------------------------------------------------------------------
// Decrypt the file with the saved session key.
// Read key BLOB length from source file, and allocate memory.
if(!(pbKeyBlob = (BYTE *)malloc(dwKeyBlobLen)))
{
HandleError("Memory allocation error.");
}
//--------------------------------------------------------------------
// Read key BLOB from source file.
//--------------------------------------------------------------------
// Import key BLOB into CSP.
if(!CryptImportKey(
hCryptProv,
pbKeyBlob,
dwKeyBlobLen,
0,
0,
&hKey))
{
HandleError("Error during CryptImportKey!");
}
}
else
{
//--------------------------------------------------------------------
// Decrypt the file with a session key derived from a password.
//--------------------------------------------------------------------
// Create a hash object.
if(!CryptCreateHash(
hCryptProv,
CALG_MD5,
0,
0,
&hHash))
{
HandleError("Error during CryptCreateHash!");
}
//--------------------------------------------------------------------
// Hash in the password data.
if(!CryptHashData(
hHash,
(BYTE *)szPassword,
strlen(szPassword),
0))
{
HandleError("Error during CryptHashData!");
}
//--------------------------------------------------------------------
// Derive a session key from the hash object.
if(!CryptDeriveKey(
hCryptProv,
ENCRYPT_ALGORITHM,
hHash,
KEYLENGTH,
&hKey))
{
HandleError("Error during CryptDeriveKey!");
}
//--------------------------------------------------------------------
// Destroy the hash object.
CryptDestroyHash(hHash);
hHash = 0;
}
//--------------------------------------------------------------------
// The decryption key is now available, either having been imported
// from a BLOB read in from the source file or having been created
// using the password. This point in the program is not reached if
// the decryption key is not available.
//--------------------------------------------------------------------
// Determine the number of bytes to decrypt at a time.
// This must be a multiple of ENCRYPT_BLOCK_SIZE.
dwBlockLen = strlen(szSource) - strlen(szSource) % ENCRYPT_BLOCK_SIZE;
dwBufferLen = dwBlockLen;
//--------------------------------------------------------------------
// Allocate memory.
if(!(pbBuffer = (BYTE *)malloc(dwBufferLen)))
{
HandleError("Out of memory!/n");
}
//--------------------------------------------------------------------
// Decrypt source file, and write to destination file.
//do
{
//--------------------------------------------------------------------
// Read up to dwBlockLen bytes from source file.
/*dwCount = fread(
pbBuffer,
1,
dwBlockLen,
hSource);
if(ferror(hSource))
{
HandleError("Error reading ciphertext!");
}*/
dwCount=strlen(szSource);
memcpy(pbBuffer,szSource,dwCount);
//--------------------------------------------------------------------
// Decrypt data.
if(!CryptDecrypt(
hKey,
0,
TRUE,
0,
pbBuffer,
&dwCount))
{
HandleError("Error during CryptDecrypt!");
}
//char ChBuff[1024];//=new char(dwCount);
memset(&ChBuff,0,1024);
memcpy(ChBuff,pbBuffer,dwCount);
ChBuff[dwCount]='/0';
//printf(ChBuff);
//printf("/r/n");
//--------------------------------------------------------------------
// Write data to destination file.
/*fwrite(
pbBuffer,
1,
dwCount,
hDestination);
if(ferror(hDestination))
{
HandleError("Error writing plaintext!");
}*/
}
//while(!feof(hSource));
status = TRUE;
//--------------------------------------------------------------------
// Free memory.
if(pbKeyBlob)
free(pbKeyBlob);
//if(pbBuffer)
// free(pbBuffer);
//--------------------------------------------------------------------
// Destroy session key.
if(hKey)
CryptDestroyKey(hKey);
//--------------------------------------------------------------------
// Destroy hash object.
if(hHash)
CryptDestroyHash(hHash);
//--------------------------------------------------------------------
// Release provider handle.
if(hCryptProv)
CryptReleaseContext(hCryptProv, 0);
return (char*)ChBuff;
} // End of Decryptfile