Arguments.hpp

#ifndef BKCRACK_ARGUMENTS_HPP
#define BKCRACK_ARGUMENTS_HPP
 
#include "Data.hpp"
#include "Keys.hpp"
#include "types.hpp"
 
#include <limits>
#include <map>
#include <optional>
#include <unordered_map>

class Arguments
{
public:
    class Error : public BaseError
    {
    public:
        explicit Error(const std::string& description);
    };

    Arguments(int argc, const char* argv[]);

    auto loadData() const -> Data;
 
    std::optional<std::string> cipherFile;    
    std::optional<std::size_t> cipherIndex;   
    std::optional<std::string> cipherArchive; 
 
    std::optional<std::string> plainFile;    
    std::optional<std::size_t> plainIndex;   
    std::optional<std::string> plainArchive; 

    std::size_t plainFilePrefix = 1 << 20;

    int offset = 0;

    std::map<int, std::uint8_t> extraPlaintext;

    bool ignoreCheckByte = false;

    int attackStart = 0;

    std::optional<std::string> password;

    std::optional<Keys> keys;

    std::optional<std::string> decipheredFile;

    bool keepHeader = false;

    std::optional<std::string> decryptedArchive;

    struct ChangePassword
    {
        std::string unlockedArchive; 
        std::string newPassword;     
    };

    std::optional<ChangePassword> changePassword;

    struct ChangeKeys
    {
        std::string unlockedArchive; 
        Keys        newKeys;         
    };

    std::optional<ChangeKeys> changeKeys;

    std::optional<std::vector<std::uint8_t>> bruteforce;

    struct LengthInterval
    {
        std::size_t minLength{0};

        std::size_t maxLength{std::numeric_limits<std::size_t>::max()};

        auto operator&(const LengthInterval& other) const -> LengthInterval;
    };

    std::optional<LengthInterval> length;

    std::optional<std::vector<std::vector<std::uint8_t>>> mask;

    std::string recoveryStart;

    int jobs;

    bool exhaustive = false;

    std::optional<std::string> infoArchive;

    bool version = false;

    bool help = false;
 
private:
    const char**       m_current;
    const char** const m_end;
 
    std::unordered_map<char, std::bitset<256>> m_charsets;
    std::unordered_map<char, std::string>      m_rawCharsets;
 
    // Resolve the set of characters denoted by the given charset specification,
    // recursively resolving referenced charsets from m_rawCharsets and caching results in m_charsets.
    auto resolveCharset(const std::string& rawCharset) -> std::bitset<256>;
 
    std::optional<std::string> m_rawBruteforce;
    std::optional<std::string> m_rawMask;
 
    auto finished() const -> bool;
 
    void parseArgument();
 
    enum class Option
    {
        cipherFile,
        cipherIndex,
        cipherArchive,
        plainFile,
        plainIndex,
        plainArchive,
        plainFilePrefix,
        offset,
        extraPlaintext,
        ignoreCheckByte,
        attackStart,
        password,
        keys,
        decipheredFile,
        keepHeader,
        decryptedArchive,
        changePassword,
        changeKeys,
        bruteforce,
        length,
        recoverPassword,
        mask,
        charset,
        recoveryStart,
        jobs,
        exhaustive,
        infoArchive,
        version,
        help
    };
 
    auto readString(const std::string& description) -> std::string;
    auto readOption(const std::string& description) -> Option;
    auto readInt(const std::string& description) -> int;
    auto readSize(const std::string& description) -> std::size_t;
    auto readHex(const std::string& description) -> std::vector<std::uint8_t>;
    auto readKey(const std::string& description) -> std::uint32_t;
    auto readRawCharset(const std::string& description) -> std::string;
};
 
#endif // BKCRACK_ARGUMENTS_HPP