Method decryptWithAd

libs/utils/src/utils/crypto/AesEncryptor.cpp:78–114

}

std::optional<std::vector<uint8_t>> AesEncryptor::decryptWithAd(const uint8_t* cipherText,
                                                                size_t len,
                                                                const uint8_t* additionalData,
                                                                size_t adLen) {
    SC_ASSERT_NOTNULL(cipherText);
    EVP_AEAD_CTX ctx;
    if (EVP_AEAD_CTX_init(&ctx, _cipher, _key.data(), _key.size(), EVP_AEAD_max_tag_len(_cipher), nullptr) == 0) {
        SCLOGE(kTag, "Failed to initialize decryption key");
        logCryptoErrors();
        SC_ASSERT(false, "Bad key");
        return std::nullopt;
    }
    const auto maxOverheadLen = EVP_AEAD_max_overhead(_cipher);
    if (len < maxOverheadLen) {
        SCLOGW(kTag, "Invalid cipherText length {}. Min expected: {}", len, maxOverheadLen);
        return std::nullopt;
    }
    std::vector<uint8_t> plainText(len - maxOverheadLen, 0);
    size_t outLen;
    if (EVP_AEAD_CTX_open(&ctx,
                          plainText.data(),
                          &outLen,
                          plainText.capacity(),
                          _iv.data(),
                          _iv.size(),
                          cipherText,
                          len,
                          additionalData,
                          adLen) == 0) {
        SCLOGE(kTag, "Failed decryption");
        logCryptoErrors();
        return {};
    }
    SC_ASSERT(outLen == plainText.size());
    EVP_AEAD_CTX_cleanup(&ctx);
    return {plainText};
}

std::optional<std::vector<uint8_t>> AesEncryptor::encrypt(const std::vector<uint8_t>& plainText) {
    return encrypt(plainText.data(), plainText.size());