WinCrypt库使用

字数统计: 3.7k字   |   阅读时长≈ 17分

上次祥云杯遇到了利用WinCrypt库模拟勒索病毒加密的程序。虽然这个库被微软官方认为已经过时了，但还是大致来了解一下。

WinCrypt库使用

0x00 简介

wincrypt库是微软推出的加密库，里面由几个内置的加密API，能够比较方便的加密文件，而不需要去探索加密算法的内核。

当然这个库已经开始要被微软淘汰了，不过现在大部分的病毒，勒索软件，或者是一些老软件用的还是这个库，所以还是了解一下吧。

关于新一代加密API，详见：

Cryptography API: Next Generation - Win32 apps | Microsoft Docs

本文通过研究一个别人写的Demo，稍微探讨一下这个加密库。

0x01 举例分析

我选择直接从一个别人已经写好的C++源码中分析加密流程。

原链接在最后的参考部分给出了。

0x02 成员体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class CMyCryptOpt{
/*---成员元素---*/
private:
	FILE* m_hSource;
	FILE* m_hDestination;

	HCRYPTPROV m_hCryptProv;
	HCRYPTKEY  m_hKey;
	HCRYPTHASH m_hHash;

	PBYTE	m_pbBuffer;
	DWORD   m_dwBlockLen;
	DWORD   m_dwBufferLen;
	DWORD   m_dwCount;
}

private域的成员元素保存了实现文件加密的所有必要变量。

文件指针

首先声明了两个FILE*指针，这是两个文件指针。

1
2
FILE* m_hSource;
FILE* m_hDestination;

一个指向源文件，一个指向目标文件。

对这两个文件指针进行初始化，读取，写入，关闭等操作，由

1
2
3
4
5
6
7
8
9
10
11
12
// 打开/创建/覆写/读取文件（取决于_Mode类型）
FILE* fopen(const char* _FileName, const char* _Mode);
// 关闭文件流
int fclose(const char* _Stream);
// 检测文件流是否有错误
int ferror(const char* _Stream);
// 检测文件指针是否指向末尾
int feof(const char* _Stream);
// 从文件流中读取_ElementCount个数据元素
size_t fread(void*  _Buffer, size_t _ElementSize, size_t _ElementCount, FILE*  _Stream);
// 向文件流中写入_ElementCount个数据元素
size_t fwrite(void*  _Buffer, size_t _ElementSize, size_t _ElementCount, FILE*  _Stream);

这些函数进行。

当然在Windows平台上，这些C语言库函数，实际上最后调用的都是Windows API。

比如fopen(), fread()，最后还是会调用CreateFile(), ReadFile()函数等。

加密提供者句柄（HCRYPTPROV)

1
HCRYPTPROV	m_hCryptProv;

这个HCRYPTPROV我暂且解释成Crypt Provider Handle，也就是一个加密提供者句柄。

翻了一下MSDN，HCRYPTPROV实际上叫做Cryptography Service Provider(CSP)，定义是：

(CSP) An independent software module that actually performs cryptography algorithms for authentication, encoding, and encryption.

也就是对一个加密模块的抽象与包装。

当然实际上，

1
2
3
typedef ULONG_PTR HCRYPTPROV;
typedef ULONG_PTR HCRYPTKEY;
typedef ULONG_PTR HCRYPTHASH;

这些句柄都仅仅是一个长指针罢了，核心是它指向的区域里面塞了什么玩意，也就是没有H的CRYPTPROV，即具体的结构体。

不过似乎微软并没有具体公开这个结构体，只给了一个句柄让我们用。

不过我翻到了一个有关Windows栈溢出漏洞，这个文章上似乎搞到了其中一个，HCRYPTKEY结构体的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 而HCRYPTKEY指向的是一个包含有多个函数地址的结构体，该结构体内容如下：
typedef struct _CRYPTKEY{
    int (*p_fun_0x00_CPGenKey)();
    int (*p_fun_0x04_CPDeriveKey)();
    int (*p_fun_0x08_CPDestroyKey)();
    int (*p_fun_0x0C_CPSetKeyParam)();
    int (*p_fun_0x10_CPGetKeyParam)();
    int (*p_fun_0x14_CPExportKey)();
    int (*p_fun_0x18_CPImportKey)();
    int (*p_fun_0x1C_CPEncrypt)();
    int (*p_fun_0x20_CPDecrypt)();
    int (*p_fun_0x24_CPDuplicateKey)();
    CRYPTPROV m_0x28_CRYPTPROV;
    
    int m_0x2C;
    int m_0x30_status;
    int m_0x34_index;
}CRYPTKEY, HCRYPTKEY;

不得不说这个结构体和我调试的时候，点入HCRYPTKEY变量时发现一大堆函数指针的事实是一致的。

Structure of HCRYPTKEY Data (codeguru.com)

这个帖子里面也说了，这些结构是逆向工程师将cryptsp.dll进行逆向工程后得到的。

这个句柄是加密流程中最开始需要初始化的。

此句柄使用CryptAcquireContext函数获取。

1
2
3
4
5
6
7
8
9
BOOL
WINAPI
CryptAcquireContextW(
    _Out_       HCRYPTPROV  *phProv,
    _In_opt_    LPCWSTR    szContainer,
    _In_opt_    LPCWSTR    szProvider,
    _In_        DWORD       dwProvType,
    _In_        DWORD       dwFlags
    );

这个函数，以及其他重要API，待会儿再阐述。

密钥句柄（HCRYPTKEY）

1
HCRYPTKEY	m_hKey;

上面刚刚放出了逆向出来的结构体。

MSDN上对于HCRYPTKEY的解释：

The HCRYPTKEY data type is used to represent handles to cryptographic keys. These handles are used to indicate to the CSP module which key is being used in a specific operation. The CSP module does not enable direct access to the key values. Instead, the user performs functions by using the key value through the key handle.

HCRYPTKEY数据类型用于表示加密密钥的句柄。这些句柄用于向CSP模块指示在一个特定的操作中使用哪个密钥。CSP模块不直接访问密钥值。相反，用户通过密钥句柄使用密钥值来执行功能。

生成密钥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
BOOL
WINAPI
CryptGenKey(
    _In_    HCRYPTPROV  hProv,
    _In_    ALG_ID      Algid,
    _In_    DWORD       dwFlags,
    _Out_   HCRYPTKEY   *phKey
    );
    
BOOL
WINAPI
CryptDeriveKey(
    _In_    HCRYPTPROV  hProv,
    _In_    ALG_ID      Algid,
    _In_    HCRYPTHASH  hBaseData,
    _In_    DWORD       dwFlags,
    _Out_   HCRYPTKEY   *phKey
    );

可以使用这些函数（没列举完），根据哈希对象（或者不用），生成会话密钥。

销毁密钥

1
2
3
4
5
6
WINADVAPI
BOOL
WINAPI
CryptDestroyKey(
    _In_    HCRYPTKEY   hKey
    );

使用密钥进行加密

1
2
3
4
5
6
7
8
9
10
11
12
WINADVAPI
_Success_(0 != return) BOOL
WINAPI
CryptEncrypt(
    _In_                                            	 HCRYPTKEY   hKey,
    _In_                                            	 HCRYPTHASH  hHash,
    _In_                                            	 BOOL    Final,
    _In_                                            	 DWORD   dwFlags,
    _Inout_updates_bytes_to_opt_(dwBufLen, *pdwDataLen)  BYTE    *pbData,
    _Inout_                                         	 DWORD   *pdwDataLen,
    _In_                                            	 DWORD   dwBufLen
    );

哈希对象句柄（HCRYPTHASH)

1
HCRYPTHASH m_hHash;

MSDN解释：

The HCRYPTHASH data type is used to represent handles to hash objects. These handles indicate to the CSP module which hash is being used in a particular operation. The CSP module does not enable direct manipulation of the hash values. Instead, the user manipulates the hash values through the hash handle.

HCRYPTHASH数据类型是用来表示哈希对象的句柄。这些句柄向CSP模块表明在一个特定的操作中使用的是哪个哈希值。CSP模块不直接操作哈希值。相反，用户通过哈希句柄来操作哈希值。

对于Hash Objects的解释

An object used to hash messages or session keys. The hash object is created by a call to CryptCreateHash(). The definition of the object is defined by the CSP specified in the call.

创建哈希对象

1
2
3
4
5
6
7
8
9
10
WINADVAPI
BOOL
WINAPI
CryptCreateHash(
    _In_    HCRYPTPROV  hProv,
    _In_    ALG_ID      Algid,
    _In_    HCRYPTKEY   hKey,
    _In_    DWORD       dwFlags,
    _Out_   HCRYPTHASH  *phHash
    );

利用哈希对象

使用输入数据（比如一个密码）产生哈希值

1
2
3
4
5
CryptHashData(
		m_hHash,
		(BYTE*)lpPassword,
		strlen(lpPassword),
		0)
1
2
3
4
5
6
7
8
9
WINADVAPI
BOOL
WINAPI
CryptHashData(
    _In_                    HCRYPTHASH  hHash,
    _In_reads_bytes_(dwDataLen)  CONST BYTE  *pbData,
    _In_                    DWORD   dwDataLen,
    _In_                    DWORD   dwFlags
    );

使用哈希对象获得会话密钥

1
2
3
4
5
6
CryptDeriveKey(
		m_hCryptProv,
		ENCRYPT_ALGORITHM,
		m_hHash,
		KEYLENGTH,
		&m_hKey)
1
2
3
4
5
6
7
8
9
10
WINADVAPI
BOOL
WINAPI
CryptDeriveKey(
    _In_    HCRYPTPROV  hProv,
    _In_    ALG_ID      Algid,
    _In_    HCRYPTHASH  hBaseData,
    _In_    DWORD       dwFlags,
    _Out_   HCRYPTKEY   *phKey
    );

销毁哈希对象

1
2
3
4
5
6
WINADVAPI
BOOL
WINAPI
CryptDestroyHash(
    _In_    HCRYPTHASH  hHash
    );

其他对象

1
2
3
4
PBYTE	m_pbBuffer;			// 缓冲区，临时存放区
DWORD   m_dwBlockLen;		// 存放加密块长度
DWORD   m_dwBufferLen;		// 缓冲区长度
DWORD   m_dwCount;			// 成功读取或加密文件的字节数

0x03 Demo函数分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class CMyCryptOpt 
{
public:
	// 构造函数和析构函数
	CMyCryptOpt(void);
	~CMyCryptOpt(void);

	// 初始化加密函数
	BOOL InitCrypt(VOID);
	// 销毁加密函数
	VOID DestroyCrypt(VOID);

	// 对文件加密
	// 源文件，加密后文件，密码
	// 主加密函数
	BOOL MyEncryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

	// 对文件解密
	// 加密后文件，加密前文件，密码
	// 主解密函数
	BOOL MyDecryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

protected:
	// 加密过程
	BOOL CryptProcess(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

构造函数和析构函数

构造函数没啥好讲的，我由于受不了VS的恶俗警告信息，所以迫真初始化了一下变量，全部设置成了NULL。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CMyCryptOpt::CMyCryptOpt(VOID) 
{
	m_hSource = NULL;
	m_hDestination = NULL;

	m_hCryptProv = NULL;
	m_hKey = NULL;
	m_hHash = NULL;

	m_pbBuffer = NULL;
	m_dwBlockLen = NULL;
	m_dwBufferLen = NULL;
	m_dwCount = NULL;
	OutputDebugString(L"Constructing Cryptor...");
}

析构函数啥也没干，调用默认销毁。

初始化加密函数和销毁加密函数

InitCrypt函数调用CryptAcquireContext和CryptCreateHash来初始化HCRYPTPROV和HCRYPTHASH对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 获得HCRYPTPROV和HCRYPTHASH句柄
BOOL CMyCryptOpt::InitCrypt(VOID){
	// 获得HCRYPTPROV句柄
    // 不知道搞两个是干啥的
	if (!CryptAcquireContext(&m_hCryptProv, NULL, NULL, PROV_RSA_FULL, 0)) 
	{
		if (!CryptAcquireContext(&m_hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
			OutputDebugString(L"CryptAcquireContext() Error!");
			return FALSE;
		}
	}
	
	// 若成功获得PROV句柄
	// 则创建一个哈希对象
	if (!CryptCreateHash(m_hCryptProv, CALG_MD5, 0, 0, &m_hHash)) {
		OutputDebugString(L"CrytpCreateHash() Error!");
		return FALSE;
	}
	return TRUE;
}

DestroyCrypt函数调用了wincrypt的几个销毁函数，来关闭HCRYPTPROV，HCRYPTKEY，HCRYPTHASH句柄。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
VOID CMyCryptOpt::DestroyCrypt(VOID) {
	// 关闭文件指针
	if (m_hSource) {
		fclose(m_hSource);
	}
	if (m_hDestination) {
		fclose(m_hDestination);
	}

	// 释放缓冲区
	if (m_pbBuffer) {
		free(m_pbBuffer);
	}

	// 销毁Session Key
	if (m_hKey) {
		CryptDestroyKey(m_hKey);
	}

	// 销毁哈希对象
	if (m_hHash) {
		CryptDestroyHash(m_hHash);
		m_hHash = NULL;
	}

	// 释放Provider句柄
	if (m_hCryptProv) {
		CryptReleaseContext(m_hCryptProv, 0);
	}
}

加密过程函数

流程

  1. 打开要加密的源文件
  2. 创建目标文件用于写入加密数据
  3. 用输入的密码和md5哈希对象产生一个散列
  4. 通过散列获得会话密钥
  5. 计算块大小
  6. 分配临时缓冲区
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
BOOL CMyCryptOpt::CryptProcess(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 打开要加密的源文件
	m_hSource = fopen(lpSourceFile, "rb");
	if (!m_hSource)
	{
		OutputDebugString(L"open source file failed!");
		return FALSE;
	}

	// 创建目标文件用于写入数据
	m_hDestination = fopen(lpDestFile, "wb");
	if (!m_hDestination)
	{
		OutputDebugString(L"open destination file failed!");
		return FALSE;
	}

	// 用输入的密码产生一个散列
	if (!CryptHashData(
		m_hHash,
		(BYTE*)lpPassword,
		strlen(lpPassword),
		0))
	{
		OutputDebugString(L"CryptHashData() failed!");
		return FALSE;
	}

	// 通过散列生成会话密钥
	if (!CryptDeriveKey(
		m_hCryptProv,
		ENCRYPT_ALGORITHM,
		m_hHash,
		KEYLENGTH,
		&m_hKey))
	{
		OutputDebugString(L"CryptDeriveKey() failed!");
		return FALSE;
	}

	// 因为加密算法是按ENCRYPT_BLOCK_SIZE 大小的块加密的，所以被加密的
	// 数据长度必须是ENCRYPT_BLOCK_SIZE 的整数倍。下面计算一次加密的
	// 数据长度。
	m_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)
	{
		m_dwBufferLen = m_dwBlockLen + ENCRYPT_BLOCK_SIZE;
	}
	else
	{
		m_dwBufferLen = m_dwBlockLen;
	}

	// 为缓冲区分配内存
	m_pbBuffer = (BYTE*)malloc(m_dwBufferLen);
	if (!m_pbBuffer)
	{
		OutputDebugString(L"分配内存错误!");
		return FALSE;
	}
	return TRUE;
}

文件加密函数和解密函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// 对文件加密
// 源文件，加密后文件，密码
BOOL CMyCryptOpt::MyEncryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 加密过程:
    // 获得密钥；分配缓冲区
	if (!CryptProcess(lpSourceFile, lpDestFile, lpPassword)) {
		return FALSE;
	}

	// 加密源文件，并将加密后数据写入目标文件
	do {
		// 读源文件
         // 
		m_dwCount = fread(m_pbBuffer, 1, m_dwBlockLen, m_hSource);
		if (ferror(m_hSource)) {
			OutputDebugString(L"读写源文件错误！");
			return FALSE;
		}

		// 加密数据
		if (!CryptEncrypt(
			m_hKey,
			0,
			feof(m_hSource),
			0,
			m_pbBuffer,
			&m_dwCount,
			m_dwBufferLen
		)) {
			OutputDebugString(L"CryptEncrypt() Failed!");
			return FALSE;
		}

		// 将数据写入文件
		fwrite(m_pbBuffer, 1, m_dwCount, m_hDestination);
		if (ferror(m_hDestination)) {
			OutputDebugString(L"WriteFile Error!");
			return FALSE;
		}
	} while (!feof(m_hSource));
	return TRUE;
}

// 对文件解密
// 加密后文件，加密前文件，密码
BOOL CMyCryptOpt::MyDecryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 解密流程
	if (!CryptProcess(lpSourceFile, lpDestFile, lpPassword)) {
		return FALSE;
	}
		
	// 解密源文件，并将解密后数据写入目标文件
	do
	{
		// read source file
         // 读取m_dwBlockLen个字节型数据从m_hSource至m_pbBuffer中
		m_dwCount = fread(m_pbBuffer, 1, m_dwBlockLen, m_hSource);
		if (ferror(m_hSource))
		{
			OutputDebugString(L"读写源文件错误!");
			return FALSE;
		}

		// decrypt data
         // 解密
		if (!CryptDecrypt(
			m_hKey,
			0,
			feof(m_hSource),
			0,
			m_pbBuffer,
			&m_dwCount))
		{	
			OutputDebugString(L"CryptEncrypt() failed!");
			return FALSE;
		}

		// write data to file
		fwrite(m_pbBuffer, 1, m_dwCount, m_hDestination);
		if (ferror(m_hDestination))
		{
			OutputDebugString(L"write file error!");
			return FALSE;
		}
	} while (!feof(m_hSource));

	return TRUE;
}

0x04 API函数原型

从MSDN上面记录几个遇到的API。

CryptAcquireContext

初始化HCRYPTPROV句柄。

1
2
3
4
5
6
7
8
9
BOOL
WINAPI
CryptAcquireContextW(
    _Out_       HCRYPTPROV  *phProv,
    _In_opt_    LPCWSTR    szContainer,
    _In_opt_    LPCWSTR    szProvider,
    _In_        DWORD       dwProvType,
    _In_        DWORD       dwFlags
);

HCRYPTPROV* phProv

传出HCRYPTPROV对象。

结束后，释放句柄，使用CryptReleaseContext函数。

LPCWSTR szContainer

可选项。

密钥容器的名称。这是一个空字符结尾的字符串，用于为CSP标识密钥容器。

如果dwFlags被设置为CRYPT_VERIFYCONTEXT，该选项必须设置为NULL。

LPCWSTR szProvider

可选项。

标识CSP用的名称。这是一个空字符结尾的字符串。

如果传入了NULL，则调用了一个默认的Provider。

更多信息，见Cryptographic Service Provider Contexts.

For a list of available cryptographic providers, see Cryptographic Provider Names.

一个应用可以通过CryptGetProvParam函数来读取dwParam参数的PP_NAME CSP值，以获取现在使用的CSP的名称。

CSP名称应该被妥当的设置，而不是使用默认CSP。

dwProvType

明确了需要使用的CSP。

Cryptographic Provider Types

dwFlags

0xFE 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// rhsEncrypt.h
#pragma once

#include <Windows.h>
#include <wincrypt.h>
#include <cstdio>

// 自定义编码模式
#define MY_ENCODING_TYPE (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)

// 密钥长度（？这么长？）
#define KEYLENGTH 0x00800000

// 加密算法：RC4
#define ENCRYPT_ALGORITHM CALG_RC4

// 加密块大小
#define ENCRYPT_BLOCK_SIZE 8

class CMyCryptOpt 
{
public:
	// 构造函数和析构函数
	CMyCryptOpt(void);
	~CMyCryptOpt(void);

	// 初始化加密函数
	BOOL InitCrypt(VOID);
	// 销毁加密函数
	VOID DestroyCrypt(VOID);

	// 对文件加密
	// 源文件，加密后文件，密码
	BOOL MyEncryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

	// 对文件解密
	// 加密后文件，加密前文件，密码
	BOOL MyDecryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

protected:
	// 加密过程
	BOOL CryptProcess(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword);

private:
	FILE* m_hSource;
	FILE* m_hDestination;

	HCRYPTPROV m_hCryptProv;
	HCRYPTKEY  m_hKey;
	HCRYPTHASH m_hHash;

	PBYTE	m_pbBuffer;
	DWORD   m_dwBlockLen;
	DWORD   m_dwBufferLen;
	DWORD   m_dwCount;

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
// rhsEncrypt.cpp
#include "rhsEncrypt.h"

CMyCryptOpt::CMyCryptOpt(VOID) 
{
	m_hSource = NULL;
	m_hDestination = NULL;

	m_hCryptProv = NULL;
	m_hKey = NULL;
	m_hHash = NULL;

	m_pbBuffer = NULL;
	m_dwBlockLen = NULL;
	m_dwBufferLen = NULL;
	m_dwCount = NULL;
	OutputDebugString(L"Constructing Cryptor...");
}

CMyCryptOpt::~CMyCryptOpt(VOID) {
	puts("Destroying Cryptor...");
}

// 获得HCRYPTPROV和HCRYPTHASH句柄
BOOL CMyCryptOpt::InitCrypt(VOID){
	// 获得HCRYPTPROV句柄
	if (!CryptAcquireContext(&m_hCryptProv, NULL, NULL, PROV_RSA_FULL, 0)) 
	{
		if (!CryptAcquireContext(&m_hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
			OutputDebugString(L"CryptAcquireContext() Error!");
			return FALSE;
		}
	}
	
	// 若成功获得PROV句柄
	// 则创建一个会话密钥
	if (!CryptCreateHash(m_hCryptProv, CALG_MD5, 0, 0, &m_hHash)) {
		OutputDebugString(L"CrytpCreateHash() Error!");
		return FALSE;
	}
	return TRUE;
}

VOID CMyCryptOpt::DestroyCrypt(VOID) {
	// 关闭文件指针
	if (m_hSource) {
		fclose(m_hSource);
	}
	if (m_hDestination) {
		fclose(m_hDestination);
	}

	// 释放内存
	if (m_pbBuffer) {
		free(m_pbBuffer);
	}

	// 销毁Session Key
	if (m_hKey) {
		CryptDestroyKey(m_hKey);
	}

	// 销毁哈希对象
	if (m_hHash) {
		CryptDestroyHash(m_hHash);
		m_hHash = NULL;
	}

	// 释放Provider句柄
	if (m_hCryptProv) {
		CryptReleaseContext(m_hCryptProv, 0);
	}
}

// 对文件加密
// 源文件，加密后文件，密码
BOOL CMyCryptOpt::MyEncryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 加密过程
	if (!CryptProcess(lpSourceFile, lpDestFile, lpPassword)) {
		return FALSE;
	}

	// 加密源文件，并将加密后数据写入目标文件
	do {
		// 读源文件
		m_dwCount = fread(m_pbBuffer, 1, m_dwBlockLen, m_hSource);
		if (ferror(m_hSource)) {
			OutputDebugString(L"读写源文件错误！");
			return FALSE;
		}

		// 加密数据
		if (!CryptEncrypt(
			m_hKey,
			0,
			feof(m_hSource),
			0,
			m_pbBuffer,
			&m_dwCount,
			m_dwBufferLen
		)) {
			OutputDebugString(L"CryptEncrypt() Failed!");
			return FALSE;
		}

		// 将数据写入文件
		fwrite(m_pbBuffer, 1, m_dwCount, m_hDestination);
		if (ferror(m_hDestination)) {
			OutputDebugString(L"WriteFile Error!");
			return FALSE;
		}
	} while (!feof(m_hSource));
	return TRUE;
}

// 对文件解密
// 加密后文件，加密前文件，密码
BOOL CMyCryptOpt::MyDecryptFile(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 解密流程
	if (!CryptProcess(lpSourceFile, lpDestFile, lpPassword)) {
		return FALSE;
	}
		
	// 解密源文件，并将解密后数据写入目标文件
	do
	{

		// read source file
		m_dwCount = fread(m_pbBuffer, 1, m_dwBlockLen, m_hSource);
		if (ferror(m_hSource))
		{
			OutputDebugString(L"读写源文件错误!");
			return FALSE;
		}

		// decrypt data
		if (!CryptDecrypt(
			m_hKey,
			0,
			feof(m_hSource),
			0,
			m_pbBuffer,
			&m_dwCount))
		{
			OutputDebugString(L"CryptEncrypt() failed!");
			return FALSE;
		}

		// write data to file
		fwrite(m_pbBuffer, 1, m_dwCount, m_hDestination);
		if (ferror(m_hDestination))
		{
			OutputDebugString(L"write file error!");
			return FALSE;
		}
	}while (!feof(m_hSource));

	return TRUE;
}

// 加密过程
BOOL CMyCryptOpt::CryptProcess(LPSTR lpSourceFile, LPSTR lpDestFile, LPSTR lpPassword) {
	// 打开要加密的源文件

	m_hSource = fopen(lpSourceFile, "rb");
	if (!m_hSource)
	{
		OutputDebugString(L"open source file failed!");
		return FALSE;
	}



	// 打开加密后产生的目标文件
	m_hDestination = fopen(lpDestFile, "wb");
	if (!m_hDestination)
	{
		OutputDebugString(L"open destination file failed!");
		return FALSE;
	}

	// 用输入的密码产生一个散列
	if (!CryptHashData(
		m_hHash,
		(BYTE*)lpPassword,
		strlen(lpPassword),
		0))
	{
		OutputDebugString(L"CryptHashData() failed!");
		return FALSE;
	}

	// 通过散列生成会话密钥
	if (!CryptDeriveKey(
		m_hCryptProv,
		ENCRYPT_ALGORITHM,
		m_hHash,
		KEYLENGTH,
		&m_hKey))
	{
		OutputDebugString(L"CryptDeriveKey() failed!");
		return FALSE;
	}

	// 因为加密算法是按ENCRYPT_BLOCK_SIZE 大小的块加密的，所以被加密的
	// 数据长度必须是ENCRYPT_BLOCK_SIZE 的整数倍。下面计算一次加密的
	// 数据长度。
	m_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)
	{
		m_dwBufferLen = m_dwBlockLen + ENCRYPT_BLOCK_SIZE;
	}
	else
	{
		m_dwBufferLen = m_dwBlockLen;
	}

	// 为缓冲区分配内存
	m_pbBuffer = (BYTE*)malloc(m_dwBufferLen);
	if (!m_pbBuffer)
	{
		OutputDebugString(L"分配内存错误!");
		return FALSE;
	}
	return TRUE;
}

0xFF 参考

使用WinCrypt进行简单的对称加密实例_lixiaomin_235的博客-CSDN博客

腾讯反病毒实验室 (qq.com)

Structure of HCRYPTKEY Data (codeguru.com)

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

A junior undergraduate
studying in the college of cyber science and engineering
in Sichuan University
in Sichuan , China.
Pronouns:He/him.
A core member of 0x401 CTF team
majorly focus on Reverse Engineering chanllenges.