windows黑客编程技术之加密技术：windows自带的加密库

已于 2022-08-30 19:29:01 修改
阅读量1.6k 收藏 7
点赞数 1
分类专栏： windows编程 windows黑客编程技术详解 文章标签： windows c++ 哈希算法
于 2022-08-25 20:31:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44891742/article/details/126014133
版权

经典的加解密算法有AES，DES，RSA等，通过加密我们可以保护我们的数据。

windows自带加密库

windows提供了一组CryptoAPI来对用户的敏感私钥数据提供保护，并以灵活的方式对数据进行加密或签名。接下来介绍HASH值计算、AES加解密、RSA加解密。
CSP：加密服务提供程序

HASH值的计算

Hash算法是一种单向加密算法，HASH就是把任意长度的输入通过HASH算法变换成固定长度的输出，该值就是HASH值。HASH值的空间远小于输入值的空间，不同的输入可能得到相同的输出，所以无法利用HASH值来确定唯一的输入值。基于这种特性，HASH值一般用来执行数据完整性校验。如MD5,SHA等。

实现过程

//用于获取指定CSP内特定密钥容器的句柄。
BOOL CryptAcquireContext(
HCRYPTPROV *phProv,//指向csp句柄的指针，通过CryptReleaseContext释放。
LPCSTR szContainer,//密钥容器名称,一般设置NULL
LPCSTR szProvider,//包含要使用CSP名称的空终止字符串，一般设置NULL。
DWORD dwProvType,//指定要获取提供程序的类型，如PROV_RSA_AES支持RSA签名算法，AES加密算法以及HASH算法。
DWORD dwFlags);//标志值，一般设置0。

//创建一个空HASH对象
BOOL CryptCreateHash(
HCRYPTPROV hProv,//调用CryptAcquireContext创建的CSP句柄
ALG_ID Algid,//标识要使用的HASH算法的ALG_ID值。
HCRYPTKEY  hKey,//对于非键控算法，设置为0.
DWORD dwFlags,//通常为0.
HCRYPTHASH *phHash);//HASH对象句柄。

//将数据添加到HASH对象，并进行HASH计算。
BOOL WINAPI CryptHashData(
HCRYPTHASH hHash, //HASH对象句柄
BYTE* pbData,//指向要添加到HASH对象数据缓冲区的指针
DWORD dwDataLen, //要添加到HASH对象缓冲区的指针
DWORD dwFlags//通常为0
);

//从HASH对象获取指定参数值
BOOL CRYPTFUNC CryptGethashParam(
HCRYPTHASH hHash,//HASH对象句柄
DWORD dwParam, //查询类型 HP_ALGID,HP_HASHSIZE,HP_HASHVAL。
BYTE *pbData, //指向接受指定值的数据缓冲区的指针。
DWORD *pdwDataLen, //指向指定的pdData缓冲区大小的DWORD值得指针，
DWORD dwFlags//0
);

//释放HASH对象句柄
BOOL CRYPTFUNC CryptDestroyHash(
HCRYPTHASH hHash
);

//释放CSP句柄
BOOL WINAPI CryptReleaseContext(
HCRYPTPROV hProv,
DWORD dwFlag
);

1 任何程序在使用CryptoAPI函数来执行数据计算或是加/解密之前，都需要调用CryptAcquireContext来获取CSP句柄。因为这里是计算数据HASH值，所以将提供程序类型设置为PROV_RSA_AES，该类型支持常用HASH算法。
2 调用CryptCreateHash在CSP中创建一个空的HASH对象并获取句柄，并可以指定HASH对象使用的HASH算法，如CALG_MD5表示MD5 HASH算法。
3 调用CryptGetHashParam从HASH对象获取指定参数，可以获取的参数有三种：
HP_ALGID：HASH算法
HP_HASHSIZE：HASH值的数据长度
HP_HASHVAL：HASH值
因为HASH算法不同，HASH值大小不固定，所以在获取HASH值之前，需要先获取HASH值长度，并申请足够的缓冲区存放HASH值。

编码实现

/*
Function：HASH值计算
pData：需要计算的内容
dwDataLength：内容长度
algHashType：HASH算法类型 如CALG_MD5，CALG_SHA1，CALG_SHA256等
ppHashData：存放计算的的HASH值
pdwHashDataLength：计算的HASH值长度
*/
BOOL CalculateHash(BYTE *pData, DWORD dwDataLength, ALG_ID algHashType, BYTE **ppHashData, DWORD *pdwHashDataLength)
{
	HCRYPTPROV hCryptProv = NULL;//CSP句柄
	HCRYPTHASH hCryptHash = NULL;//HASH对象句柄
	BYTE *pHashData = NULL;
	DWORD dwHashDataLength = 0;
	DWORD dwTemp = 0;
	BOOL bRet = FALSE;


	do
	{
		// 获得指定CSP的密钥容器的句柄		
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 创建一个HASH对象, 指定HASH算法		
		bRet = ::CryptCreateHash(hCryptProv, algHashType, NULL, NULL, &hCryptHash);
		if (FALSE == bRet)
		{
			ShowError("CryptCreateHash");
			break;
		}

		// 计算HASH数据
		bRet = ::CryptHashData(hCryptHash, pData, dwDataLength, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptHashData");
			break;
		}
		
		
		
		// 获取HASH结果的大小
		dwTemp = sizeof(dwHashDataLength);
		bRet = ::CryptGetHashParam(hCryptHash, HP_HASHSIZE, (BYTE *)(&dwHashDataLength), &dwTemp, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptGetHashParam");
			break;
		}

		// 申请内存
		pHashData = new BYTE[dwHashDataLength];
		if (NULL == pHashData)
		{
			bRet = FALSE;
			ShowError("new");
			break;
		}
		::RtlZeroMemory(pHashData, dwHashDataLength);

		// 获取HASH结果数据
		bRet = ::CryptGetHashParam(hCryptHash, HP_HASHVAL, pHashData, &dwHashDataLength, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptGetHashParam");
			break;
		}

		// 返回数据
		*ppHashData = pHashData;
		*pdwHashDataLength = dwHashDataLength;

	} while (FALSE);

	// 释放关闭
	if (FALSE == bRet)
	{
		if (pHashData)
		{
			delete[]pHashData;
			pHashData = NULL;
		}
	}
	if (hCryptHash)
	{
		::CryptDestroyHash(hCryptHash);
	}
	if (hCryptProv)
	{	
		::CryptReleaseContext(hCryptProv, 0);
	}

	return bRet;
}

测试结果
在这里插入图片描述

AES加解密

AES是最常见的对称加密算法，所谓对称加密算法就是加密和解密使用相同密钥的加密算法。AES为分组密码，就是把明文分成一组一组的，每组长度相同，每次加密一组数据，直到加密完整个明文。AES对称加密算法的优势在于算法公开，计算量小，加密效率高。
在AES标准规范中，分组长度只能是128位（16个字节）。密钥长度可以是：
128：CALG_AES_128（16字节）
192：CALG_AES_192（24字节）
256：CALG_AES_256（32字节）

实现过程

//CryptDeriveKey：生成从基础数据值（可以是密码或者别的）派生出的加密会话密钥。
BOOL CRYPTFUNC CryptDeriveKey(
HCRYPTPROV hProv,//CSP句柄
ALG_ID Algid,//标识要使用的HASH算法的ALG_ID值
HCRYPTHASH hBaseData,//HASH对象句柄
DWORD dwFlags,//指定生成密钥的类型
HCRYPTKEY* phKey);//加密会话密钥

//对数据进行加密
BOOL CRYPTFUNC CryptEncrypt
(HCRYPTKEY hKey,//加密会话密钥
HCRYPTHASH hHash,//HASH对象句柄
BOOL Final,//指定它是否是加密系列中的最后一部分
DWORD dwFlags, //0
BYTE* pbData,//指向要加密的明文缓冲区的指针，该缓冲区文本会被生成的密文所覆盖。
DWORD* pdwDataLen,//pbData缓冲区中明文长度
DWORD dwBufLen//指定输入pbData缓冲区的总大小
);

BOOL CryptDecrypt(
HCRYPTKEY  hKey,//加密会话密钥
HCRYPTHASH hHash,//HASH对象句柄
BOOL       Final,//指定它是否是加密系列中的最后一部分
DWORD      dwFlags,//0
BYTE       *pbData,//指向要解密的明文缓冲区的指针，该缓冲区文本会被生成的明文所覆盖。
DWORD      *pdwDataLen//pbData缓冲区的总大小
);

//释放密钥句柄
BOOL CRYPTFUNC CryptDestroyKey(HCRYPTKEY hKey);

1 任何程序在使用CryptoAPI函数来执行数据计算或是加/解密之前，都需要调用CryptAcquireContext来获取CSP句柄.由于这里使用的是AES对称加密算法，所以将提供程序类型设置为PROV_RSA_AES，该类型支持AES算法。
2 下面并不直接使用明文密码作为AES的加密密码，而是把明文密码的MD5值作为密码，再调用CryptDeriveKey函数来派生出AES的加密密钥。先CryptCreateHash创建HASH对象，然后CryptHashData对传入的密码进行MD5值计算，再CryptDeriveKey通过MD5来派生密钥，CALG_AES_128表示用于128位AES加密。
3 派生完密钥之后，可以调用CryptEncrypt来根据派生密钥中指定的加密算法进行加密。

AES加密编码实现

/*
Function：AES加密
pPassword:加密密码
dwPasswordLength：密码长度
pData：指向要加密的明文缓冲区的指针
dwDataLength：pData缓冲区中明文的长度 
dwBufferLength：pData缓冲区总大小：大于明文长度，因为加密完成后密文也会写道这个缓冲区。
*/ 
BOOL AesEncrypt(BYTE *pPassword, DWORD dwPasswordLength, BYTE *pData, DWORD &dwDataLength, DWORD dwBufferLength)
{
	BOOL bRet = TRUE;
	HCRYPTPROV hCryptProv = NULL;//CSP句柄
	HCRYPTHASH hCryptHash = NULL;//HASH对象句柄
	HCRYPTKEY hCryptKey = NULL;//加密密钥句柄

	do
	{
		// 获取CSP句柄
		//CryptAcquireContext：用于获取指定CSP内特定密钥容器的句柄。
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 创建HASH对象
		bRet = ::CryptCreateHash(hCryptProv, CALG_MD5, NULL, 0, &hCryptHash);
		if (FALSE == bRet)
		{
			ShowError("CryptCreateHash");
			break;
		}

		// 对密钥进行HASH计算
		bRet = ::CryptHashData(hCryptHash, pPassword, dwPasswordLength, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptHashData");
			break;
		}

		// 使用HASH来生成密钥
		bRet = ::CryptDeriveKey(hCryptProv, CALG_AES_128, hCryptHash, CRYPT_EXPORTABLE, &hCryptKey);
		if (FALSE == bRet)
		{
			ShowError("CryptDeriveKey");
			break;
		}

		// 加密数据
		//CryptEncrypt：由CSP模块保存的密钥指定的加密算法来加密数据。
		//TRUE：表示该加密是AES加密数据中最后一组，这样系统会自动按照分组长度对数据进行填充并计算。
		bRet = ::CryptEncrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength, dwBufferLength);
		if (FALSE == bRet)
		{
			ShowError("CryptEncrypt");
			break;
		}

	} while (FALSE);

	// 关闭释放
	if (hCryptKey)
	{
		::CryptDestroyKey(hCryptKey);//释放密钥句柄
	}
	if (hCryptHash)
	{
		::CryptDestroyHash(hCryptHash);//释放HASH对象句柄
	}
	if (hCryptProv)
	{
		::CryptReleaseContext(hCryptProv, 0);//释放CSP句柄
	}

	return bRet;
}

由于AES是对称加密，所以加密解密都是同一个密码。为了获取相同的解密密钥，需要根据明文密码来计算出派生密钥。过程与上面相同。

AES解码编码实现

/*
Function：AES解密
pPassword:解密密码
dwPasswordLength：密码长度
pData：指向要解密的明文缓冲区的指针
dwDataLength：pData缓冲区中明文的长度 
dwBufferLength：pData缓冲区总大小：大于明文长度，因为加密完成后密文也会写道这个缓冲区。
*/ 
BOOL AesDecrypt(BYTE *pPassword, DWORD dwPasswordLength, BYTE *pData, DWORD &dwDataLength, DWORD dwBufferLength)
{
	BOOL bRet = TRUE;
	HCRYPTPROV hCryptProv = NULL;
	HCRYPTHASH hCryptHash = NULL;
	HCRYPTKEY hCryptKey = NULL;

	do
	{
		// 获取CSP句柄
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 创建HASH对象
		bRet = ::CryptCreateHash(hCryptProv, CALG_MD5, NULL, 0, &hCryptHash);
		if (FALSE == bRet)
		{
			ShowError("CryptCreateHash");
			break;
		}

		// 对密钥进行HASH计算
		bRet = ::CryptHashData(hCryptHash, pPassword, dwPasswordLength, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptHashData");
			break;
		}

		// 使用HASH来生成密钥
		bRet = ::CryptDeriveKey(hCryptProv, CALG_AES_128, hCryptHash, CRYPT_EXPORTABLE, &hCryptKey);
		if (FALSE == bRet)
		{
			ShowError("CryptDeriveKey");
			break;
		}

		// 解密数据
		bRet = ::CryptDecrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength);
		if (FALSE == bRet)
		{
			ShowError("CryptDecrypt");
			break;
		}

	} while (FALSE);

	// 关闭释放
	if (hCryptKey)
	{
		::CryptDestroyKey(hCryptKey);
	}
	if (hCryptHash)
	{
		::CryptDestroyHash(hCryptHash);
	}
	if (hCryptProv)
	{
		::CryptReleaseContext(hCryptProv, 0);
	}

	return bRet;
}

测试结果

![在这里插入图片描述](https://img-blog.csdnimg.cn/fc168fffb1744789afb6e707a223ec70.pn

RSA加解密

RSA是一种非对称加密算法，加密密钥和解密密钥不相同。RSA算法的安全性非常高，极大整数进行因数分解的难度决定了RSA算法的可靠性。但是由于RSA进行的都是大数运算，所以RSA速度很慢，是同安全级别的对称密码算法的1/1000左右，一般RSA用于少量数据加密。

实现过程

//随机生成加密会话密钥或公钥/私钥对，密钥或密钥对的句柄在phKey返回。
BOOL CRYPTFUNC CryptGenKey( 
HCRYPTPROV  hProv,//CSP句柄
ALG_ID Algid,//标识要使用的HASH算法的ALG_ID值
DWORD dwFlags,//指定生成的密钥类型
HCRYPTKEY* phKey//密钥句柄
);

//以安全的方式从加密服务提供程序中导出加密密钥或密钥对。
BOOL CRYPTFUNC CryptExportKey(
HCRYPTKEY hKey,//指向要导出的密钥句柄
HCRYPTKEY hExpKey,//指向目标用户的密钥句柄，通常为NULL
DWORD dwBlobType,//指定要在pdData中导出键BLOB的类型。PUBLICKEYBLOB表示导出公钥，PRIVATEKEYBLOB表示导出私钥。
DWORD dwFlags,//0
BYTE* pbData,//指向接收关键BLOB数据的缓冲区的指针
DWORD* pdwbDataLen//pddate缓冲区大小
);

//将加密密钥从密钥 BLOB传输到加密服务提供程序(CSP)
BOOL CryptImportKey(
HCRYPTPROV hProv,//CSP句柄
const BYTE *pbData,//指定一个BYTE数组，此密钥BOLO由CryptExportKey创建
DWORD dwDataLen,//包含关键BLOB长度
HCRYPTKEY  hPubKey,//解密存储在pdData中的加密密钥句柄
DWORD  dwFlags,//目前仅在将PRIVATEKEYBLOB形式的公钥/私钥对导入 CSP 时使用
HCRYPTKEY  *phKey//指向接受导入键句柄的指针
);

通常情况下，公钥用来加密数据，私钥用来解密数据，因此在数据加解/密前，需要先产生公钥和私钥密钥对。公钥和私钥成对，使用公钥加密的数据只能用唯一的私钥来解密。

1 首先，任何程序在使用CryptoAPI函数来执行数据计算或是加/解密之前，都需要调用CryptAcquireContext来获取CSP句柄.由于这里使用的是RSA非对称加密算法，所以将提供程序类型设置为PROV_RSA_FULL，该类型支持RSA算法。
2 调用CryptGenKey函数随机生成AT_KEYEXCHANGE交换密钥对，并设置生成的密钥对类型为CRYPT_EXPORTABLE，它是可导出的，可以使用CryptExportKey导出密钥。此时RSA密钥对已经生成。

编码实现

/*
Function：生成公钥和私钥
ppPublicKey：公钥
pdwPublicKeyLength：公钥长度
ppPrivateKey：私钥
pdwPrivateKeyLength：私钥长度
*/ 
BOOL GenerateKey(BYTE **ppPublicKey, DWORD *pdwPublicKeyLength, BYTE **ppPrivateKey, DWORD *pdwPrivateKeyLength)
{
	BOOL bRet = TRUE;
	HCRYPTPROV hCryptProv = NULL;//CSP句柄
	HCRYPTKEY hCryptKey = NULL;//密钥句柄
	BYTE *pPublicKey = NULL;//公钥内容
	DWORD dwPublicKeyLength = 0;//公钥长度
	BYTE *pPrivateKey = NULL;//私钥内容
	DWORD dwPrivateKeyLength = 0;//私钥长度

	do
	{
		// 获取CSP句柄
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 生成公私密钥对
		bRet = ::CryptGenKey(hCryptProv, AT_KEYEXCHANGE, CRYPT_EXPORTABLE, &hCryptKey);
		if (FALSE == bRet)
		{
			ShowError("CryptGenKey");
			break;
		}

		// 获取公钥密钥的长度和内容
		bRet = ::CryptExportKey(hCryptKey, NULL, PUBLICKEYBLOB, 0, NULL, &dwPublicKeyLength);
		if (FALSE == bRet)
		{
			ShowError("CryptExportKey");
			break;
		}
		pPublicKey = new BYTE[dwPublicKeyLength];
		::RtlZeroMemory(pPublicKey, dwPublicKeyLength);
		bRet = ::CryptExportKey(hCryptKey, NULL, PUBLICKEYBLOB, 0, pPublicKey, &dwPublicKeyLength);
		if (FALSE == bRet)
		{
			ShowError("CryptExportKey");
			break;
		}

		// 获取私钥密钥的长度和内容
		bRet = ::CryptExportKey(hCryptKey, NULL, PRIVATEKEYBLOB, 0, NULL, &dwPrivateKeyLength);
		if (FALSE == bRet)
		{
			ShowError("CryptExportKey");
			break;
		}
		pPrivateKey = new BYTE[dwPrivateKeyLength];
		::RtlZeroMemory(pPrivateKey, dwPrivateKeyLength);
		bRet = ::CryptExportKey(hCryptKey, NULL, PRIVATEKEYBLOB, 0, pPrivateKey, &dwPrivateKeyLength);
		if (FALSE == bRet)
		{
			ShowError("CryptExportKey");
			break;
		}

		// 返回数据
		*ppPublicKey = pPublicKey;
		*pdwPublicKeyLength = dwPublicKeyLength;
		*ppPrivateKey = pPrivateKey;
		*pdwPrivateKeyLength = dwPrivateKeyLength;

	} while (FALSE);

	// 释放关闭
	if (hCryptKey)
	{
		::CryptDestroyKey(hCryptKey);
	}
	if (hCryptProv)
	{
		::CryptReleaseContext(hCryptProv, 0);
	}

	return bRet;
}


/*
Function:公钥加密数据
*/ 
BOOL RsaEncrypt(BYTE *pPublicKey, DWORD dwPublicKeyLength, BYTE *pData, DWORD &dwDataLength, DWORD dwBufferLength)
{
	BOOL bRet = TRUE;
	HCRYPTPROV hCryptProv = NULL;
	HCRYPTKEY hCryptKey = NULL;

	do
	{
		// 获取CSP句柄
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 导入公钥
		bRet = ::CryptImportKey(hCryptProv, pPublicKey, dwPublicKeyLength, NULL, 0, &hCryptKey);
		if (FALSE == bRet)
		{
			ShowError("CryptImportKey");
			break;
		}

		// 加密数据
		bRet = ::CryptEncrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength, dwBufferLength);
		if (FALSE == bRet)
		{
			ShowError("CryptImportKey");
			break;
		}

	} while (FALSE);

	// 释放并关闭
	if (hCryptKey)
	{
		::CryptDestroyKey(hCryptKey);
	}
	if (hCryptProv)
	{
		::CryptReleaseContext(hCryptProv, 0);
	}

	return bRet;
}

/*
Function:私钥解密数据
*/ 
BOOL RsaDecrypt(BYTE *pPrivateKey, DWORD dwProvateKeyLength, BYTE *pData, DWORD &dwDataLength)
{
	BOOL bRet = TRUE;
	HCRYPTPROV hCryptProv = NULL;
	HCRYPTKEY hCryptKey = NULL;

	do
	{
		// 获取CSP句柄
		bRet = ::CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0);
		if (FALSE == bRet)
		{
			ShowError("CryptAcquireContext");
			break;
		}

		// 导入私钥
		bRet = ::CryptImportKey(hCryptProv, pPrivateKey, dwProvateKeyLength, NULL, 0, &hCryptKey);
		if (FALSE == bRet)
		{
			ShowError("CryptImportKey");
			break;
		}

		// 解密数据
		bRet = ::CryptDecrypt(hCryptKey, NULL, TRUE, 0, pData, &dwDataLength);
		if (FALSE == bRet)
		{
			ShowError("CryptDecrypt");
			break;
		}

	} while (FALSE);

	// 释放并关闭
	if (hCryptKey)
	{
		::CryptDestroyKey(hCryptKey);
	}
	if (hCryptProv)
	{
		::CryptReleaseContext(hCryptProv, 0);
	}

	return bRet;
}

测试结果

在这里插入图片描述

shalunZhou
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微软官方提供的加密库相关学习
ATree的博客
08-14 879
最近在看一个sample，很长时间没有看伪代码，突然感觉有些生疏了，但是这个样本用到了RSA-2048位密钥长度的算法，一下子就又想研究研究它了，之前没想过别人是如何知道这个sample是使用了什么算法，可能是通过比我用的高级的插件吧，我用PEID的附带插件扫描识别算法，但是具体多少位的加密密钥就识别不出来，所以为了搞清楚一些之前没有很明白的API，决定仔细查询下微软加密库相关的API。 该AP...
轻松看懂的加解密系列(1) —— Windows CryptoAPI 实例介绍
weixin_41077112的博客
09-08 1681
Windows CryptoAPI 实例介绍
关于windows密码加密算法的说明
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
09-13 5189
一、背景 本文的主要介绍Windows创建和存储密码哈希（Hash）的方式，以及这些哈希的破解方式。 我们使用的Windows的计算机使用两种方法对用户密码创建哈希，这两种方法在本质上有着不同的安全意义。这两种方法分别是LAN Manager (LM)以及NT LAN Manager第二版(NTLMv2)。哈希是一种加密算法，通过对加密对象字符串计算得出一个字符串，这种加密需要获取任意大小的字符串数据，并用算法对其进行加密，然后返回一个固定大小的字符串。 其中，早期的LAN Manager哈希是Window
windows黑客编程技术之隐藏技术（进程伪装，傀儡进程，进程隐藏）
weixin_44891742的博客
07-26 6211
windows黑客编程技术之隐藏技术（进程伪装，傀儡进程，进程隐藏）
微软同态加密库SEAL算子功能汇总
lin_12138的博客
06-16 2207
微软同态加密库SEAL算子功能汇总 近来在学习微软的同态加密库SEAL，为了方便学习，特将SEAL库支持的算子功能做个总结。 以SEAL库的src/seal/evaluate.h文件为参考 算子 功能描述 表达式 negate_inplace 对密文求反 c1=-（c1） negate 对密文求反，求反的结果保持为新的密文 c2=-（c1） add_inplace 两个密文相加，和保存在第一个密文里 c1=c1+c2 add(const Ciphertext &encry
windows黑客编程系列（一）：运行单一实例
至臻求学，胸怀云月
03-09 5082
windows黑客编程系列一 由于课题需要，不得不转行windows PE文件的研究，需要接触windows黑客编程。 新建windows编程系列笔记，待课题结束，回归ELF。 使用codeblocks新建一个win32 GUI程序 打开codeblocks -> create a new project -> 选择win32 GUI project -> Go -> 选择...
远程桌面(你的桌面我作主)附源码
03-16
3. **远程桌面客户端**：要连接到远程计算机，你需要一个远程桌面客户端，如Windows自带的“mstsc.exe”或者第三方客户端如Chrome Remote Desktop、TeamViewer等。这些客户端允许输入目标计算机的IP地址或主机名以及...
iOS Hackers Handbook
01-14
这部分内容将引导读者深入了解iOS操作系统的核心安全机制，如权限管理系统（如Gatekeeper）、加密技术（如Data Protection API）以及代码签名等。通过掌握这些基础知识，可以为后续更深层次的技术讨论奠定坚实基础。...
Windows自带的加密算法Crypto实现MD5, AES256以及RSA算法
輚至消亡
10-01 3146
密码学我了解的很少，但是在逆向中这却是非常重要的基础。这个Crypto函数库是windows自带的，我实现了散列算法MD5[128位], 对称加密算法AES[256位]以及RSA算法。散列函数实现改几个参数就能成SHA算法了。 1. MD5 // 单向散列函数 BOOL OneWayHash(PBYTE pData, DWORD dwSize, ALG_ID cType) { HCRYPTPROV hCryptProv = NULL; HCRYPTHASH hCryptHash = NULL;
Windows黑客编程第二章
逆向学习
06-10 821
文章目录使用互斥体创建单一实例DLL延迟加载与资源的释放DLL延迟加载导入资源资源释放 转载自甘迪文著的《Windows黑客编程》。 使用互斥体创建单一实例 // 判断是否重复运行 BOOL IsAlreadyRun() { HANDLE hMutex = NULL; hMutex = ::CreateMutex(NULL, FALSE, "TEST"); if (hMutex) { ...
PB MD5利用系统winapi实现(绝对好用)
05-27
详细说明:http://blog.csdn.net/xiajinxian/article/details/46627527 适用环境:powerbuilder 10.0以后的版本 window server2003以后的测试可用 PB也可以调用系统自带的DLL 实现MD5 其中md5file对大附件的处理速度也比第三方组件快
windows黑客编程技术详解之启动技术
weixin_44891742的博客
06-21 1657
windows黑客编程之启动技术
Windows MFC工程起步
萍水间人的小天地
06-09 205
先填坑 VS2019安装MFC库，折腾可半天，看这篇文章 MFC 还有这个 然后就成功了 从三个实验说起 0x01 资源释放 病毒木马大多使用资源释放技术，它可以使程序变得更为简洁，如果程序额外需要加载一些DLL文件，文本文件，图片文件，或者其他的音/频文件灯，可以把它们作为资源插入到程序里，等到程序运行的时候，再把他们释放到本地上，这样...
winAPI做hash加密
wangxijie的专栏
09-04 962
#include #include using namespace std;#include #include #include #include #include #include #define BOLCKSIZE 184320DWORD ComputeHash(CONST BYTE *pbData, DWORD dwDataLen, ALG_ID al
[网络安全自学篇] 九十四.《Windows黑客编程技术详解》之提权技术（令牌权限提升和Bypass UAC）
最新发布
dzqxwzoe的博客
11-14 188
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。这篇文章将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充相关知识点。第六篇文章主要介绍木马病毒提权技术，包括进程访问令牌权限提升和Bypass UAC，希望对您有所帮助。如果把权限看作是门禁卡，那么计算机便是一栋拥有许多门禁的大楼，要想进入一个房间或办公室，则需要拥有对应房间的门禁卡。
sha512哈希算法php,利用Crypto API实现Hash算法（补充SHA256、SHA512）
weixin_32645721的博客
03-27 714
最近有需要计算SHA256的需求，于是在原有的基础上做了修改，唯一需要注意的地方就是在调用CryptAcquireContext需要修改参数如下：CryptAcquireContext(&hCryptProv, NULL, NULL,PROV_RSA_AES, CRYPT_VERIFYCONTEXT)更新之后的效果图：------------------------------------...
c++实现AES加密算法
林庆丰的博客
10-01 947
c++实现AES加密算法 #include "stdafx.h" #include <Windows.h> void ShowError(char *pszText) { char szErr[MAX_PATH] = { 0 }; ::wsprintf(szErr, "%s Error[0x%x]\n", pszText, ::GetLastError()); #ifdef _DEBUG ::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICO
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值