c++ - Crypto++ 的 SecByteBlock 类的优点

Question

我正在使用 Crypto++ 库在 CBC 模式下使用 AES 算法解密文件。我在 sample code 中遇到了 SecByteBlock 类AES 表示

The key is declared on the stack using a SecByteBlock to ensure the sensitive material is zeroized.

谁能解释一下什么时候 SecByteBlock 的内容会被清除，以及这个类比 char* 有什么优势。

提前致谢

Answer 1

[title] Advantages of SecByteBlock class from Crypto++

使用 SecByteBlock 的优势您是否获得了具有归零功能的托管缓冲区。归零通常是合规性项目。例如，FIPS 140-2 要求它，即使是在 1 级验证中也是如此。

第二个不明显的好处是分配器不初始化 POD 内存 - 它返回一个原始 block 。这很有意义，因为您经常采用 0 值初始化，然后用数据覆盖内容。初始化它没有任何意义，它节省了很多时间。

可以得到SecBlock提供一个 0 值初始化 block 。以下是执行这两项操作的方法:

SecByteBlock block1(32);
SecByteBlock block2(NULL, 32);

block1大小为 32 字节，未初始化，其内容将是垃圾。

block2大小也是 32 字节，但它使用 (ptr, size)重载。重载将复制 ptr 指向的 block 。 , 或者它会写 0 如果它是 NULL .

---

为了完整性和引用，一个 SecByteBlock只是 SecBlock<byte> 的类型定义. SecBlock<T>是感兴趣的类，图书馆经常使用 SecBlock<byte> , SecBlock<word32> , SecBlock<word64>等

这是 Doxygen 为 SecBlock 生成的手册页: SecBlock< T, A > Class Template Reference .这是 secblock.h 的头文件(它只是一个 header 实现)。

---

Can someone please explain me when the contents of SecByteBlock will get cleared ...

SecByteBlock的内容在明显的对象破坏情况下被清除。即分配给SecBlock的内存在析构函数运行时以 0 的模式清除。

有一个不明显的案例，那就是 resize称为缩一。在这种情况下，返回给操作系统的额外空间也会被删除。

可以在源码中看到删除。例如，来自 Crypto++ 5.6.4 secblock.h :

  187     //! \brief Deallocates a block of memory
  188     //! \param ptr the pointer for the allocation
  189     //! \param size the size of the allocation, in elements
  190     //! \details Internally, SecureWipeArray() is called before deallocating the memory.
  191     //!   Once the memory block is wiped or zeroized, AlignedDeallocate() or
  192     //!   UnalignedDeallocate() is called.
  193     //! \details AlignedDeallocate() is used if T_Align16 is true.
  194     //!   UnalignedDeallocate() used if T_Align16 is false.
  195     void deallocate(void *ptr, size_type size)
  196     {
  197         CRYPTOPP_ASSERT((ptr && size) || !(ptr || size));
  198         SecureWipeArray((pointer)ptr, size);
  199 
  200 #if CRYPTOPP_BOOL_ALIGN16
  201         if (T_Align16 && size*sizeof(T) >= 16)
  202             return AlignedDeallocate(ptr);
  203 #endif
  204 
  205         UnalignedDeallocate(ptr);
  206     }

---

what advantages this class offer over char*.

嗯，SecBlock<byte>是一个管理缓冲区的类。 char*只是一种类型，并没有太多。您必须管理 char* 的缓冲区指向。

您可以使用类似 std::string 的东西, 但你不会得到溢出检测(只需要 std::vector 来检查它)并且你不会得到归零。

话虽如此，您可以同时执行以下操作:

• typdef SecBlock<char> SecCharBlock
• typedef std::basic_string<char, std::char_traits<char>, AllocatorWithCleanup<char> > secure_string

第二个有点酷。你可以做到，因为secblock.h提供与标准库兼容的安全分配器。 SecBlock<T>在内部使用安全分配器，它被称为 AllocatiorWithCleanup<T> .

OpenSSL 的维基页面 EVP Symmetric Encryption and Decryption | C++ Progams使用类似的分配器来提供 secure_string在他们的例子中上课。 OpenSS: 的 zallocator电话 OpenSSL_cleanse .

来自 Crypto++ 5.6.4 secblock.h :

  141 //! \class AllocatorWithCleanup
  142 //! \brief Allocates a block of memory with cleanup
  143 //! \tparam T class or type
  144 //! \tparam T_Align16 boolean that determines whether allocations should be aligned on 16-byte boundaries
  145 //! \details If T_Align16 is true, then AllocatorWithCleanup calls AlignedAllocate()
  146 //!    for memory allocations. If T_Align16 is false, then AllocatorWithCleanup() calls
  147 //!    UnalignedAllocate() for memory allocations.
  148 //! \details Template parameter T_Align16 is effectively controlled by cryptlib.h and mirrors
  149 //!    CRYPTOPP_BOOL_ALIGN16. CRYPTOPP_BOOL_ALIGN16 is often used as the template parameter.
  150 template <class T, bool T_Align16 = false>
  151 class AllocatorWithCleanup : public AllocatorBase<T>
  152 {
  153 public:
  154     CRYPTOPP_INHERIT_ALLOCATOR_TYPES
  155 
  156     //! \brief Allocates a block of memory
  157     //! \param ptr the size of the allocation
  158     //! \param size the size of the allocation, in elements
  159     //! \returns a memory block
  160     //! \throws InvalidArgument
  161     //! \details allocate() first checks the size of the request. If it is non-0
  162     //!   and less than max_size(), then an attempt is made to fulfill the request
  163     //!   using either AlignedAllocate() or UnalignedAllocate().
  164     //! \details AlignedAllocate() is used if T_Align16 is true.
  165     //!   UnalignedAllocate() used if T_Align16 is false.
  166     //! \details This is the C++ *Placement New* operator. ptr is not used, and the function
  167     //!   CRYPTOPP_ASSERTs in Debug builds if ptr is non-NULL.
  168     //! \sa CallNewHandler() for the methods used to recover from a failed
  169     //!   allocation attempt.
  170     //! \note size is the count of elements, and not the number of bytes
  171     pointer allocate(size_type size, const void *ptr = NULL)
  172     {
  173         CRYPTOPP_UNUSED(ptr); CRYPTOPP_ASSERT(ptr == NULL);
  174         this->CheckSize(size);
  175         if (size == 0)
  176             return NULL;
  177 
  178 #if CRYPTOPP_BOOL_ALIGN16
  179         // TODO: should this need the test 'size*sizeof(T) >= 16'?
  180         if (T_Align16 && size*sizeof(T) >= 16)
  181             return (pointer)AlignedAllocate(size*sizeof(T));
  182 #endif
  183 
  184         return (pointer)UnalignedAllocate(size*sizeof(T));
  185     }
  186     ...
  241 };