通过windows cng api 实现rsa非对称加密

已于 2023-12-23 16:46:41 修改
阅读量518 收藏 9
点赞数 7
分类专栏： windows inners 文章标签： windows rsa 非对称加密
于 2023-12-23 14:22:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pureman_mega/article/details/135167839
版权

参考：

1,使用 CNG 加密数据 - Win32 apps | Microsoft Learn

2,不记得了

  （下文通过cng api演示rsa加密，不做原理性介绍）   

      相对于aes等对称加密算法，rsa加密算法不可逆性更强。非对称加密在通常情况下，使用公钥对数据进行加密之后，如果没有私钥，基本是不可能实现解密的。在一些勒索程序中，非对称加密会经常出现；这里算是填个坑吧。

     下面代码实现：

      1，rsa加密

      2，公钥/私钥导出

#define RsaKeyLen 2048

HRESULT bthr(BOOL b)
{
    return b ? S_OK : HRESULT_FROM_WIN32(GetLastError());
}


//确实不需要直接从 BCryptExportKey 或 NCryptExportKey 进行 base64 编码输出，但需要执行额外的步骤 :
//
//使用 BCryptExportKey(或 NCryptExportKey) BCRYPT_RSAFULLPRIVATE_BLOB(但不是 BCRYPT_RSAPRIVATE_BLOB)或 BCRYPT_RSAPUBLIC_BLOB
//对生成的 BCRYPT_RSAKEY_BLOB 进行编码 CNG_RSA_PRIVATE_KEY_BLOB 或 CNG_RSA_PUBLIC_KEY_BLOB 并放入 CRYPT_PRIVATE_KEY_INFO
//使用 PKCS_PRIVATE_KEY_INFO 对 CRYPT_PRIVATE_KEY_INFO 进行编码 >
//调用CryptBinaryToStringA


HRESULT ExportToPem(_In_ BCRYPT_KEY_HANDLE hKey, BOOL bPrivate, _Out_ PSTR* ppsz, _Out_ PULONG pcch)
{
    HRESULT hr;
    CRYPT_PRIVATE_KEY_INFO PrivateKeyInfo = { 0, {const_cast<PSTR>(szOID_RSA_RSA)} };
    CERT_PUBLIC_KEY_INFO   PublicKeyInfo = { {const_cast<PSTR>(szOID_RSA_RSA)} };
  
    ULONG cbKey = 0;
    PUCHAR pbKey = 0;//really PBCRYPT_RSAKEY_BLOB

    PCWSTR pszBlobType;
    PCSTR lpszStructType;

    if (bPrivate)
    {
        pszBlobType = BCRYPT_RSAFULLPRIVATE_BLOB;
        lpszStructType = CNG_RSA_PRIVATE_KEY_BLOB;
    }
    else
    {
        pszBlobType = BCRYPT_RSAPUBLIC_BLOB;
        lpszStructType = CNG_RSA_PUBLIC_KEY_BLOB;
    }

    while (0 <= (hr = BCryptExportKey(hKey, 0, pszBlobType, pbKey, cbKey, &cbKey, 0)))
    {
        if (pbKey)
        {
            if (bPrivate)
            {
                if (0 <= (hr = bthr(CryptEncodeObjectEx(
                    X509_ASN_ENCODING,
                    lpszStructType,
                    pbKey, 
                    CRYPT_ENCODE_ALLOC_FLAG, 
                    0,
                    &PrivateKeyInfo.PrivateKey.pbData,
                    &PrivateKeyInfo.PrivateKey.cbData))))
                {
                    hr = bthr(CryptEncodeObjectEx(
                        X509_ASN_ENCODING, 
                        PKCS_PRIVATE_KEY_INFO,
                        &PrivateKeyInfo, 
                        CRYPT_ENCODE_ALLOC_FLAG,
                        0,
                        &pbKey, 
                        &cbKey));

                    LocalFree(PrivateKeyInfo.PrivateKey.pbData);
                }
            }
            else
            {
                //public key
                if (0 <= (hr = bthr(CryptEncodeObjectEx(
                    X509_ASN_ENCODING,
                    lpszStructType, 
                    pbKey, 
                    CRYPT_ENCODE_ALLOC_FLAG, 
                    0,
                    &PublicKeyInfo.PublicKey.pbData,
                    &PublicKeyInfo.PublicKey.cbData))))
                {
                    hr = bthr(CryptEncodeObjectEx(
                        X509_ASN_ENCODING,
                        X509_PUBLIC_KEY_INFO,
                        &PublicKeyInfo, 
                        CRYPT_ENCODE_ALLOC_FLAG, 
                        0,
                        &pbKey, 
                        &cbKey));

                    LocalFree(PublicKeyInfo.PublicKey.pbData);
                }
            }

            if (0 <= hr)
            {
                PSTR psz = 0;
                ULONG cch = 0;
                while (0 <= (hr = bthr(CryptBinaryToStringA(
                    pbKey,
                    cbKey,
                    CRYPT_STRING_BASE64HEADER, //CRYPT_STRING_BASE64HEADER without the "---------BEGIN CERTIFICATE---------"
                    psz,
                    &cch))))
                {
                    if (psz)
                    {
                        *ppsz = psz, * pcch = cch;
                        break;
                    }

                    if (!(psz = (PSTR)LocalAlloc(0, cch)))
                    {
                        hr = HRESULT_FROM_WIN32(GetLastError());
                        break;
                    }
                }

                LocalFree(pbKey);
            }

            break;
        }

        pbKey = (PUCHAR)malloc(cbKey);
    }

    return hr;
}

BOOL DecryptAnd(BCRYPT_KEY_HANDLE hKey, PUCHAR pbData, ULONG cbData)
{
    UCHAR buf[0x1000] = { 0 };
    ULONG pbcResult = 0;
    NTSTATUS status = 0;

    if (!NT_SUCCESS(BCryptDecrypt(
        hKey,
        pbData,
        cbData,
        NULL,
        NULL,
        0,
        buf,
        0x1000,
        &pbcResult,
        BCRYPT_PAD_PKCS1)))
    {
        wprintf(L"BCryptDecrypt fail,error:%d\n", GetLastError());
        goto end;
    }

    //print cipher text
    PrintBytes(buf, pbcResult);

end:
    return status == 0 ? TRUE : FALSE;
}

BOOL EncryptAnd(BCRYPT_KEY_HANDLE hKey, PUCHAR pbData, ULONG cbData)
{
    UCHAR buf[0x1000] = { 0 };
    ULONG pbcResult = 0;
    NTSTATUS status = 0;

    printf("plain text length:%d\n", cbData);

    if (!NT_SUCCESS(BCryptEncrypt(
        hKey,
        pbData,
        cbData,
        NULL,
        NULL,
        0,
        buf,
        0x1000,
        &pbcResult,
        BCRYPT_PAD_PKCS1)))
    {
        wprintf(L"BCryptEncrypt fail,error:%d\n", GetLastError());
        goto end;
    }

    //print cipher text
    printf("cipher text length:%d\n", pbcResult);

    PrintBytes(buf, pbcResult);

    printf("begin to decrypt \n");
    //begin to decrypt
    DecryptAnd(hKey, buf, pbcResult);

end:
    return status == 0 ? TRUE : FALSE;
}





void UnsymmetricEncrypt()
{
    NTSTATUS status =0;
    BCRYPT_ALG_HANDLE hAlgRsa=NULL;
    BCRYPT_KEY_HANDLE hRsaKey=NULL;

    DWORD rsaPublicKeyLen = (RsaKeyLen) * 2;
    UCHAR rsaPublicKey[(RsaKeyLen) * 2] = { 0 };
    UCHAR rsaPrivateKey[(RsaKeyLen) * 2] = { 0 };
    ULONG cbResult = 0;
    PSTR PublicKey = NULL;
    PSTR PrivateKey = NULL;

    UCHAR plainText[0x20] = "abcdefghijklm";

    //opne rsa algorithm provider
    if (!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(
        &hAlgRsa,
        BCRYPT_RSA_ALGORITHM,
        NULL,
        0)))
    {
        wprintf(L"BCryptOpenAlgorithmProvider fail,error:%d\n", GetLastError());
        goto end;
   }

    //generate key pair 
    if (!NT_SUCCESS(status = BCryptGenerateKeyPair(
        hAlgRsa,
        &hRsaKey,
        RsaKeyLen,
        0
    )))
    {
        wprintf(L"BCryptGenerateKeyPair fail,error:%d\n", GetLastError());
        goto end;
    }

    //finalize
    if (!NT_SUCCESS(status = BCryptFinalizeKeyPair(
        hRsaKey,
        0)))
    {
        wprintf(L"BCryptFinalizeKeyPair fail,error:%d\n",GetLastError());
        goto end;
    }

    //encrypt and decrypt
    EncryptAnd(hRsaKey, plainText, 13);
    printf("\n");

    if (!NT_SUCCESS(status = BCryptExportKey(
        hRsaKey,
        NULL,
        BCRYPT_RSAPUBLIC_BLOB,
        rsaPublicKey,
        rsaPublicKeyLen,
        &cbResult,
        0)))
    {
        wprintf(L"BCryptExportKey fail,error:%d\n", GetLastError());
        goto end;
    }
    else
    {
        //printf public key
        //0x52, 0x53, 0x41, 0x31, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        //0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xb4, 0x7a, 0xb0, 0x43, 0xee,
        //0x48, 0xbf, 0x53, 0x05, 0x60, 0xe3, 0x0e, 0xd9, 0xe2, 0x52, 0xa3, 0xb2, 0xef, 0x08, 0x20, 0xef,
        //0xe4, 0x39, 0x40, 0xb7, 0xf9, 0xf3, 0x72, 0xe5, 0xf7, 0x3c, 0x25, 0x7e, 0x88, 0xe8, 0xe8, 0x9a,
        //0x13, 0x67, 0xca, 0x5d, 0x45, 0xd6, 0x33, 0x6f, 0x9d, 0xda, 0xcc, 0xae, 0x07, 0x44, 0x2c, 0x11,
        //0x5c, 0x82, 0xdf, 0xe9, 0x87, 0xd9, 0xf0, 0xcd, 0xb7, 0xb2, 0xc1,
        printf("rsa public key blob:\n");
        PrintBytes(rsaPublicKey, cbResult);

        //if (S_OK != ExportToPem(
        //    hRsaKey,
        //    TRUE,
        //    &PrivateKey,
        //    &cbResult))
        //{
        //    wprintf(L"ExportToPem PrivateKey fail!\n");
        //    goto end;
        //}

        if (S_OK != ExportToPem(
            hRsaKey,
            FALSE,
            &PublicKey,
            &cbResult))
        {
            wprintf(L"ExportToPem PrivateKey fail!\n");
            goto end;
        }

        printf("\npublic key in pem:\n%s\n", PublicKey);
        //printf("private key in pem:\n%s\n", PrivateKey);
    }

    wprintf(L"\n UnsymmetricEncrypt success!\n");
end:
    if (hAlgRsa)
    {
        BCryptCloseAlgorithmProvider(hAlgRsa, 0);
    }
    if (hRsaKey)
    {
        BCryptDestroyKey(hRsaKey);
    }
}

运行结果如下图：

第一次运行

                                                                  第二次运行

通过运行结果可以看出，调用系统cng api 每次生成的密钥对都不一样，这就很ok。从表面上来看，非对称加密算法比对称加密算法多一个密钥，这就更安全一点。

pureman_mega
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows密码服务框架(CNG)介绍
cqwei1987的博客
06-29 2343
本文对微软新一代密码应用接口Windows CNG进行介绍，并对其密码原语、密钥存储两个部分的特点、安全性进行分析。
【RSA】RSA加密、解密、签名与验证
小王的储物间
12-20 3142
最近要做iOS SDK的联网授权，涉及到数据安全验证，因此想到使用RSA进行签名和验证。1、客户方前往我方开放平台注册授权，得到AppId和AppSecret。2、客户方集成SDK，调用Register接口传入AppId和AppSecret。3、SDK将AppId和客户端平台相关信息提交给服务器后台。4、服务器下发最新服务器时间戳、sign、公钥、授权相关数据给客户端。5、客户端使用公钥进行签名验证。6、签名验证通过计算授权时间是否有效。
win32api 实现 RSA加解密/SHA1WithRSA/.../PEM,CER,P12解析/-易语言
06-12
目前支持： PEM X.509 公私钥 导入/解析 二进制 X.509 公钥 导入/解析 私钥 P12/PFX 导入/解析 RSA公钥加密（RSA_PKCS1_PADDING） RSA私钥解密 MD5WithRSA SHA1WithRSA SHA256WithRSA SHA384WithRSA SHA512WithRSA [hmac-]md2/md4/md5/sha1/sha256/sha384/sha512 AES128/AES192/AES256/DES/3DES/RC4 KeyFactory 类则尽量还原了 CryptoJS 3.1.2 对 key 和 IV 的自动填充，AES 除外，AES 的密钥补齐大概是 CryptoJS 的 BUG。
[CryptAPI]纯windowsAPI计算AES/DEA/3DES，RSA加密解密，RSA签名验签，HMAC，散列等
06-05
资源介绍：。这次就不用openssl了。直接用windows自带的加密库实现各种加密运算。支持的算法：。AES、DES、3DES 的（ECB/CBC/OFB/CFB/CTS 模式）。RC2  RC4。RSA密钥对生成。RSA公钥加密/私钥解密。RSA签名/验签。各种散列：MD2/MD4/MD5，SHA/SHA1/SHA256/SHA384/SHA512。HMAC算法，支持 hmac-md5    hmac-sha1   hmac-sha256   hmac-384   hmac-sha512。PEM文件纯易语言解析，载入，导出。FPX文件导入用于winhttp API 双向验证 等等（winhttpAPI 源码请自行在论坛里搜索，例子很多）。资源作者：。@落款hMZ。资源下载：。
轻松看懂的加解密系列(1) —— Windows CryptoAPI 实例介绍
最新发布
weixin_41077112的博客
09-08 1520
Windows CryptoAPI 实例介绍
MFC实现AES非对称加密解密算法
07-11
在MFC中实现非对称加密，通常需要调用如CryptoAPI或CNG（Cryptographic Native API）这样的系统级加密库。 MFC本身并不直接支持加密功能，但可以通过包含Cryptography API来实现。例如，可以使用CAES Cryptographic...
RSA.zip_RSA算法_rsa加密解密_ten7dj_windows 破解rsa_加密解密
09-21
在Windows环境下，通常使用如CryptoAPI或Windows Cryptography Next Generation (CNG) API等系统提供的加密服务来实现RSA算法。VC6.0项目中的代码可能就是利用这些API，或者自定义实现RSA的核心逻辑。 "ten7dj"可能...
Cryptography API: Next Generation(CNG)使用梳理——非对称加密算法应用（二）非对称密钥导入并保存及公钥加密私钥解密
耍宝王专栏
07-11 530
此篇主要聊一下，如果保存BCrypt创建的密钥，及导出（备份）NCrypt创建的密钥（私钥）CNG中NCrypt创建的密钥对会默认会保存在本地，而BCrypt创建的密钥对并不会保存。NCrypt创建的密钥默认不能导出私钥。
CSP编程基础--CryptAPI基本函数含参介绍
热门推荐
liuhuiyi的专栏
07-26 1万+
一： Creating a Key Container and Generating Keys   创建一个密钥容器，在进行加密，解密文件，并且签名的时候，必须需要一个公/私钥对，下面我们就来创建默认的密钥容器，要注意的是创建密钥容器并不会自动产生公/私钥对.   下面是我们程序的任务：   1，假如密钥容器不存在则创建一个。   2，假如签名密钥不存在则在密钥容器里创建一个。   3，
CNG 关于 Key 相关的操作
Useless Programmer 的专栏
03-09 1374
章节目录 简介 创建 Key 查看系统中的 Key 从 Windows Store 导出 key 导入 Key 到 Windows Store 作者能力有限, 如果您在阅读过程中发现任何错误, 还请您务必联系本人,指出错误, 避免后来读者再学习错误的知识.谢谢! 简介## CNG 全称 Cryptography API: Next Generation (CNG). 是 windows 平...
用CNG加密文件的简单方法
谢启东的专栏
02-18 8122
用CNG加密文件的简单方法     简介    文中用到了一些Cryptography API Next Generation（CNG）函数，开发环境为Windows Vista下的Visual C++ 2005 SP1标准版，加上Windows SDK及CNG SDK。    程序可适用于以下情况：    在安全环境下保存文档，但需要在不安全的媒质（如互联网）中传送。    加密文件，如图像
关于下一代加密技术 (CNG) 之RSA Cng的应用探索（一）
weixin_43136586的博客
02-29 823
公共网络（如 Internet）不提供实体间安全通信的方法。 这种网络上的通信容易被未经授权的第三方读取甚至修改。 加密这些信息有助于防止他人查看数据，它提供了检测数据是否已被修改的方式，同时有助于在非安全信道上提供安全的通信方式。 例如，可以使用加密算法对数据进行加密，在加密状态下传输数据，然后由预定的接收方对数据进行解密。 如果第三方截获了加密的数据，解密数据是很困难和费时的。 在 .NET...
winAPI做hash加密
masterfish的专栏
09-04 655
http://blog.csdn.net/wangxijie/archive/2009/09/04/4520562.aspx#include   #include   using namespace std;  #include   #include   #include   #in
恶意样本分析手册——API函数篇
zzkk_的博客
09-04 1360
文件类、网络类、注册表与服务类、进程线程类、注入类、驱动类、加密与解密、消息传递等各种类别恶意样本分析。 文件类 kernel32!CreateFile 功能：这是一个多功能的函数，可打开或创建以下对象，并返回可访问的句柄：控制台，通信资源，目录（只读打开），磁盘驱动器，文件，邮槽，管道 函数原型： HANDLE WINAPI CreateFile( _In_ LP
Microsoft Windows Vista中的下一代加密API
谢启东的专栏
01-23 4179
Microsoft Windows Vista中的下一代加密API    CNG是Windows Vista中最新的加密体系，其支持新的API、一体式用户及内核模式、灵活的加密方法及新的密码套件。    简介    CNG是Windows Vista中一种新的、灵活的框架结构，其实现了可扩展的提供者模式，可允许你通过指定所需的加密算法来加载某个提供者，而不用针对某个特殊的提供者进行硬编码。   
MS CryptoAPI/CNG
06-12
Microsoft CryptoAPI/CNG (Cryptographic API/Next Generation) 是一组基于 Windows 操作系统的加密服务。它提供了一系列加密算法和协议，包括对称加密、非对称加密、数字签名、消息认证码 (MAC)、SSL/TLS 和 IPsec 等。 CryptoAPI 是一种早期的加密 API，用于 Windows 2000 和 Windows XP 等早期版本的 Windows 操作系统。CNG 是 CryptoAPI 的后继版本，用于 Windows Vista 和更高版本的 Windows 操作系统。与 CryptoAPI 不同，CNG 采用了更强的加密算法，例如 AES、SHA-256、SHA-512 等，并支持更多的公开密钥基础设施 (PKI) 标准。 CryptoAPI/CNG 提供了一系列编程接口，包括 C++ 和 .NET 接口，以便开发人员可以轻松地实现加密和解密、数字签名和验证、密钥管理等功能。CryptoAPI/CNG 还提供了一些工具和命令行实用程序，例如 Certutil、Makecert 和 Pvk2pfx 等，用于在 Windows 操作系统中生成和管理数字证书和密钥。 CryptoAPI/CNG 也是 Microsoft 安全性产品中的一部分，例如 BitLocker、Windows Defender 和 Windows Hello 等。它们使用 CryptoAPI/CNG 来提供强大的加密和安全功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值