aes-256-ctr.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2021 Tusooa Zhu <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
 
#include <memory>
 
 
#include <copy-helper.hpp>
 
#include "crypto-util.hpp"
 
 
namespace Kazv
{
    namespace
    {
        using std::begin;
        using std::end;
    }
 
    class AES256CTRDesc
    {
    public:
        inline static const int optimalBlockSize{16};
        inline static const int keySize{32};
        inline static const int ivSize{16}; // AES block size
        inline static const int ivSizeInit{8};
        inline static const int randomSize{keySize + ivSizeInit};
        using DataT = std::string;
 
    private:
        struct RawTag {};
 
        AES256CTRDesc(RawTag, DataT key, DataT iv);
 
    public:
        AES256CTRDesc(std::string key, std::string iv);
 
        template<class RangeT>
        static AES256CTRDesc fromRandom(RangeT random) {
            if (random.size() < randomSize) {
                // Not enough random, return an invalid one
                return AES256CTRDesc(RawTag{}, DataT(), DataT());
            }
            auto iv = DataT(ivSize, 0);
            std::copy(random.begin() + keySize, random.begin() + keySize + ivSizeInit, iv.begin());
            return AES256CTRDesc(RawTag{},
                                 DataT(random.begin(), random.begin() + keySize),
                                 iv);
        }
 
        template<class RangeT1, class RangeT2>
        static AES256CTRDesc fromRaw(RangeT1 key, RangeT2 iv)
        {
            if (key.size() < keySize || iv.size() < ivSize) {
                // Not enough random, return an invalid one
                return AES256CTRDesc(RawTag{}, DataT(), DataT());
            }
            return AES256CTRDesc(RawTag{},
                                 DataT(key.begin(), key.begin() + keySize),
                                 DataT(iv.begin(), iv.begin() + ivSize));
        }
 
        KAZV_DECLARE_COPYABLE(AES256CTRDesc)
 
        ~AES256CTRDesc();
 
        bool valid() const;
 
        std::string key() const;
 
        std::string iv() const;
 
        template<class RangeT>
        using ResultBase = std::pair<AES256CTRDesc, RangeT>;
 
        using Result = ResultBase<DataT>;
 
        Result process(DataT data) const &;
        template<class RangeT,
                 class = std::enable_if_t<!std::is_same_v<std::decay_t<RangeT>, DataT>, int>>
        ResultBase<std::decay_t<RangeT>> process(RangeT data) const & {
            using ActualRangeT = std::decay_t<RangeT>;
            auto [next, res] = process(DataT(begin(data), end(data)));
            return { next, ActualRangeT(res.begin(), res.end()) };
        }
 
        Result process(DataT data) &&;
        template<class RangeT,
                 class = std::enable_if_t<!std::is_same_v<std::decay_t<RangeT>, DataT>, int>>
        ResultBase<std::decay_t<RangeT>> process(RangeT data) && {
            using ActualRangeT = std::decay_t<RangeT>;
            auto [next, res] = std::move(*this).process(DataT(begin(data), end(data)));
            return { next, ActualRangeT(res.begin(), res.end()) };
        }
 
        DataT processInPlace(DataT data);
        template<class RangeT,
                 class = std::enable_if_t<!std::is_same_v<std::decay_t<RangeT>, DataT>, int>>
        std::decay_t<RangeT> processInPlace(RangeT data) {
            using ActualRangeT = std::decay_t<RangeT>;
            auto res = processInPlace(DataT(begin(data), end(data)));
            return ActualRangeT(res.begin(), res.end());
        }
 
    private:
        struct Private;
 
        std::unique_ptr<Private> m_d;
    };
}