DES64-CTR加密息争密模式

问题

   加密

1.     输入：<plaintext> <key> <iv>
3.     输出：<ciphertext>
5.     例如
7.     输入：<i love you, sunsiqi> <0123456789ABCDEF> <FEDCBA0123456789>
9.     输出：<4e152ec964f73950dfc7a3d833bdaeffd6f0b8a727c13c29>

复制代码

解密

1.       输入：<ciphertext> <key> <iv>
3.       输出：<plaintext>
5.       例如
7.       输入：<4e152ec964f73950dfc7a3d833bdaeffd6f0b8a727c13c29> <0123456789ABCDEF> <FEDCBA0123456789>
9.       输出：<i love you, sunsiqi>

复制代码

要求
  

• 举行安全内存管理
  
• 加密或解密操作完成后清算敏感数据
  

  介绍

   CTR模式
          CTR（Counter）模式即计数器模式，是一种流暗码模式。它将一个递增的计数器值通过加密算法加密后与明文举行异或运算得到密文，解密时使用相同的计数器值加密后再与密文异或得到明文。计数器模式把块暗码转换为流暗码，可并行处理数据，并且支持随机访问。
  特点
  

• 流暗码特性：DES - CTR 模式将 DES 块暗码转换为流暗码，答应对任意长度的数据举行加密，而不必要对数据举行填充。
  
• 并行处理：由于每个计数器值的加密操作是相互独立的，因此可以并行处理，进步加密息争密的效率。
  
• 随机访问：可以在任意位置开始解密，而不必要解密前面的所有数据块，这在必要随机访问加密数据的应用中非常有效。
  

  工作原理
  

• 初始化计数器：选择一个初始计数器值（通常称为初始向量，IV），计数器的长度通常与 DES 算法的块长度相同（64 位）。
  
• 计数器递增：在每次加密或解密操作前，计数器的值递增。
  
• 加密计数器值：使用 DES 算法对当前计数器值举行加密，得到一个 64 位的加密块。
  
• 异或运算：将加密块与明文数据的相应部分举行异或运算，得到密文数据。解密时，使用相同的计数器值举行加密，然后与密文数据举行异或运算，得到明文数据。
  

  特性
  特性CTR模式初始化向量称为计数器（Counter）填充要求无需填充并行性支持并行加密/解密错误流传只影响单个字节密钥流重用绝对禁止（计数器必须唯一）典范应用场景实时流加密、随机访问  长处
  

• 高效性：支持并行处理，加密息争密速度快。
  
• 机动性：不必要对数据举行填充，可处理任意长度的数据。
  
• 随机访问：可以在任意位置开始解密，实用于随机访问场景。
  

  缺点
  

• 密钥管理：必要确保计数器值的唯一性，否则大概会导致安全毛病。如果两个差异的加密操作使用了相同的计数器值，攻击者可以通过异或两个密文来恢复部分明文信息。
  
• 安全性依靠：DES 算法自己的密钥长度较短，存在被暴力破解的风险，因此 DES - CTR 模式的安全性也受到一定影响。在对安全性要求较高的场景中，建议使用更安全的加密算法。
  

  分析

   为什么要清算敏感数据？
  敏感数据（如加密密钥、明文数据、初始化向量等）在使用完毕后如果不及时清算，大概会残留在内存中，存在安全风险。攻击者有大概通过某些本领从内存中恢复这些敏感信息，从而造成数据泄露。
     在加密或解密操作完成后必要清算敏感数据，本文主要描述两种操作方式：
  

• 在方法体内立即实验。在加密或解密方法的加密或解密操作之后添加安全清算敏感数据的代码。使用volatile指针防止编译器优化清零操作。
  1. volatile char* volatile_key = reinterpret_cast<volatile char*>(&key[0]);
  2. volatile char* volatile_iv = reinterpret_cast<volatile char*>(&iv[0]);
  3. std::fill(volatile_key, volatile_key + key.size(), 0);
  4. std::fill(volatile_iv, volatile_iv + iv.size(), 0);

  复制代码
• 使用RAII方式。 
  

  

• RAII（Resource Acquisition Is Initialization）即 “资源获取即初始化”，是 C++ 中管理资源、避免资源泄漏的一种编程惯用法。
  
• RAII 使用对象的生命周期来管理资源。当一个对象被创建时，它会自动获取所需的资源；当对象的生命周期竣事时（例如，对象脱离其作用域），它会自动开释这些资源。这里的资源可以是各种必要手动管理的东西，如内存、文件句柄、网络连接、数据库连接等。
  
• RAII 的核心原理基于 C++ 的构造函数和析构函数机制：
          构造函数：在对象创建时自动调用，负责资源的获取。
          析构函数：在对象销毁时自动调用，负责资源的开释。
  通过这种方式，资源的生命周期与对象的生命周期绑定在一起，从而确保资源在不必要时被精确开释。
  

1. // 新增安全擦除类，在namespace SymCryptoUtilities中添加安全擦除类
2.     class SecureWiper {
3.         public:
4.             SecureWiper(std::string& data) : m_data(data) {}
5.             ~SecureWiper() {
6.                 // 添加调试输出验证清理操作
7.                 std::cout << "Wiping data at: " << (void*)&m_data[0] << std::endl;
8.                 if (!m_data.empty()) {
9.                 // 使用volatile指针防止编译器优化清零操作
10.                     volatile char* ptr = reinterpret_cast<volatile char*>(&m_data[0]);
11.                     std::fill(ptr, ptr + m_data.size(), 0);
12.                 }
13.             }
14.         private:
15.             std::string& m_data;
16.     };

复制代码

在main函数解码key和iv之后创建安全擦除对象，在此之后实验加密或解密操作，在return 0；之后自动调用wipe_key和wipe_iv的析构函数完成清算

1. // 创建安全擦除对象，在main函数的解码key和iv之后创建安全擦除对象，在此之后执行加密或解密操作，在return 0；之后自动调用wipe_key和wipe_iv的析构函数完成清理
2.         SymCryptoUtilities::SecureWiper wipe_key(key);
3.         SymCryptoUtilities::SecureWiper wipe_iv(iv);

复制代码

    在main函数中必要移除const修饰符，答应修改key和iv。

1.     // 原代码
2.     const std::string key = SymCryptoUtilities::hexDecode(keyHex);
3.     const std::string iv  = SymCryptoUtilities::hexDecode(ivHex);
5.     // 修改为
6.     std::string key = SymCryptoUtilities::hexDecode(keyHex);
7.     std::string iv  = SymCryptoUtilities::hexDecode(ivHex);

复制代码

    安全擦除机制
  

• 使用volatile指针防止编译器优化清零操作
  
• 通过RAII确保脱离作用域自动清算，清算操作在栈展开时自动实验，即使加密过程中抛出异常，RAII对象也会保证清算内存
  
• 覆盖所有内存区域（包括短字符串优化的栈内存）
  

    内存管理优化
  在main函数中使用Crypto++的SecByteBlock替代std::string，SecByteBlock会在析构时自动安全擦除内存。
  SecByteBlock 是 Crypto++ 库中用于管理字节数组的类，它在一定水平上提供了自动内存管理功能。当 SecByteBlock 对象的生命周期竣事时，其析构函数会自动开释所占用的内存。然而，这并不意味着内存中的数据会被安全地清算。为了确保敏感数据不会残留在内存中，仍旧必要在对象销毁前自动清算数据。可以通过自定义一个类，使用其构造函数和析构函数来实现 RAII 方式的敏感数据清算。

1.     CryptoPP::SecByteBlock key = SymCryptoUtilities::hexDecode(keyHex);
2.     CryptoPP::SecByteBlock iv  = SymCryptoUtilities::hexDecode(ivHex);

复制代码

代码

   头文件

1. #include <iostream>
2. #include <string>
3. #include <cctype>
4. #include <cryptopp/des.h>
5. #include <cryptopp/modes.h>
6. #include <cryptopp/filters.h>
7. #include <cryptopp/hex.h>
8. #include <stdexcept>

复制代码

主函数

1. int main(int argc, char* argv[]) {
3.    if (argc != 4) {
4.         if (argc != 4) {
5.         std::cerr << "Usage: " << argv[0] << " <plaintext> <hex_key> <hex_counter>\n"
6.                   << "Example: " << argv[0] << " "SecretData" 0123456789ABCDEF FEDCBA9876543210\n"
7.                   << "Note: Key and Counter must be 16-character hexadecimal strings (8 bytes)\n"
8.                   << "Note: support arbitrary binary data such as Chinese characters\n"
9.                   << "Note: no padding is required when using the CTR mode."
10.                   << std::endl;
11.         return 1;
12.         }
13.     }
15.     const std::string plaintext = argv[1];
16.     const std::string keyHex    = argv[2];
17.     const std::string counterHex = argv[3];
19.     try {
20.         // 输入验证
21.         if (keyHex.length() != 16 || !SymCryptoUtilities::isValidHex(keyHex)) {
22.             throw std::invalid_argument("Key must be 16-character hex string (8 bytes)");
23.         }
24.         if (counterHex.length() != 16 || !SymCryptoUtilities::isValidHex(counterHex)) {
25.             throw std::invalid_argument("Counter must be 16-character hex string (8 bytes)");
26.         }
29.         /*
30.         内存管理优化，在main函数中使用Crypto++的SecByteBlock替代std::string，SecByteBlock会在析构时自动安全擦除内存。
31.         SecByteBlock 是 Crypto++ 库中用于管理字节数组的类，它在一定程度上提供了自动内存管理功能。当 SecByteBlock 对象的生命周期结束时，其析构函数会自动释放所占用的内存。然而，这并不意味着内存中的数据会被安全地清理。为了确保敏感数据不会残留在内存中，仍然需要在对象销毁前主动清理数据。可以通过自定义一个类，利用其构造函数和析构函数来实现 RAII 方式的敏感数据清理。
32.         
33.         CryptoPP::SecByteBlock key = SymCryptoUtilities::hexDecode(keyHex);
34.         CryptoPP::SecByteBlock iv  = SymCryptoUtilities::hexDecode(ivHex);
35.         */
37.         // 十六进制解码密钥和计数器，移除const设置，允许修改
38.         std::string key = SymCryptoUtilities::hexDecode(keyHex);
39.         std::string counter = SymCryptoUtilities::hexDecode(counterHex);
41.         /*  RAII安全擦除
42.             创建安全擦除对象。在解码之后创建安全擦除对象，在此之后执行加密或解密操作。
43.             程序运行完return 0；之后，自动调用wipe_key和wipe_counter的析构函数完成清理
44.         */
45.         SymCryptoUtilities::SecureWiper wipe_key(key);
46.         SymCryptoUtilities::SecureWiper wipe_counter(counter);
48.         // 执行加密
49.         const std::string ciphertext = SymCryptoUtilities::desCTREncrypt(plaintext, key, counter);
51.         std::cout << "Ciphertext (hex): " << ciphertext << std::endl;
52. } catch (const std::exception& e) {
53.         std::cerr << "Error: ";
54.         try {
55.             std::rethrow_if_nested(e);
56.         } catch (const std::exception& nested) {
57.             std::cerr << nested.what() << std::endl;
58.             return 2;
59.         }
60.         std::cerr << e.what() << std::endl;
61.         return 1;
62.     }
64.     return 0;
65. }

复制代码

加密

   方法

1. namespace SymCryptoUtilities {
3.     bool isValidHex(const std::string& hexStr) {
4.         if (hexStr.empty()) return false;
5.         for (char c : hexStr) {
6.             if (!std::isxdigit(c)) return false;
7.         }
8.         return true;
9.     }
11.     std::string hexDecode(const std::string& hexStr) {
12.         if (hexStr.length() % 2 != 0) {
13.             throw std::invalid_argument("Hex string must have even length");
14.         }
16.         std::string decoded;
17.         CryptoPP::StringSource ss(
18.             hexStr, true,
19.             new CryptoPP::HexDecoder(
20.                 new CryptoPP::StringSink(decoded)
21.             )
22.         );
23.         return decoded;
24.     }
26.     std::string hexEncode(const std::string& data) {
27.         std::string encoded;
28.         CryptoPP::StringSource ss(
29.             data, true,
30.             new CryptoPP::HexEncoder(
31.                 new CryptoPP::StringSink(encoded),
32.                 false // 无换行符
33.             )
34.         );
35.         return encoded;
36.     }
38.     /*
39.     RAII（Resource Acquisition Is Initialization）即 “资源获取即初始化”，是 C++ 中管理资源、避免资源泄漏的一种编程惯用法。
40.     RAII 利用对象的生命周期来管理资源。当一个对象被创建时，它会自动获取所需的资源；当对象的生命周期结束时（例如，对象离开其作用域），它会自动释放这些资源。这里的资源可以是各种需要手动管理的东西，如内存、文件句柄、网络连接、数据库连接等。
41.     RAII 的核心原理基于 C++ 的构造函数和析构函数机制：
42.         构造函数：在对象创建时自动调用，负责资源的获取。
43.         析构函数：在对象销毁时自动调用，负责资源的释放。
44.     通过这种方式，资源的生命周期与对象的生命周期绑定在一起，从而确保资源在不需要时被正确释放。
45.     通过RAII确保离开作用域自动清理，清理操作在栈展开时自动执行，即使加密过程中抛出异常，RAII对象也会保证清理内存
46.     */
47.     // 安全擦除类（RAII）
48.     class SecureWiper {
49.     public:
50.         SecureWiper(std::string& data) : m_data(data) {}
51.         ~SecureWiper() {
52.             // 添加调试输出验证清理操作
53.             std::cout << "Wiping data at: " << (void*)&m_data[0] << std::endl;
54.             if (!m_data.empty()) {
55.                 // 使用volatile指针防止编译器优化清零操作
56.                 volatile char* ptr = reinterpret_cast<volatile char*>(&m_data[0]);
57.                 std::fill(ptr, ptr + m_data.size(), 0);
58.             }
59.         }
60.     private:
61.         std::string& m_data;
62.     };
64.     // DES-CTR加密函数
65.     std::string desCTREncrypt(const std::string& plaintext,
66.                              const std::string& key,
67.                              const std::string& counter) {
68.         try {
69.             // 参数验证
70.             if (key.size() != CryptoPP::DES::DEFAULT_KEYLENGTH) {
71.                 throw std::invalid_argument("Invalid key size. Expected 8 bytes");
72.             }
73.             if (counter.size() != CryptoPP::DES::BLOCKSIZE) {
74.                 throw std::invalid_argument("Invalid counter size. Expected 8 bytes");
75.             }
77.             // 设置加密器
78.             CryptoPP::CTR_Mode<CryptoPP::DES>::Encryption encryptor;
79.             encryptor.SetKeyWithIV(
80.                 reinterpret_cast<const CryptoPP::byte*>(key.data()), key.size(),
81.                 reinterpret_cast<const CryptoPP::byte*>(counter.data())
82.             );
84.             // 执行加密
85.             std::string ciphertext;
86.             CryptoPP::StringSource ss(
87.                 plaintext, true,
88.                 new CryptoPP::StreamTransformationFilter(
89.                     encryptor,
90.                     new CryptoPP::StringSink(ciphertext) //无填充参数
91.                 )
92.             );
94.             /*
95.                 // 安全清理敏感数据（立即执行）
96.                 volatile char* volatile_key = reinterpret_cast<volatile char*>(&key[0]);
97.                 volatile char* volatile_iv = reinterpret_cast<volatile char*>(&iv[0]);
98.                 std::fill(volatile_key, volatile_key + key.size(), 0);
99.                 std::fill(volatile_iv, volatile_iv + iv.size(), 0);
100.             */
102.             return hexEncode(ciphertext);
104.         } catch (const CryptoPP::Exception& e) {
105.             std::throw_with_nested(std::runtime_error("Crypto++错误: " + std::string(e.what())));
106.         }catch (const std::exception& e) {
107.             std::cerr << "Standard Exception: " << e.what() << std::endl;
108.             throw;
109.         }
110.     }
111. }

复制代码

解密

   方法

1. // DES-CTR解密函数
2.     std::string desCTRDecrypt(const std::string& ciphertextHex,
3.                               const std::string& key,
4.                               const std::string& counter) {
5.             try {
6.                 // 参数验证
7.                 if (key.size() != CryptoPP::DES::DEFAULT_KEYLENGTH) {
8.                     throw std::invalid_argument("Invalid key size. Expected 8 bytes");
9.                 }
10.                 if (counter.size() != CryptoPP::DES::BLOCKSIZE) {
11.                     throw std::invalid_argument("Invalid counter size. Expected 8 bytes");
12.                 }
13.                 if (!isValidHex(ciphertextHex)) {
14.                     throw std::invalid_argument("Invalid Hexadecimal ciphertext");
15.                 }
17.                 // 解码十六进制
18.                 const std::string ciphertext = hexDecode(ciphertextHex);
20.                 // 设置解密器（CTR模式加密解密使用相同对象）
21.                 CryptoPP::CTR_Mode<CryptoPP::DES>::Decryption decryptor;
22.                 decryptor.SetKeyWithIV(
23.                     reinterpret_cast<const CryptoPP::byte*>(key.data()), key.size(),
24.                     reinterpret_cast<const CryptoPP::byte*>(counter.data())
25.                 );
27.                 // 执行解密
28.                 std::string decrypted;
29.                 CryptoPP::StringSource ss(
30.                     ciphertext, true,
31.                     new CryptoPP::StreamTransformationFilter(
32.                         decryptor,
33.                         new CryptoPP::StringSink(decrypted)
34.                     )
35.                 );
37.                 return decrypted;
39.             }catch (const CryptoPP::Exception& e) {
40.                 std::throw_with_nested(std::runtime_error("Crypto++错误: " + std::string(e.what())));
41.             }catch (const std::exception& e) {
42.                 std::cerr << "Standard Exception: " << e.what() << std::endl;
43.                 throw;
44.             }
45.   }

复制代码

运行

  

1. g++ DES64-CTR-decrypt.cpp -o decrypt -lcryptopp
3. g++ DES64-CTR-encrypt.cpp -o encrypt -lcryptopp

复制代码

测试 

   

  

  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。