C++/VC/MFC字符串/文件加解密

最新推荐文章于 2021-12-29 11:51:03 发布
最新推荐文章于 2021-12-29 11:51:03 发布
阅读量2k 收藏 1
点赞数
分类专栏： C/C++/MFC 文章标签： c++ session allocation file exchange algorithm

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

朱海辉
关注
专栏目录
MFC 加密解密字符串
12-21
对MFC的CString 字符串进行加密，并可逆，对加密字符串解密，不用多说了吧，你懂的。
mfc字符串加解密
08-23
对MFC的CString 字符串进行加密，并可逆，对加密字符串解密，直接可以运行，适合VC6.0
DES对字符串加密解密+MFC实现，生成中间2进制数据
06-23
简单的课程作业，信息安全，进行加密解密，内部2进制转换，在外部显示
MFC文件夹加解密小工具
03-30
该项目是由我们自己用vc写的一个对文件夹操作的竞赛项目，对文件夹加密、解密，里面有zlib，不管是对于初学者还是对于有过vc学习的人们都有一定帮助。 修改了 解密时密码错误的bug。
C/C++/VC/MFC 通用字符串操作函数、通用字符串类型
Kim的博客
07-29 351
/* // 字符串函数更安全的替代，Strsafe.h 官方文档： https://docs.microsoft.com/en-us/windows/win32/api/strsafe/ // 官方建议使用更安全的带_s的函数，官方文档： https://docs.microsoft.com/zh-cn/cpp/c-runtime-library/reference/itoa-s-itow-s?view=msvc-160 ANSI UNICODE 通用 (char.h) (wch.
C++/MFC中分割字符串
weixin_43264512的博客
12-29 595
//按空格进行分割 string strSr = "aaa bbb ccc ddd"; //用于保存分割后的字符串 vector<string> vecstr; int nStart = 0; int nEnd = 0; while (true) { while (nStart < strSr.length() && strSr[nStart] == ' ') { nStart++; } if (nStart >= strSr.
MFC字符串CString 操作用法详解
11-03
### MFC字符串CString操作用法详解 #### 一、引言 Microsoft Foundation Classes (MFC) 是一套由微软开发的类库，它封装了Windows API，使得开发者可以更方便地进行Windows应用程序的开发。其中，`CString`是MFC中...
AES加密/解密算法，基于MFC下的 VC6.0
08-09
在MFC（Microsoft Foundation Classes）环境下，VC6.0是Microsoft Visual C++的一个版本，用于开发Windows应用程序。在这样的环境中实现AES加密/解密算法，通常需要以下步骤： 1. **库选择**：首先，你需要一个库来...
VC++从文本文件中读取一个字符串
03-15
在VC++编程环境中，从文本文件中读取一个字符串是一项基本但重要的任务。这涉及到文件操作，字符串...理解并掌握这些内容，对于进行C++的文件操作和字符串处理至关重要。实际编程时，应根据具体需求灵活运用这些知识。
MFC 实现文本文件加密解密
04-11
这是基于VC2010平台下的对文本文件加密解密的一个程序，有整个工程源码
VC++ 字符串 CString 加密 解密 源码
09-15
VC++ 字符串 CString 加密 解密 源码
VC 文本字符加密、解密程序示范.rar
07-10
VC 文本字符加密、解密程序示范，程序在界面方面使用了XPBotton控件，因此窗体做的挺漂亮，还有那几个按钮，也是我喜欢的风格。本加密程序可对一段文字、字符串进行加密和解密，可将加密后的字符串保存为文件。
c语言实现md5算法字符串加密（vc调试通过）
09-17
c语言实现md5算法字符串加密，vc调试通过
VC++用Des加密字符串
10-12
VC++用Des加密字符串，不用多说了吧
md5.zip_md5_vc mfc_字符串压缩
09-23
在MD5.zip文件中，可能包含了一个使用MFC编写的C++程序，用于处理字符串的MD5计算。 字符串压缩通常指的是将长字符串通过某种算法转化为较短的、可表示的格式，但MD5并不直接进行字符串压缩，而是生成一个独特的...
MFC 简单的加密解密 小程序
weixin_33929309的博客
03-06 295
简单的加密解密算法 这个小程序是用来作为一个非常简单的对称加密算法，比移位加密稍微强那么一点点。 seed的话大家可以自己来设置，seed大概为60位，程序没有边界检查，很简陋，希望看官们别见笑。 // Code.h: interface for the CCode class. // ///////////////////////...
vc++字符串加解密(附源码）
Keivin
07-21 889
最简洁的字符串加解密，当然肯定也没有太多的技术含量，只是提供一种思路与方法，也相当是 对字符串进行了一些处理操作，解密时进行了一些恢复操作！ CString CDataencryptDlg::Encrypt(CString S, WORD K) { CString Str,Str1,Result; int i,j; Str = S; for(i=0;i<S.GetLength();i++) { Str.SetAt(i,S.GetAt(i)+K); } S = ...
vc实现用3des对字符串加密解密
12-11
vc实现用3des对字符串加密解密，vc、3des、源代码、测试通过，现成的类方便移植。
VC_MFC串口通信详细教程：创建与配置实例
本文档深入探讨了Visual C++ (VC_MFC) 中串口通信编程的详细过程。首先，作者强调了在工业控制领域，Windows平台下的工控机常通过RS485总线与智能仪表进行通信，串口通信因其方便性被广泛应用，特别是半双工通信模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值