cryptencrypt加密解密

① windowsxp有什么函数

Windows XP提供了丰富的API函数供开发者使用，以下是一些常见的函数：

1. GDI函数（图形设备接口）：

   • BitBlt：用于位块传输，可以实现图像的复制、移动等操作。
   • DrawText：用于在指定区域内绘制文本，支持多种文本格式化选项。
   • TextOut：用于在指定位置输出文本。
   • CreateFont：用于创建字体对象，可以指定字体的各种属性。
   • SelectObject：用于将指定的对象（如字体、画笔等）选入设备上下文。
   • GetDC：用于获取指定窗口或屏幕的设备上下文，以便进行绘图操作。
   • ReleaseDC：用于释放之前获取的设备上下文。

2. 用户界面函数：

   • MessageBox：用于显示消息框，可以包含文本、图标和按钮等元素。
   • CreateWindow：用于创建窗口，可以指定窗口的类名、样式、大小等属性。
   • ShowWindow：用于显示或隐藏指定的窗口。
   • SendMessage：用于向指定窗口发送消息，可以触发窗口的各种事件。
   • PostMessage：将消息放入指定窗口的消息队列中，稍后处理。

3. 文件和目录操作函数：

   • CreateFile：用于创建或打开文件，并获取文件的句柄。
   • OpenFile：用于打开文件（注意：在较新的Windows版本中，OpenFile已被CreateFile取代）。
   • ReadFile：用于从文件中读取数据。
   • WriteFile：用于向文件中写入数据。
   • DeleteFile：用于删除指定的文件。
   • GetFileSize：用于获取文件的大小。

4. 进程和线程函数：

   • CreateThread：用于创建线程，可以指定线程的入口函数、参数等。
   • ExitThread：用于退出当前线程。
   • CreateProcess：用于创建进程，可以指定进程的可执行文件、命令行参数等。
   • TerminateProcess：用于终止指定的进程。

5. 网络函数：

   • Socket：用于创建套接字，是进行网络通信的基础。
   • Connect：用于将套接字连接到指定的服务器。
   • Send：用于通过套接字发送数据。
   • Receive：用于通过套接字接收数据。
   • CloseSocket：用于关闭套接字，释放资源。

6. 内存操作函数：

   • GlobalAlloc：用于分配全局内存块。
   • GlobalLock：用于锁定全局内存块，以便进行访问。
   • GlobalUnlock：用于解锁全局内存块。
   • HeapAlloc：用于从堆中分配内存。
   • HeapFree：用于释放之前从堆中分配的内存。

7. 安全相关函数：

   • CryptEncrypt：用于加密数据，保护数据的机密性。
   • CryptDecrypt：用于解密数据，还原加密前的数据。
   • LogonUser：用于用户登录验证，检查用户凭据的有效性。

这只是Windows XP API函数的一部分，实际上还有很多其他函数和接口。在开发Windows XP应用程序时，建议参考微软的官方文档以获取更详细的信息。

② 知道RAS的公钥，如何通过程序加密一个字符串呀 私钥在别人手上，不用我解密。使用软件VS2005/CBuilder

//------------rsa.h--------------------

#ifndef RSAH
#define RSAH
//-------------------------------------------------------------------------
#include <iostream>
#include <windows.h>
#include <wincrypt.h>

typedef struct tagRSAFileStruct
{
char m_szVersion[11];
char m_szDate[21];
char m_szPrivider[61];
char m_szCustomer[61];
char m_szUserID[21];
char m_szPubKey[2049];
char m_szPrvKey[2049];
char m_szMD5Str[33];
}RSAFile;

//-------------------------------------------------------------------------
class XRSA
{
private:
unsigned int m_iErrorNo;
unsigned char Char2Hex(unsigned char byVal);
void Char2HexStr(unsigned char byVal, char * pszBuffer);

char *m_pszPubKey, *m_pszPrvKey;
char *m_pszOutData;

public:
XRSA();
~XRSA();

public:
int GetErrorNo();
//解密文件
int Decrypt(unsigned char *pszKey, //解密用密钥
DWORD dwKeyLen, //密钥长度
unsigned char *pszInBuffer,//输入密文文件
DWORD dwInLen,//输入密文文件长度
unsigned char **pszOutBuffer, //输出明文文件
DWORD &dwOutLen //输出明文文件长度
);

//加密文件
int Encrypt(unsigned char *pszKey,//加密用的密钥
DWORD dwKeyLen , //加密密钥长度
unsigned char *pszInBuffer,//输入明文文件
DWORD dwInLen, //输入明文文件长度
unsigned char **pszOutBuffer ,//输出密文文件
DWORD &dwOutLen //输出密文文件长度
);

int GenerateRSAKey(unsigned char **pszPubKey, //公钥文件
DWORD &dwPubKeyLen, //公钥的长度
unsigned char **dwPrvKey,//私钥文件
DWORD &dwPrvKeyLen //私钥的长度
);

public:
int HexStr2Hex(char *pszBuffer, //Hex data buffer
int iInLen, //Hex data len
char *pszHexBuffer //以输出结果，以字符串形式
//必须保证该空间至少是输入长度的2倍+1
);
int Hex2HexStr(char *pszHexBuffer, int iInLen, char *pszBuffer);
};
//-------------------------------------------------------------------------
#endif

//------------rsa.cpp--------------------

#include "RSA.H"
#include "stdio.h"
unsigned char XRSA::Char2Hex(unsigned char val)
{
if (val >= '0' && val <= '9')
return val - 0x30;
else if (val >= 'A' && val <= 'F')
return (val - 0x41 + 10);
else if (val >= 'a' && val <= 'f')
return (val - 0x61 + 10);
else
return 0;
}
void XRSA::Char2HexStr(unsigned char val, char * buff)
{
sprintf(buff, "%02x", val);
buff[2]=0;
return;
}

int XRSA::HexStr2Hex(char *buff, int len, char *hexbuff)
{
unsigned char hi4, low4, byval;
int i,j;

for (i=0, j=0; i<len; i+=2, j++)
{
hi4 = Char2Hex(buff[i]);
if (i<len)
low4 = Char2Hex(buff[i+1]);
else
low4 = 0;
byval = hi4 * 0x10 + low4;

hexbuff[j] = byval;
}
return j;
}

int XRSA::Hex2HexStr(char *hex, int len, char *buff)
{
char tempbuff[10];

memset(buff, 0, len*2+1);

for (int i=0; i<len; i++)
{
Char2HexStr(hex[i], tempbuff);
strcat(buff, tempbuff);
}
return len * 2;
}
//-----------------------------------------------------------
XRSA::XRSA()
{
m_iErrorNo = 0;
m_pszPubKey = NULL;
m_pszPrvKey = NULL;
m_pszOutData = NULL;
}
//-----------------------------------------------------------
XRSA::~XRSA()
{
if(m_pszPubKey != NULL)
{
delete []m_pszPubKey;
m_pszPubKey = NULL;
}
if(m_pszPrvKey != NULL)
{
delete []m_pszPrvKey;
m_pszPrvKey = NULL;
}
if(m_pszOutData != NULL)
{
delete []m_pszOutData;
m_pszOutData = NULL;
}
}
//-----------------------------------------------------------
int XRSA::Decrypt(unsigned char *pszKey, //解密用密钥, HexStr
DWORD dwKeyLen, //密钥长度
unsigned char *pszInBuffer, //输入密文缓冲区
DWORD dwInLen, //输入密文长度
unsigned char **pszOutBuffer, //输出明文
DWORD &dwOutLen //输出明文长度
)
{
//var begin ------------------------------------------------
HCRYPTPROV t_hCryptProv; //临时的密钥容器句柄
HCRYPTKEY t_hKey; //临时的密钥句柄
int result = 0; //返回结果值,如果正常返回为0
unsigned char *tempDivSrcData;
int j=0;
int t=0;

char *pszRealKey, *pszPointer;
//var end -------------------------------------------------

pszRealKey = new char[dwKeyLen];

dwKeyLen = HexStr2Hex(pszKey, dwKeyLen, pszRealKey);

//连接密钥容器
/*不管密钥容器存在不存在先干掉它再生成,如果生成失败就返回-1*/
CryptAcquireContext(&t_hCryptProv,"Mecrt Temp CSP",NULL, PROV_RSA_FULL,CRYPT_DELETEKEYSET);
if(!CryptAcquireContext(&t_hCryptProv,"Mecrt Temp CSP",NULL, PROV_RSA_FULL,CRYPT_NEWKEYSET))
{
m_iErrorNo = GetLastError();
delete []pszRealKey;
return -1;
}
//------------------------------------------------------------
/*倒入解密用的密钥文件，如果失败返回-2*/
if(!CryptImportKey(t_hCryptProv, pszRealKey, dwKeyLen, 0, 0,&t_hKey))
{
m_iErrorNo = GetLastError();
delete []pszRealKey;
return -2;
}

//-------------------------------------------------------------
if(m_pszOutData != NULL)
{
delete []m_pszOutData;
}
m_pszOutData = new char[dwInLen * 128 + 1];

*pszOutBuffer = m_pszOutData;
pszPointer = m_pszOutData;

tempDivSrcData = new unsigned char[128+1];
//-------------------------------------------------------------
// 数据解密
//------------------------------------------------------------------------
for(int i=0; i*128 < (int)dwInLen;i++)
{
pszInBuffer += i*128;

if( (dwInLen - i*128) > 0 ) j = 128;
else j = (dwInLen - i*128);

memset(tempDivSrcData,0x00,128+1);
memcpy(tempDivSrcData, pszInBuffer, j);

if(!CryptDecrypt(t_hKey, 0, true, 0, tempDivSrcData,(unsigned long *)&j))
{
m_iErrorNo = GetLastError();
result = -2;
break;
}
t += j;

memcpy(pszPointer + j, tempDivSrcData,j);
pszPointer = pszPointer + j;
}
//--------------------------------------------------
dwOutLen = t;
//----------------------------------------------------------------
//-------------------------结束清空垃圾----------------------

delete tempDivSrcData;
delete []pszRealKey;

CryptDestroyKey(t_hKey);
CryptReleaseContext(t_hCryptProv,0);

return result;
}
//---------------------------------------------------------------------------
int XRSA::Encrypt(unsigned char *pszKey, //加密用的密钥，HexStr
DWORD dwKeyLen , //加密密钥长度
unsigned char *pszInBuffer, //需要加密的缓冲区
DWORD dwInLen, //需要加密的缓冲区长度
unsigned char **pszOutBuffer, //输出密文
DWORD &dwOutLen //输出密文长度
)
{
//var begin ------------------------------------------------
HCRYPTPROV t_hCryptProv; //临时的密钥容器句柄
HCRYPTKEY t_hKey; //临时的密钥句柄
int result = 0; //返回结果值,如果正常返回为0
unsigned char *tempDivSrcData;
int j=0;
int t=0;

char *pszRealKey, *pszPointer;
//var end -------------------------------------------------

pszRealKey = new char[dwKeyLen];
dwKeyLen = HexStr2Hex(pszKey, dwKeyLen, pszRealKey);

//连接密钥容器
/*不管密钥容器存在不存在先删除它再生成,如果生成失败就返回-1*/
CryptAcquireContext(&t_hCryptProv,"Mecrt Temp CSP",NULL, PROV_RSA_FULL,CRYPT_DELETEKEYSET);
if(!CryptAcquireContext(&t_hCryptProv,"Mecrt Temp CSP",NULL, PROV_RSA_FULL,CRYPT_NEWKEYSET))
{
m_iErrorNo = GetLastError();
delete []pszRealKey;
return -1;
}
//------------------------------------------------------------
/*倒入解密用的密钥文件，如果失败返回-2*/
if(!CryptImportKey(t_hCryptProv, pszRealKey, dwKeyLen, 0, 0, &t_hKey))
{
m_iErrorNo = GetLastError();
delete []pszRealKey;
return -2;
}
//-------------------------------------------------------------
if(m_pszOutData != NULL)
{
delete []m_pszOutData;
}
m_pszOutData = new char[dwInLen * 128 + 1];

*pszOutBuffer = m_pszOutData;
pszPointer = m_pszOutData;

tempDivSrcData = new unsigned char[128+1];
//-------------------------------------------------------------
// 数据加密
for(int i=0; i*117 < (int)dwInLen;i++)
{
pszInBuffer += i * 117;

if( (dwInLen - i*117) > 0 ) j = 117;
else j = (dwInLen - i*117);

memset(tempDivSrcData,0x00,128+1);
memcpy(tempDivSrcData, pszInBuffer, j);

if(!CryptEncrypt(t_hKey, 0, true, 0, tempDivSrcData, (unsigned long *)&j, 128))
{
m_iErrorNo = GetLastError();
result = -3;
break;
}

t += j;

memcpy(pszPointer,tempDivSrcData,j);

pszPointer = pszPointer + j;
}
dwOutLen = t;
//----------------------------------------------------------------
//-------------------------结束清空垃圾----------------------

delete []tempDivSrcData;
delete []pszRealKey;

CryptDestroyKey(t_hKey);
CryptReleaseContext(t_hCryptProv,0);

return result;
}
//---------------------------------------------------------------------------
int XRSA::GenerateRSAKey(unsigned char **pszPubKey, //公钥数据，输出HexStr
DWORD &dwPubKeyLen, //公钥长度，输出
unsigned char **dwPrvKey, //私钥文件，输出HexStr
DWORD &dwPrvKeyLen //私钥长度，输出
)
{
//-------------------------Var Begin----------------------------------
HCRYPTPROV hCryptProv; //密钥容器CSP句柄
HCRYPTKEY hKey; //密钥文件的句柄
int result = 0; //函数默认返回值为0表示正常结束

char * pszTempPubKey, * pszTempPrvKey;
//-------------------------Var End------------------------------------

CryptAcquireContext(&hCryptProv,"Mecrt CSP",NULL, PROV_RSA_FULL,CRYPT_DELETEKEYSET);
if(!CryptAcquireContext(&hCryptProv,"Mecrt CSP",NULL, PROV_RSA_FULL,CRYPT_NEWKEYSET))
{
m_iErrorNo = GetLastError();
return -1;
}
//-------------------------------------------------------------------------
if (!CryptGenKey(hCryptProv,AT_KEYEXCHANGE ,0x04000000 |CRYPT_EXPORTABLE,&hKey))
{
m_iErrorNo = GetLastError();
return -2;
}

//---------------检查输出Key的长度------------------------------------------
if(!CryptExportKey(hKey,NULL,PUBLICKEYBLOB,0, NULL, &dwPubKeyLen))
{
m_iErrorNo = GetLastError();
result = -3;
goto __END;
}

//----------------取PubKey的Hex值-------------------------------------------
pszTempPubKey = new char[dwPubKeyLen];
if(!CryptExportKey(hKey,NULL,PUBLICKEYBLOB,0, pszTempPubKey, &dwPubKeyLen))
{
m_iErrorNo = GetLastError();
result = -3;

delete pszTempPubKey;

goto __END;
}

//------------输出PubKey至HexStr--------------------------------------------
if(m_pszPubKey != NULL)
{
delete []m_pszPubKey;
}
m_pszPubKey = new char[dwPubKeyLen * 2 + 1];
dwPubKeyLen = Hex2HexStr(pszTempPubKey, dwPubKeyLen, m_pszPubKey);
//---------------检查输出Key的长度------------------------------------------
if(!CryptExportKey(hKey, NULL, PRIVATEKEYBLOB,0, NULL, &dwPrvKeyLen))
{
m_iErrorNo = GetLastError();
result = -4;

delete pszTempPubKey;

goto __END;
}
//----------------取PubKey的Hex值-------------------------------------------
pszTempPrvKey = new char[dwPrvKeyLen];
if(!CryptExportKey(hKey, NULL, PRIVATEKEYBLOB, 0, pszTempPrvKey, &dwPrvKeyLen))
{
m_iErrorNo = GetLastError();
result = -4;

delete pszTempPubKey;
delete pszTempPrvKey;

goto __END;
}
//------------输出PrvKey至HexStr--------------------------------------------
if(m_pszPrvKey != NULL)
{
delete []m_pszPrvKey;
}
m_pszPrvKey = new char[dwPrvKeyLen * 2 + 1];
dwPrvKeyLen = Hex2HexStr(pszTempPrvKey, dwPrvKeyLen, m_pszPrvKey);

__END:
CryptDestroyKey(hKey);
CryptAcquireContext(&hCryptProv,"Mecrt CSP",NULL, PROV_RSA_FULL,CRYPT_DELETEKEYSET);
CryptReleaseContext(hCryptProv,0);

return result ;
}
//-------------------------------------------------------------------------
int XRSA::GetErrorNo()
{
return m_iErrorNo;
}

//----------------调用例子--------------------------

XRSA rsa;

rsa.Encrypt(.....);