master

分支 (1)

管理

管理

master

experiment
/
加密API
/
CSP.c

#include "tool.h"
#include <windows.h>
#include <wincrypt.h>
#include <stdio.h>
#include <QDebug>

BOOL CalHash(unsigned char* src,  unsigned char* hash,  int len)
{
    HCRYPTPROV hCryptProv;  //定义一个CSP模块的句柄。
      LPCTSTR pszContainerName = TEXT("Hash");//用一个TEXT宏定义一个容器的名字，
      if(CryptAcquireContext(  //这个函数是获取有某个容器的CSP模块的指针，成功返回TRUE。
        &hCryptProv,    //指向一个CSP模块句柄指针，里面用指定的容器
        pszContainerName, //指定容器的名称
        NULL,       //这个参数这里用的是缺省值，指得是缺省得CSP模块，你也可以传入一个LPCTSTR类型的字符串，指定CSP模块
        PROV_RSA_AES, //确定密钥的类型
        0))
      {
        printf("CSP Create Success\n");
      }else   //不成功的处理段
      {
           if(GetLastError() == NTE_BAD_KEYSET) // NTE_BAD_KEYSET意味着密钥容器不存在，下面就去创建一个新的密钥容器
           {
            if(CryptAcquireContext(&hCryptProv,
                pszContainerName,NULL,PROV_RSA_AES,
                CRYPT_NEWKEYSET)) // CRYPT_NEWKEYSET意味着当指定容器不存在的时候，去创建一个容器。
            {
                 printf("A new key container has been created.\n");
            }else
            {
                printf("CSP Create Fail\n");
                return FALSE;
            }
           }
       }


  HCRYPTHASH hHash;
  //创建hash对象
  if(!CryptCreateHash( hCryptProv,
             CALG_MD5,
             0,
             0,
             &hHash))
  {
    printf("CryptCreateHash fail!");
    return FALSE;
  }

  if(!CryptHashData( hHash,
            (BYTE*)src,
            len,
            0
            ))
  {
    printf("CryptHashData fail!");
    return FALSE;
  }

  DWORD dwHashLen= 16;
  if(!CryptGetHashParam(hHash,
             HP_HASHVAL,
             (BYTE*)hash,
             &dwHashLen,
             0))
  {
    printf("CryptGetHashParam fail!");
    return FALSE;
  }

  CryptDestroyHash(hHash);
  CryptReleaseContext(hCryptProv, 0);
  return TRUE;
}


BOOL Encrypt(unsigned char* src,
       unsigned char* dest,
       char* passwd
       )

{
  HCRYPTPROV hCryptProv;  //定义一个CSP模块的句柄。
  LPCTSTR pszContainerName = TEXT("Encrypt");//用一个TEXT宏定义一个容器的名字，
  if(CryptAcquireContext(  //这个函数是获取有某个容器的CSP模块的指针，成功返回TRUE。
               &hCryptProv,    //指向一个CSP模块句柄指针，里面用指定的容器
               pszContainerName, //指定容器的名称
               NULL,       //这个参数这里用的是缺省值，指得是缺省得CSP模块，你也可以传入一个LPCTSTR类型的字符串，指定CSP模块
               PROV_RSA_AES, //确定密钥的类型
               0))
  {
    printf("CSP Create Success\n");
  }
  else
  {
    //不成功的处理段
    if(GetLastError() == NTE_BAD_KEYSET) // NTE_BAD_KEYSET意味着密钥容器不存在，下面就去创建一个新的密钥容器
    {
      if(CryptAcquireContext(&hCryptProv,
                  pszContainerName,NULL,PROV_RSA_AES,
                  CRYPT_NEWKEYSET)) // CRYPT_NEWKEYSET意味着当指定容器不存在的时候，去创建一个容器
      {
        printf("A new key container has been created.\n");
      }
  }
  HCRYPTHASH hCryptHash;
  //创建hash对象
  if(!CryptCreateHash( hCryptProv,
             CALG_MD5,
             0,
             0,
             &hCryptHash))
  {
    printf("CryptCreateHash fail!");
    return FALSE;
  }

  //用输入的密码作哈稀散列

  if(!CryptHashData( hCryptHash,lse
  {
    printf("CSP Create Fail\n");
    return FALSE;
  }

}
            (BYTE*)passwd,
            strlen(passwd),
            0))
  {
    printf("CryptHashData fail!");
    return FALSE;
  }

  //用哈稀散列生成会话密钥
  HCRYPTKEY hCryptKey;
  if(!CryptDeriveKey(hCryptProv,
            CALG_AES_128,
            hCryptHash,
            CRYPT_EXPORTABLE,
            &hCryptKey
            ))
  {
    printf("CryptDeriveKey fail!");
    return FALSE;
  }

  //对文件进行加密,hCryptKey已经与加密算法相关联了CALG_AES_128
  unsigned char buf[16];
  DWORD lenght = 16;
  memcpy(buf,src,16);
  if(!CryptEncrypt(hCryptKey,
           NULL,//如果数据同时进行散列和加密，这里传入一个散列对象
           0,//如果是最后一个块为TRUE
           0,
           (BYTE*)buf,//输入被加密的数据，输出加密数据
           &lenght,//输入输入数据长度，输出加密后数据长度
           16
           ))
  {
    qDebug() << "errre";
    qDebug() << GetLastError();
  }

  memcpy(dest,buf,16);
  CryptDestroyHash(hCryptHash);
  CryptReleaseContext(hCryptProv, 0);
  return TRUE;
}

BOOL Decrypt(unsigned char* src,
       unsigned char* dest,
       char* passwd
       )
{

  HCRYPTPROV hCryptProv;  //定义一个CSP模块的句柄。“CSP模块，请查看《加密解密二》222页，那里有简单的说明，这里就不说了。
  LPCTSTR pszContainerName = TEXT("Decrypt");//用一个TEXT宏定义一个容器的名字，
  if(CryptAcquireContext(  //这个函数是获取有某个容器的CSP模块的指针，成功返回TRUE。
               &hCryptProv,    //指向一个CSP模块句柄指针，里面用指定的容器
               pszContainerName, //指定容器的名称
               NULL,       //这个参数这里用的是缺省值，指得是缺省得CSP模块，你也可以传入一个LPCTSTR类型的字符串，指定CSP模块
               PROV_RSA_AES, //确定密钥的类型
               0))   //常设为0，还有些其他的类型，请看MSDN
  {
    printf("CSP Create Success\n");
  }
  else
  {
    //不成功的处理段
    if(GetLastError() == NTE_BAD_KEYSET) // NTE_BAD_KEYSET意味着密钥容器不存在，下面就去创建一个新的密钥容器
    {
      if(CryptAcquireContext(&hCryptProv,
                  pszContainerName,NULL,PROV_RSA_AES,
                  CRYPT_NEWKEYSET)) // CRYPT_NEWKEYSET意味着当指定容器不存在的时候，去创建一个容器。
      {
        printf("A new key container has been created.\n");
      }
      else
      {
        printf("CSP Create Fail\n");
        return FALSE;
      }
    }
  }
  HCRYPTHASH hCryptHash;
  //创建hash对象
  if(!CryptCreateHash( hCryptProv,
             CALG_MD5,
             0,
             0,
             &hCryptHash))
  {
    printf("CryptCreateHash fail!");
    return FALSE;
  }

  //用输入的密码作哈稀散列

  if(!CryptHashData( hCryptHash,
            (BYTE*)passwd,
            strlen(passwd),
            0
            ))
  {
    printf("CryptHashData fail!");
    return FALSE;
  }

  //用哈稀散列生成会话密钥
  HCRYPTKEY hCryptKey;
  if(!CryptDeriveKey(hCryptProv,
            CALG_AES_128,
            hCryptHash,
            CRYPT_EXPORTABLE,
            &hCryptKey
            ))
  {
    printf("CryptDeriveKey fail!");
    return FALSE;
  }

  CryptDestroyHash(hCryptHash);

  //对文件进行加密,hCryptKey已经与加密算法相关联了CALG_AES_128

  unsigned char buf[16];
  DWORD lenght = 16;
  memcpy(buf,src,16);
  CryptDecrypt(hCryptKey,
         NULL,//如果数据同时进行散列和加密，这里传入一个散列对象
         0,//如果是最后一个块为TRUE
         0,
         (BYTE*)buf,//输入被加密的数据，输出加密数据
         &lenght//输入输入数据长度，输出加密后数据长度
         );

  memcpy(dest,buf,16);
  CryptReleaseContext(hCryptProv, 0);
  return TRUE;
}

BOOL Sign(unsigned char* src,
     unsigned char* dest,
     int      len)
{
  HCRYPTPROV hCryptProv;  //定义一个CSP模块的句柄。“CSP模块，请查看《加密解密二》222页，那里有简单的说明，这里就不说了。
  LPCTSTR pszContainerName = TEXT("Decrypt");//用一个TEXT宏定义一个容器的名字，
  if(CryptAcquireContext(  //这个函数是获取有某个容器的CSP模块的指针，成功返回TRUE。
              &hCryptProv,    //指向一个CSP模块句柄指针，里面用指定的容器
               pszContainerName, //指定容器的名称
               NULL,       //这个参数这里用的是缺省值，指得是缺省得CSP模块，你也可以传入一个LPCTSTR类型的字符串，指定CSP模块
               PROV_RSA_FULL, //确定密钥的类型
               0))   //常设为0，还有些其他的类型，请看MSDN
  {
    printf("CSP Create Success\n");
  }
  else
  {
    //不成功的处理段
    if(GetLastError() == NTE_BAD_KEYSET) // NTE_BAD_KEYSET意味着密钥容器不存在，下面就去创建一个新的密钥容器
    {
     if(CryptAcquireContext(&hCryptProv,
                  pszContainerName,NULL,PROV_RSA_AES,
                  CRYPT_NEWKEYSET)) // CRYPT_NEWKEYSET意味着当指定容器不存在的时候，去创建一个容器。
      {
        printf("A new key container has been created.\n");
      }
      else
      {
        printf("CSP Create Fail\n");
        return FALSE;
      }
    }
  }

  HCRYPTKEY hKey;     //创建一个密钥句柄
  if(CryptGetUserKey( // CryptGetUserKey是获取一个密钥句柄的函数，成功返回TRUE
             hCryptProv,  //指定容器的CSP模块句柄
             AT_SIGNATURE,  //指定私钥的类型
             &hKey))  //原来接收获取的密钥句柄
  {
    printf("A signature key is available.\n");
  }
  else
  {
    printf("No signature key is available.\n");
    if(GetLastError() == NTE_NO_KEY) // NTE_NO_KEY意味着密钥不存在，下面就生成一个密钥
    {
      printf("The signature key does not exist.\n");
      printf("Create a signature key pair.\n");
      if(CryptGenKey( // CryptGenKey生成一个密钥
               hCryptProv, //指定CSP模块的句柄
               AT_SIGNATURE, //对于公钥密码系统，生成一个私钥和一个公钥，这个参数指定了这个密钥是公钥，于是生成了一个密码对。如果不是公钥系统，则指定了密码算法，具体看MSDN。
               0,  //指定了生成密钥的类型，这个参数的说明挺多的，想获取更为详尽的资料请看MSDN。
               &hKey))
      {
        printf("Created a signature key pair.\n");
      }
      else
      {
        printf("Created a signature key fail.\n");
        return FALSE;
      }
    }

    else
    {
      printf("An error other than NTE_NO_KEY ");
      return FALSE;
    }

  }
  HCRYPTHASH hHash;
  if(!CryptHashData( hHash,
            (BYTE*)src,
            len,
            0
            ))
  {
    printf("CryptHashData fail!");
    return FALSE;
  }

  DWORD lenght = 32;
  if(!CryptSignHash(hHash,AT_SIGNATURE,NULL,CRYPT_TYPE2_FORMAT,(BYTE*)dest,&lenght))
  {
    printf("CryptSignHash fail!");
    return FALSE;
  }

  if(hKey) //将密钥句柄销毁
  {
    if(!(CryptDestroyKey(hKey)))
    {
      printf("Error during CryptDestroyKey.");
    }
    hKey = NULL;
  }
  CryptDestroyHash(hHash);
  CryptReleaseContext(hCryptProv, 0);
  return TRUE;
}

char *qstoc(const QString Qstr)
{

  QByteArray ba = Qstr.toLatin1();
  char *c_str;
  c_str = (char *)malloc(ba.length() + 1);
  memset(c_str, 0, ba.length());
  memcpy(c_str, ba.data(), ba.length());
  c_str[ba.length()] = '\0';
  return c_str;
}