关于wincrypt各位大侠请看看. ( 积分: 200 )

  • 主题发起人 主题发起人 ic
  • 开始时间 开始时间
I

ic

Unregistered / Unconfirmed
GUEST, unregistred user!
#pragma once
#include <wincrypt.h>

// 数据流加密/解密接口
class CCrypt
{
public:
CCrypt():m_hProv(NULL),m_hKey(NULL){}
~CCrypt() { Destroy(); }

operator HCRYPTPROV () const{return m_hProv;}
BOOL Create(LPCTSTR pszPwd)
{ // 初始化
if(CryptAcquireContext(&m_hProv,NULL,MS_DEF_PROV,PROV_RSA_FULL,0) ||
CryptAcquireContext(&m_hProv,NULL,MS_DEF_PROV,PROV_RSA_FULL,CRYPT_NEWKEYSET))
{
// 根据口令生成加密键
HCRYPTHASH hHash;
if(CryptCreateHash(m_hProv,CALG_MD5,0,0,&hHash))
{
if(CryptHashData(hHash,(PBYTE)pszPwd,lstrlen(pszPwd),0))
{
if(CryptDeriveKey(m_hProv,CALG_RC4,hHash,0,&m_hKey))
{
CryptDestroyHash(hHash);
return TRUE;
}
}
CryptDestroyHash(hHash);
}
CryptReleaseContext(m_hProv,0);
m_hProv=NULL;
}
return FALSE;
}
void Destroy()
{ // 释放资源
if(m_hProv)
{
CryptDestroyKey(m_hKey);
CryptReleaseContext(m_hProv,0);
m_hProv=NULL;
}
}
BOOL Encrypt(PVOID pData,DWORD cbData) const
{ // 加密数据流，采用原地加密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
return CryptEncrypt(m_hKey,NULL,TRUE,0,(PBYTE)pData,&cbData,cbData);
}
BOOL Decrypt(PVOID pData,DWORD cbData) const
{ // 解密数据流，采用原地解密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
return CryptDecrypt(m_hKey,NULL,TRUE,0,(PBYTE)pData,&cbData);
}

static DWORD GetHash(const void* pData,DWORD cbData)
{ // 计算hash值
DWORD dwValue=0;
for(DWORD i=0;i<cbData;i++)
{
dwValue=(dwValue<<5)+dwValue+((const BYTE*)pData);
}
return dwValue;
}

private:
HCRYPTPROV m_hProv; // 加密算法提供者
HCRYPTKEY m_hKey; // 加密键
};


//------------------------调用示范------------------------------------------
CString s1; char cBuf[MAX_PATH] = {0, };
BOOL bR = FALSE;
int i1 = 32, i2 = 16;
char cData[32] = {0, };
CCrypt Crypt;
Crypt.Create("bb68jkape1");
bR = Crypt.Encrypt(cBuf, i2);
Crypt.Destroy();
 
#pragma once
#include <wincrypt.h>

// 数据流加密/解密接口
class CCrypt
{
public:
CCrypt():m_hProv(NULL),m_hKey(NULL){}
~CCrypt() { Destroy(); }

operator HCRYPTPROV () const{return m_hProv;}
BOOL Create(LPCTSTR pszPwd)
{ // 初始化
if(CryptAcquireContext(&m_hProv,NULL,MS_DEF_PROV,PROV_RSA_FULL,0) ||
CryptAcquireContext(&m_hProv,NULL,MS_DEF_PROV,PROV_RSA_FULL,CRYPT_NEWKEYSET))
{
// 根据口令生成加密键
HCRYPTHASH hHash;
if(CryptCreateHash(m_hProv,CALG_MD5,0,0,&hHash))
{
if(CryptHashData(hHash,(PBYTE)pszPwd,lstrlen(pszPwd),0))
{
if(CryptDeriveKey(m_hProv,CALG_RC4,hHash,0,&m_hKey))
{
CryptDestroyHash(hHash);
return TRUE;
}
}
CryptDestroyHash(hHash);
}
CryptReleaseContext(m_hProv,0);
m_hProv=NULL;
}
return FALSE;
}
void Destroy()
{ // 释放资源
if(m_hProv)
{
CryptDestroyKey(m_hKey);
CryptReleaseContext(m_hProv,0);
m_hProv=NULL;
}
}
BOOL Encrypt(PVOID pData,DWORD cbData) const
{ // 加密数据流，采用原地加密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
return CryptEncrypt(m_hKey,NULL,TRUE,0,(PBYTE)pData,&cbData,cbData);
}
BOOL Decrypt(PVOID pData,DWORD cbData) const
{ // 解密数据流，采用原地解密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
return CryptDecrypt(m_hKey,NULL,TRUE,0,(PBYTE)pData,&cbData);
}

static DWORD GetHash(const void* pData,DWORD cbData)
{ // 计算hash值
DWORD dwValue=0;
for(DWORD i=0;i<cbData;i++)
{
dwValue=(dwValue<<5)+dwValue+((const BYTE*)pData);
}
return dwValue;
}

private:
HCRYPTPROV m_hProv; // 加密算法提供者
HCRYPTKEY m_hKey; // 加密键
};


//------------------------调用示范------------------------------------------
CString s1; char cBuf[MAX_PATH] = {0, };
BOOL bR = FALSE;
int i1 = 32, i2 = 16;
char cData[32] = {0, };
CCrypt Crypt;
Crypt.Create("bb68jkape1");
bR = Crypt.Encrypt(cBuf, i2);
Crypt.Destroy();
 
这是我译的代码.
{---------------------------------------------------------------------------
File :Crypt.pas
contents :EnCryptStr;DeCryptStr;HexToStr;StrToHex
Description :Encrypt or deCrypt a string
Parameters :
Author :
Date :2005-8-18
Notes :数据流加密采用对称加密方式，加密算法采用RC4，口令是固定的，
经MD5散列后使用
----------------------------------------------------------------------------}
unit Crypt;

interface

uses
Wincrypt,Types,Windows,Classes;

function HexToStr(S: string): string;
function StrToHex(S: string): string;


function EnCryptStr(SourStr:String ; var DestStr:String ; StrPassword:String):Boolean;
function DeCryptStr(SourStr:String ; var DestStr:String ; StrPassword:String):Boolean;



implementation
uses
Math,SysUtils,variants;

function myMessageBox(sMsg:string;sCaption:string='信息'):integer;
begin
Result:=windows.MessageBox(0,PAnsiChar(sMsg),pchar(sCaption),MB_OK+MB_ICONASTERISK);
end;




//----------------------------new

function EnCryptStr(SourStr:String ; var DestStr:String ; StrPassword:String):Boolean;


var
hProv : HCRYPTPROV;
hKey : HCRYPTKEY;
hHash : HCRYPTHASH;
dwCount: DWORD;
eof : Boolean;
lps: pchar;
hDest : TStringStream;
cbuf:array[0..MAX_PATH] of Char;
pbBuffer:PByte;
s_ms,d_ms:TMemoryStream;

begin
Result :=False;
hProv := 0;
hHash := 0;
hKey := 0;
eof:=false;
try
if not CryptAcquireContext(@hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, 0) then
if not CryptAcquireContext(@hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET) then
raise Exception.CreateFmt('CryptAcquireContext error %d', [GetLastError()]);
if not(CryptCreateHash(hProv, CALG_MD5, 0, 0, @hHash)) then
raise Exception.CreateFmt('无法产生 Hash 句柄 %d', [GetLastError()]);
if not(CryptHashData(hHash, PByte(pansichar(StrPassword)), lstrlen(pansichar(StrPassword)), 0)) then
raise Exception.CreateFmt('无法产生 Hash 值 %d', [GetLastError()]);
if not(CryptDeriveKey(hProv, CALG_RC4, hHash, 0, @hKey)) then
raise Exception.CreateFmt('HASH无法传回键值 %d', [GetLastError()]);

CryptDestroyHash(hHash);
hHash := 0;
eof:=true;

GetMem(lps, 16);
StrCopy(lps,pchar(trim(sourstr)));
dwCount:=16;

CryptEncrypt(hKey, 0, eof , 0, pbyte(lps), @dwCount, dwcount);
DestStr:= StrPas(pchar(lps));





// strpas( pchar(pointer(ur_pbyte_var)) )

// Showmessage(b);


// freemem(lps,16);
// hDestination.free;
// showmessage(
// ZeroMemory(lps,Length(sourstr) + 16);

//'蘄擏{????╞驵'
//'蘄?
//'蘄擏楛A蜓酰?╞鎂FE'
// DestStr:=sourstr;

{

GetMem(pbBuffer, dwBufferLen);
if (pbBuffer=nil) then
begin
myMessageBox('内存不足,无法分配内存空间');
Exit;
end;
repeat
dwCount := hSource.Read(pbBuffer^,dwBlockLen);
if (dwCount=0) then
begin
myMessageBox('无法打开源文件');
exit;
end;
eof:=true;
dwcount:=16; //dwBufferLen
if not CryptEncrypt(hKey, 0, eof , 0, pbBuffer, @dwCount, dwcount) then
begin
myMessageBox('无法打开缓存');
exit;
end;

if hDestination.Write(pbBuffer^,dwCount)=0 then
begin
myMessageBox('----');
exit;
end;
until not(hSource.Position<hSource.Size);
//怕字串流中间有 null 的问题 , 所以需要將加密结果转成HEX
DestStr:=StrToHex(hDestination.DataString);
}
Result:= true;
finally
// if(hSource<>nil) then hSource.free;
// if(hDestination<>nil) then hDestination.free;
// if((pbKeyBlob<>nil) and (StrPassword = '')) then FreeMem(pbKeyBlob);
// if(pbBuffer<>nil) then FreeMem(pbBuffer);

if(hKey<>0) then CryptDestroyKey(hKey);
if(hHash<>0) then CryptDestroyHash(hHash);
if(hProv<>0) then CryptReleaseContext(hProv, 0);

end;
end;


function DeCryptStr(SourStr:String ; var DestStr:String ; StrPassword:String):Boolean;
var
hSource, hDestination: TStringStream;
hProv : HCRYPTPROV;
hKey : HCRYPTKEY;
hXchgKey : HCRYPTKEY;
hHash : HCRYPTHASH;

pbKeyBlob : PByte;
pbBuffer : PByte;

dwKeyBlobLen : DWORD;
dwBlockLen : DWORD;
dwBufferLen : DWORD;
dwCount : DWORD;
eof : Boolean;
tmp_buf : array [0..80] of char;
sHex : String;
begin
Result:=false;
hProv := 0;
hKey := 0;
hXchgKey := 0;
hHash := 0;
eof:=false;
sHex:=HexToStr(SourStr);
try
hSource := TStringStream.Create(sHex);
if (hSource=nil) then
begin
myMessageBox('创建字符流失败');
Exit;
end;

hDestination := TStringStream.Create('');
if (hDestination=nil) then
begin
myMessageBox('创建字符流失败');
exit;
end;
if not CryptAcquireContext(@hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, 0) then
begin
if not CryptAcquireContext(@hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET) then
raise Exception.CreateFmt('CryptAcquireContext error %d', [GetLastError()]);
end;
if not(CryptCreateHash(hProv, CALG_MD5, 0, 0, @hHash)) then
begin
myMessageBox('不能创建HASH句柄?');
exit;
end;

if not(CryptHashData(hHash, PByte(StrPassword), Length(StrPassword), 0)) then
begin
myMessageBox('产生HASH值时发生错误 ?');
exit
end;

if not(CryptDeriveKey(hProv, ENCRYPT_ALGORITHM, hHash, 0, @hKey)) then
begin
myMessageBox('HASH无法传回键值');
exit
end;
CryptDestroyHash(hHash);
hHash := 0;
// end;
dwBlockLen := 1000 - (1000 mod ENCRYPT_BLOCK_SIZE);
dwBufferLen := dwBlockLen;
GetMem(pbBuffer, dwBufferLen);
if (pbBuffer=nil) then
begin
myMessageBox('内存不足,无法分配内存空间');
Exit
end;
repeat
dwCount:=hSource.Read(pbBuffer^,dwBlockLen);
if (dwCount=0) then
begin
myMessageBox('无法读取源字符');
Exit
end;
eof := true;
if not(CryptDecrypt(hKey, 0, eof, 0, pbBuffer, @dwCount)) then
begin
myMessageBox('解密时发生错误?');
Exit
end;
if (hDestination.Write(pbBuffer^, dwCount)=0) then
begin
myMessageBox('[写入目标缓存失败?');
exit;
end;
until not(hSource.Position<hSource.Size);
DestStr:=hDestination.DataString;
Result:=true;
finally
if(hSource<>nil) then hSource.free;
if(hDestination<>nil) then hDestination.free;
if((pbKeyBlob<>nil) and (StrPassword = '')) then FreeMem(pbKeyBlob);
if(pbBuffer<>nil) then FreeMem(pbBuffer);
if(hKey<>0) then CryptDestroyKey(hKey);
if(hXchgKey<>0) then CryptDestroyKey(hXchgKey);
if(hHash<>0) then CryptDestroyHash(hHash);
if(hProv<>0) then CryptReleaseContext(hProv, 0);
end;
end;

function StrToHex(S: string): string;
var
i: integer;
begin
Result := '';
for i := 1 to Length( S ) do
Result := Result + IntToHex( Ord( S ), 2 );
end;

function HexToStr(S: string): string;
var
i: integer;
begin
Result := '';
for i := 1 to Length( S ) do
begin
if ((i mod 2) = 1) then
Result := Result + Chr( StrToInt( '0x' + Copy( S, i, 2 )));
end;
end;






end.
 
都没有人来,唉..
 
TCrypt = class
private
m_hProv: HCRYPTPROV; // 加密算法提供者
m_hKey: HCRYPTKEY;
procedure Destroy; // 加密键
public
constructor Create;
destructor Destory; override;
function CreatePWD(pszPwd: PChar): Boolean;
function Encrypt(pData: Pointer; cbData: DWord): Boolean;
function Decrypt(pData: Pointer; cbData: DWord): Boolean;
class function GetHash(const pData: Pointer; cbData: DWord): DWord;
end;

procedure TCrypt.Create;
begin
m_hProv := nil;
m_hKey := nil;
end;

function TCrypt.CreatePWD(pszPwd: PChar): Boolean;
begin
// 初始化
if (CryptAcquireContext(@m_hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, 0) or
CryptAcquireContext(@m_hProv, nil, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET)) then begin

// 根据口令生成加密键
HCRYPTHASH hHash;
if (CryptCreateHash(m_hProv, CALG_MD5, 0, 0, @hHash)) then begin
if (CryptHashData(hHash, (PBYTE)pszPwd, lstrlen(pszPwd), 0)) then begin
if (CryptDeriveKey(m_hProv, CALG_RC4, hHash, 0, @m_hKey)) then begin
CryptDestroyHash(hHash);
Result := True;
Exit;
end;
end;
CryptDestroyHash(hHash);
end;
CryptReleaseContext(m_hProv, 0);
m_hProv = nil;
end;
Result := FALSE;
end;

function TCrypt.Decrypt(pData: Pointer; cbData: DWord): Boolean;
begin
// 解密数据流，采用原地解密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
Result := CryptDecrypt(m_hKey, nil, True, 0, (PBYTE)pData, @cbData);
end;

destructor TCrypt.Destroy;
begin
if (m_hProv > 0) then begin
CryptDestroyKey(m_hKey);
CryptReleaseContext(m_hProv, 0);
m_hProv = nil;
end;
inhertied;
end;

function TCrypt.Encrypt(pData: Pointer; cbData: DWord): Boolean;
begin
// 加密数据流，采用原地加密方式，如果希望保存原来的缓冲区，应先复制后再调用该函数
Result := CryptEncrypt(m_hKey, nil, True, 0, (PBYTE)pData, &cbData, cbData);
end;

class function TCrypt.GetHash(const pData: Pointer; cbData: DWord): DWord;
var
dwValue: DWord;
I: Integer;
begin // 计算hash值
dwValue := 0;
for I := 0 to cbData - 1 do
dwValue := (dwValue shl 5) + dwValue + ((PBYTE)pData);

Result := dwValue;
end;
翻译了一部分，但是没有头文件，不知道那两个声明怎么处理
 
{---------------------------------------------------------------------------
File :Wincrypt.pas
Contents:Cryptographic API Prototypes and Definitions
Author :Copyright (C) Microsoft Corporation
Minder :
Date :2005-8-18
Notes :转换VC++6 wincrypt.h 文件
----------------------------------------------------------------------------}

unit Wincrypt;

{$ALIGN ON}

{$IFNDEF VER90}
{$WEAKPACKAGEUNIT}
{$ENDIF}
interface

uses
Windows;

const
CryptDll = 'advapi32.dll';

function GET_ALG_CLASS(x :integer) :integer;
function GET_ALG_TYPE(x :integer) :integer;
function GET_ALG_SID(x :integer) :integer;

{Algorithm classes }
const
ALG_CLASS_ANY = 0;
ALG_CLASS_SIGNATURE = (1 shl 13);
ALG_CLASS_MSG_ENCRYPT = (2 shl 13);
ALG_CLASS_DATA_ENCRYPT = (3 shl 13);
ALG_CLASS_HASH = (4 shl 13);
ALG_CLASS_KEY_EXCHANGE = (5 shl 13);
{Algorithm types }
ALG_TYPE_ANY = 0;
ALG_TYPE_DSS = (1 shl 9);
ALG_TYPE_RSA = (2 shl 9);
ALG_TYPE_BLOCK = (3 shl 9);
ALG_TYPE_STREAM = (4 shl 9);
{Generic sub-ids }
ALG_SID_ANY = 0;
{Some RSA sub-ids }
ALG_SID_RSA_ANY = 0;
ALG_SID_RSA_PKCS = 1;
ALG_SID_RSA_MSATWORK = 2;
ALG_SID_RSA_ENTRUST = 3;
ALG_SID_RSA_PGP = 4;
{Some DSS sub-ids}
ALG_SID_DSS_ANY = 0;
ALG_SID_DSS_PKCS = 1;
ALG_SID_DSS_DMS = 2;
{Block cipher sub ids DES sub_ids }
ALG_SID_DES = 1;
ALG_SID_3DES = 3;
ALG_SID_DESX = 4;
ALG_SID_IDEA = 5;
ALG_SID_CAST = 6;
ALG_SID_SAFERSK64 = 7;
ALD_SID_SAFERSK128 = 8;
{KP_MODE }
CRYPT_MODE_CBCI = 6; {ANSI CBC Interleaved}
CRYPT_MODE_CFBP = 7; {ANSI CFB Pipelined}
CRYPT_MODE_OFBP = 8; {ANSI OFB Pipelined}
CRYPT_MODE_CBCOFM = 9; {ANSI CBC + OF Masking}
CRYPT_MODE_CBCOFMI = 10; {ANSI CBC + OFM Interleaved}
{RC2 sub-ids }
ALG_SID_RC2 = 2;
{Stream cipher sub-ids }
ALG_SID_RC4 = 1;
ALG_SID_SEAL = 2;
{Hash sub ids }
ALG_SID_MD2 = 1;
ALG_SID_MD4 = 2;
ALG_SID_MD5 = 3;
ALG_SID_SHA = 4;
ALG_SID_MAC = 5;
ALG_SID_RIPEMD = 6;
ALG_SID_RIPEMD160 = 7;
ALG_SID_SSL3SHAMD5 = 8;
{Our silly example sub-id }
ALG_SID_EXAMPLE = 80;

{$IFNDEF ALGIDDEF}
{$DEFINE ALGIDDEF}
type
ALG_ID = DWORD; //Cardinal;
{$ENDIF}

{algorithm identifier definitions }
const
CALG_MD2 = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD2);
CALG_MD4 = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD4);
CALG_MD5 = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD5);
CALG_SHA = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_SHA);
CALG_MAC = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MAC);
CALG_RSA_SIGN = (ALG_CLASS_SIGNATURE or ALG_TYPE_RSA or ALG_SID_RSA_ANY);
CALG_DSS_SIGN = (ALG_CLASS_SIGNATURE or ALG_TYPE_DSS or ALG_SID_DSS_ANY);
CALG_RSA_KEYX = (ALG_CLASS_KEY_EXCHANGE or ALG_TYPE_RSA or ALG_SID_RSA_ANY);
CALG_DES = (ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_DES);
CALG_RC2 = (ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_BLOCK or ALG_SID_RC2);
CALG_RC4 = (ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_STREAM or ALG_SID_RC4);
CALG_SEAL = (ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_STREAM or ALG_SID_SEAL);

type
VTableProvStruc = record
Version :LongInt;
FuncVerifyImage :TFarProc;
FuncReturnhWnd :TFarProc;
end;
PVTableProvStruc = ^VTableProvStruc;

const
{dwFlags definitions for CryptAquireContext }
CRYPT_VERIFYCONTEXT = $F0000000;
CRYPT_NEWKEYSET = $00000008;
CRYPT_DELETEKEYSET = $10;
{dwFlag definitions for CryptGenKey }
CRYPT_EXPORTABLE = $00000001;
CRYPT_USER_PROTECTED = $00000002;
CRYPT_CREATE_SALT = $00000004;
CRYPT_UPDATE_KEY = $00000008;
{exported key blob definitions }
SIMPLEBLOB = $1;
PUBLICKEYBLOB = $6;
PRIVATEKEYBLOB = $7;
AT_KEYEXCHANGE = 1;
AT_SIGNATURE = 2;
CRYPT_USERDATA = 1;
{dwParam }
KP_IV = 1; {Initialization vector}
KP_SALT = 2; {Salt value}
KP_PADDING = 3; {Padding values}
KP_MODE = 4; {Mode of the cipher}
KP_MODE_BITS = 5; {Number of bits to feedback}
KP_PERMISSIONS = 6; {Key permissions DWORD}
KP_ALGID = 7; {Key algorithm}
KP_BLOCKLEN = 8; {Block size of the cipher}
{KP_PADDING }
PKCS5_PADDING = 1; {PKCS 5 (sec 6.2) padding method}
{KP_MODE }
CRYPT_MODE_CBC = 1; {Cipher block chaining}
CRYPT_MODE_ECB = 2; {Electronic code book}
CRYPT_MODE_OFB = 3; {Output feedback mode}
CRYPT_MODE_CFB = 4; {Cipher feedback mode}
CRYPT_MODE_CTS = 5; {Ciphertext stealing mode}
{KP_PERMISSIONS }
CRYPT_ENCRYPT = $0001; {Allow encryption}
CRYPT_DECRYPT = $0002; {Allow decryption}
CRYPT_EXPORT = $0004; {Allow key to be exported}
CRYPT_READ = $0008; {Allow parameters to be read}
CRYPT_WRITE = $0010; {Allow parameters to be set}
CRYPT_MAC = $0020; {Allow MACs to be used with key}
HP_ALGID = $0001; {Hash algorithm}
HP_HASHVAL = $0002; {Hash value}
HP_HASHSIZE = $0004; {Hash value size}
CRYPT_FAILED = FALSE;
CRYPT_SUCCEED = TRUE;

function RCRYPT_SUCCEEDED(rt :BOOL) :BOOL;
function RCRYPT_FAILED(rt :BOOL) :BOOL;

const
{CryptGetProvParam}
PP_ENUMALGS = 1;
PP_ENUMCONTAINERS = 2;
PP_IMPTYPE = 3;
PP_NAME = 4;
PP_VERSION = 5;
PP_CONTAINER = 6;
CRYPT_FIRST = 1;
CRYPT_NEXT = 2;
CRYPT_IMPL_HARDWARE = 1;
CRYPT_IMPL_SOFTWARE = 2;
CRYPT_IMPL_MIXED = 3;
CRYPT_IMPL_UNKNOWN = 4;
{CryptSetProvParam}
PP_CLIENT_HWND = 1;
PROV_RSA_FULL = 1;
PROV_RSA_SIG = 2;
PROV_DSS = 3;
PROV_FORTEZZA = 4;
PROV_MS_EXCHANGE = 5;
PROV_SSL = 6;
{STT defined Providers}
PROV_STT_MER = 7;
PROV_STT_ACQ = 8;
PROV_STT_BRND = 9;
PROV_STT_ROOT = 10;
PROV_STT_ISS = 11;
MS_DEF_PROV_A = 'Microsoft Base Cryptographic Provider v1.0';
MS_DEF_PROV_W = 'Microsoft Base Cryptographic Provider v1.0';
{$IFDEF UNICODE}
MS_DEF_PROV = MS_DEF_PROV_W;
{$ELSE}
MS_DEF_PROV = MS_DEF_PROV_A;
{$ENDIF}

{$IFDEF USE_BLOCK_CIPHER}
ENCRYPT_ALGORITHM = CALG_RC2;
ENCRYPT_BLOCK_SIZE = 8;
{$ELSE}
ENCRYPT_ALGORITHM = CALG_RC4;
ENCRYPT_BLOCK_SIZE = 1;
{$ENDIF}

MAXUIDLEN = 64;
CUR_BLOB_VERSION = 2;

type
PROV_ENUMALGS = record
aiAlgid :ALG_ID;
dwBitLen :LongInt;
dwNameLen :LongInt;
szName :array[0..20 - 1] of Char;
end;
PPROV_ENUMALGS = ^PROV_ENUMALGS;

type
PUBLICKEYSTRUC = record
bType :BYTE;
bVersion :BYTE;
reserved :Word;
aiKeyAlg :ALG_ID;
end;
PPUBLICKEYSTRUC = ^PUBLICKEYSTRUC;
BLOBHEADER = PUBLICKEYSTRUC;
PBLOBHEADER = ^BLOBHEADER;

type
RSAPUBKEY = record
magic :DWORD; // Has to be RSA1
bitlen :DWORD; // # of bits in modulus
pubexp :DWORD; // public exponent
{Modulus data follows }
end;
PRSAPUBKEY = ^RSAPUBKEY;

type
HCRYPTPROV = DWORD; //cardinal;
PHCRYPTPROV = ^HCRYPTPROV;
HCRYPTKEY = DWORD; //cardinal;
PHCRYPTKEY = ^HCRYPTKEY;
HCRYPTHASH = DWORD; //cardinal;
PHCRYPTHASH = ^HCRYPTHASH;

function CryptAcquireContextA(phProv :PHCRYPTPROV;
pszContainer :PAnsiChar;
pszProvider :PAnsiChar;
dwProvType :LongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptAcquireContext(phProv :PHCRYPTPROV;
pszContainer :PAnsiChar;
pszProvider :PAnsiChar;
dwProvType :LongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptAcquireContextW(phProv :PHCRYPTPROV;
pszContainer :PWideChar;
pszProvider :PWideChar;
dwProvType :LongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptReleaseContext(hProv :HCRYPTPROV;
dwFlags :LongInt) :BOOL;stdcall;

function CryptGenKey(hProv :HCRYPTPROV;
Algid :ALG_ID;
dwFlags :LongInt;
phKey :PHCRYPTKEY) :BOOL;stdcall;

function CryptDeriveKey(hProv :HCRYPTPROV;
Algid :ALG_ID;
hBaseData :HCRYPTHASH;
dwFlags :LongInt;
phKey :PHCRYPTKEY) :BOOL;stdcall;

function CryptDestroyKey(hKey :HCRYPTKEY) :BOOL;stdcall;

function CryptSetKeyParam(hKey :HCRYPTKEY;
dwParam :LongInt;
pbData :PBYTE;
dwFlags :LongInt) :BOOL;stdcall;

function CryptGetKeyParam(hKey :HCRYPTKEY;
dwParam :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptSetHashParam(hHash :HCRYPTHASH;
dwParam :LongInt;
pbData :PBYTE;
dwFlags :LongInt) :BOOL;stdcall;

function CryptGetHashParam(hHash :HCRYPTHASH;
dwParam :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptSetProvParam(hProv :HCRYPTPROV;
dwParam :LongInt;
pbData :PBYTE;
dwFlags :LongInt) :BOOL;stdcall;

function CryptGetProvParam(hProv :HCRYPTPROV;
dwParam :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptGenRandom(hProv :HCRYPTPROV;
dwLen :LongInt;
pbBuffer :PBYTE) :BOOL;stdcall;

function CryptGetUserKey(hProv :HCRYPTPROV;
dwKeySpec :LongInt;
phUserKey :PHCRYPTKEY) :BOOL;stdcall;

function CryptExportKey(hKey :HCRYPTKEY;
hExpKey :HCRYPTKEY;
dwBlobType :LongInt;
dwFlags :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt) :BOOL;stdcall;

function CryptImportKey(hProv :HCRYPTPROV;
pbData :PBYTE;
dwDataLen :LongInt;
hPubKey :HCRYPTKEY;
dwFlags :LongInt;
phKey :PHCRYPTKEY) :BOOL;stdcall;

function CryptEncrypt(hKey :HCRYPTKEY;
hHash :HCRYPTHASH;
Final :Bool;
dwFlags :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt;
dwBufLen :LongInt) :BOOL;stdcall;

function CryptDecrypt(hKey :HCRYPTKEY;
hHash :HCRYPTHASH;
Final :Bool;
dwFlags :LongInt;
pbData :PBYTE;
pdwDataLen :PLongInt) :BOOL;stdcall;

function CryptCreateHash(hProv :HCRYPTPROV;
Algid :ALG_ID;
hKey :HCRYPTKEY;
dwFlags :LongInt;
phHash :PHCRYPTHASH) :BOOL;stdcall;

function CryptHashData(hHash :HCRYPTHASH;
pbData :PBYTE;
dwDataLen :LongInt;
dwFlags :LongInt) :BOOL;stdcall;

function CryptHashSessionKey(hHash :HCRYPTHASH;
hKey :HCRYPTKEY;
dwFlags :LongInt) :BOOL;stdcall;

function CryptDestroyHash(hHash :HCRYPTHASH) :BOOL;stdcall;

function CryptSignHashA(hHash :HCRYPTHASH;
dwKeySpec :LongInt;
sDescription :PAnsiChar;
dwFlags :LongInt;
pbSignature :PBYTE;
pdwSigLen :PLongInt) :BOOL;stdcall;

function CryptSignHash(hHash :HCRYPTHASH;
dwKeySpec :LongInt;
sDescription :PAnsiChar;
dwFlags :LongInt;
pbSignature :PBYTE;
pdwSigLen :PLongInt) :BOOL;stdcall;

function CryptSignHashW(hHash :HCRYPTHASH;
dwKeySpec :LongInt;
sDescription :PWideChar;
dwFlags :LongInt;
pbSignature :PBYTE;
pdwSigLen :PLongInt) :BOOL;stdcall;

function CryptVerifySignatureA(hHash :HCRYPTHASH;
pbSignature :PBYTE;
dwSigLen :LongInt;
hPubKey :HCRYPTKEY;
sDescription :PAnsiChar;
dwFlags :LongInt) :BOOL;stdcall;

function CryptVerifySignature(hHash :HCRYPTHASH;
pbSignature :PBYTE;
dwSigLen :LongInt;
hPubKey :HCRYPTKEY;
sDescription :PAnsiChar;
dwFlags :LongInt) :BOOL;stdcall;

function CryptVerifySignatureW(hHash :HCRYPTHASH;
pbSignature :PBYTE;
dwSigLen :LongInt;
hPubKey :HCRYPTKEY;
sDescription :PWideChar;
dwFlags :LongInt) :BOOL;stdcall;


function CryptSetProviderA(pszProvName :PAnsiChar;
dwProvType :LongInt) :BOOL;stdcall;

function CryptSetProvider(pszProvName :PAnsiChar;
dwProvType :LongInt) :BOOL;stdcall;

function CryptSetProviderW(pszProvName :PWideChar;
dwProvType :LongInt) :BOOL;stdcall;

implementation

{Macro inplementation}

function GET_ALG_CLASS(x :integer) :integer;
begin
Result := (x and (7 shl 13));
end;

function GET_ALG_TYPE(x :integer) :integer;
begin
Result := (x and (15 shl 9));
end;

function GET_ALG_SID(x :integer) :integer;
begin
Result := (x and (511));
end;

function RCRYPT_SUCCEEDED(rt :BOOL) :BOOL;
begin
Result := rt = CRYPT_SUCCEED;
end;

function RCRYPT_FAILED(rt :BOOL) :BOOL;
begin
Result := rt = CRYPT_FAILED;
end;
{end Macro}

function CryptAcquireContextA;external CryptDll name 'CryptAcquireContextA';
{$IFDEF UNICODE}
function CryptAcquireContext;external CryptDll name 'CryptAcquireContextW';
{$ELSE}
function CryptAcquireContext;external CryptDll name 'CryptAcquireContextA';
{$ENDIF}
function CryptAcquireContextW;external CryptDll name 'CryptAcquireContextW';
function CryptReleaseContext;external CryptDll name 'CryptReleaseContext';
function CryptGenKey;external CryptDll name 'CryptGenKey';
function CryptDeriveKey;external CryptDll name 'CryptDeriveKey';
function CryptDestroyKey;external CryptDll name 'CryptDestroyKey';
function CryptSetKeyParam;external CryptDll name 'CryptSetKeyParam';
function CryptGetKeyParam;external CryptDll name 'CryptGetKeyParam';
function CryptSetHashParam;external CryptDll name 'CryptSetHashParam';
function CryptGetHashParam;external CryptDll name 'CryptGetHashParam';
function CryptSetProvParam;external CryptDll name 'CryptSetProvParam';
function CryptGetProvParam;external CryptDll name 'CryptGetProvParam';
function CryptGenRandom;external CryptDll name 'CryptGenRandom';
function CryptGetUserKey;external CryptDll name 'CryptGetUserKey';
function CryptExportKey;external CryptDll name 'CryptExportKey';
function CryptImportKey;external CryptDll name 'CryptImportKey';
function CryptEncrypt;external CryptDll name 'CryptEncrypt';
function CryptDecrypt;external CryptDll name 'CryptDecrypt';
function CryptCreateHash;external CryptDll name 'CryptCreateHash';
function CryptHashData;external CryptDll name 'CryptHashData';
function CryptHashSessionKey;external CryptDll name 'CryptHashSessionKey';
function CryptDestroyHash;external CryptDll name 'CryptDestroyHash';
function CryptSignHashA;external CryptDll name 'CryptSignHashA';
{$IFDEF UNICODE}
function CryptSignHash;external CryptDll name 'CryptSignHashW';
{$ELSE}
function CryptSignHash;external CryptDll name 'CryptSignHashA';
{$ENDIF}
function CryptSignHashW;external CryptDll name 'CryptSignHashW';
function CryptVerifySignatureA;external CryptDll name 'CryptVerifySignatureA';
{$IFDEF UNICODE}
function CryptVerifySignature;external CryptDll name 'CryptVerifySignatureW';
{$ELSE}
function CryptVerifySignature;external CryptDll name 'CryptVerifySignatureA';
{$ENDIF}
function CryptVerifySignatureW;external CryptDll name 'CryptVerifySignatureW';
function CryptSetProviderA;external CryptDll name 'CryptSetProviderA';
{$IFDEF UNICODE}
function CryptSetProvider;external CryptDll name 'CryptSetProviderW';
{$ELSE}
function CryptSetProvider;external CryptDll name 'CryptSetProviderA';
{$ENDIF}
function CryptSetProviderW;external CryptDll name 'CryptSetProviderW';

end.
 
我现在转过来的代码与原来的VC代 码生成的字串有区别,估计是位数的原因,但还没想到如何解决.如果那位朋友想到了,请贴一下.多谢了.
 
呵呵，帮顶一下，回家了

－－－－－－－－－－－－－
通常我顶了以后就会来很多人抢分滴[:D][:D][:D]
 
我正好有个这样的例子，是从前千中元写的，你要的话，就留个EMAIL，拿去试试吧
 
to chenybin, 谢谢帮顶,
to app2001, 我的EMAIL:66101601@163.COM.多谢.
 
to app2001:
不行的,这个文件转出来不一致

比如:1 加密出来是以下样子,
---------------- 二进制状况 -------------------
7D
---------------- ASCII 状况 -------------------
}
--------------- 文本文字状况 ------------------
}
而以前的VC写的程序转出来是这样的.
蘄鱯霢?澹挢竍
相差太远.
 
wincrypt是和intrcpt.dll一样的东东吧？
 
来领分了，呵呵
 
多人接受答案了。
 
您必须登录或注册才可回复。

Similar threads

W
救命：关于IHTMLDocument2的问题,诸位大侠看看(200)
回复
4
查看
2K
stlont
S
X
vc++翻译成Delphi ( 积分: 200 )
回复
0
查看
434
xaviter
X
小
如何监听记录本机指定端口的进出数据(端口复用) ( 积分: 200 )
回复
0
查看
503
小虫77
小
H
有熟悉SDK合C++的吗？看看我试验的一段有关窗口类注册、创建窗口实类...的程序为什么没有报错？ ( 积分: 200 )
回复
1
查看
800
NeutronDelphi
N
V
请高手来帮我看看这段用钱买回来的代码--关于读写内存的 ( 积分: 200 )
2
回复
25
查看
642
VasonChen
V
后退
顶部