OpenSSLAesCcm.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_OPENSSLAESCCM_HXX_
#define _UTILS_OPENSSLAESCCM_HXX_
 
#include <string>
#include <openssl/evp.h>
 
#include "utils/logging.h"
 
#ifndef ASSERT_EQ
#define ASSERT_EQ(expected, actual)                                            \
    do                                                                         \
    {                                                                          \
        int __ret = (actual);                                                  \
        int __e = (expected);                                                  \
        if (__e != __ret)                                                      \
        {                                                                      \
            LOG(FATAL, "At %s(%d): Failed assertion " #actual                  \
                       ": expected %d actual %d\n",                            \
                __FILE__, __LINE__, __e, __ret);                               \
            HASSERT(0);                                                        \
        }                                                                      \
    } while (false)
#endif
 
void CCMEncrypt(const std::string &aes_key, const std::string &iv,
    const std::string &auth_data, const std::string &plain, std::string *cipher,
    std::string *tag)
{
    ASSERT_EQ(32u, aes_key.size());
    ASSERT_EQ(11u, iv.size());
 
    EVP_CIPHER_CTX *ctx;
    ctx = EVP_CIPHER_CTX_new();
 
    ASSERT_EQ(1,
        EVP_EncryptInit_ex(ctx, EVP_aes_256_ccm(), nullptr, nullptr, nullptr));
 
    constexpr int taglen = 16;
    constexpr int Lvalue = 4;
    constexpr int ivlen = 15 - Lvalue;
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG, taglen, nullptr);
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN, ivlen, NULL);
    EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_L, Lvalue, NULL);
    // ASSERT_EQ(ivlen, EVP_CIPHER_CTX_iv_length(ctx));
    int key_length = EVP_CIPHER_CTX_key_length(ctx);
    ASSERT_EQ(32, key_length);
    ASSERT_EQ(
        1, EVP_EncryptInit_ex(ctx, nullptr, nullptr,
               (const uint8_t *)aes_key.data(), (const uint8_t *)iv.data()));
 
    int outlen = -1;
    ASSERT_EQ(
        1, EVP_EncryptUpdate(ctx, nullptr, &outlen, nullptr, plain.size()));
 
    ASSERT_EQ(1, EVP_EncryptUpdate(ctx, nullptr, &outlen,
                     (const uint8_t *)auth_data.data(), auth_data.size()));
    cipher->resize(plain.size() + 16);
    ASSERT_EQ(1, EVP_EncryptUpdate(ctx, (uint8_t *)&((*cipher)[0]), &outlen,
                     (const uint8_t *)plain.data(), plain.size()));
    HASSERT(outlen <= (int)cipher->size());
    LOG(INFO, "encupdate: in=%d, ret=%d", (int)plain.size(), outlen);
    cipher->resize(outlen);
    // CCM always outputs the same number of bytes than the input.
    ASSERT_EQ((int)plain.size(), outlen);
    int ret = -1;
    ASSERT_EQ(1, EVP_EncryptFinal_ex(ctx, (uint8_t *)&((*cipher)[0]), &ret));
    ASSERT_EQ(0, ret);
 
    tag->resize(16);
    ASSERT_EQ(
        1, EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_GET_TAG, 16, &((*tag)[0])));
 
    EVP_CIPHER_CTX_free(ctx);
}
 
class MD
{
public:
    static std::string SHA256(const void *data, size_t len)
    {
        EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
        std::string ret(32, 0);
        EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
        EVP_DigestUpdate(mdctx, data, len);
        unsigned int md_len;
        EVP_DigestFinal_ex(mdctx, (uint8_t *)&ret[0], &md_len);
        HASSERT(md_len == 32);
        EVP_MD_CTX_free(mdctx);
        return ret;
    }
 
private:
    MD();
};
 
#endif // _UTILS_OPENSSLAESCCM_HXX_