encode.h

Go to the documentation of this file.

// Copyright (C) 2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef ENCODE_H
#define ENCODE_H
 
#include <stdint.h>
#include <string>
#include <vector>
 
namespace isc {
namespace util {
namespace encode {
 
class BaseNEncoder {
public:
 
    BaseNEncoder(const std::string& algorithm,
                 const char* digit_set,
                 const std::vector<uint8_t>& bits_table,
                 size_t bits_per_digit,
                 size_t digits_per_group,
                 const char pad_char,
                 size_t max_pad,
                 bool case_sensitive);
 
    virtual ~BaseNEncoder() = default;
 
    std::string encode(const std::vector<uint8_t>& input);
 
    void decode(const std::string& encoded_str, std::vector<uint8_t>& output);
 
    char bitsToDigit(uint8_t bits);
 
    uint8_t digitToBits(uint8_t digit);
 
    std::string getAlgorithm() const {
        return (algorithm_);
    }
 
    const char* getDigitSet() const {
        return (digit_set_);
    }
 
    const std::vector<uint8_t>& getBitsTable() const {
        return (bits_table_);
    }
 
    size_t getBitsPerDigit() {
        return (bits_per_digit_);
    }
 
    size_t getDigitsPerGroup() const {
        return (digits_per_group_);
    }
 
    uint8_t getPadChar() const {
        return (pad_char_);
    }
 
    size_t getMaxPad() {
        return (max_pad_);
    }
 
    size_t getMaxBitsToDigit() {
        return (max_bits_to_digit_);
    }
 
    size_t getMaxDigitToBits() {
        return (max_digit_to_bits_);
    }
 
    bool isCaseSensitive() {
        return (case_sensitive_);
    }
 
protected:
    std::string algorithm_;
 
    const char* digit_set_;
 
    std::vector<uint8_t>bits_table_;
 
    size_t bits_per_digit_;
 
    size_t digits_per_group_;
 
    const char pad_char_;
 
    size_t max_pad_;
 
    bool case_sensitive_;
 
    size_t max_bits_to_digit_;
 
    size_t max_digit_to_bits_;
};
 
class Base64Encoder : public BaseNEncoder {
public:
    static const char* DIGIT_SET;
 
    static const std::vector<uint8_t> BITS_TABLE;
 
    Base64Encoder()
     : BaseNEncoder("base64", DIGIT_SET, BITS_TABLE, 6, 4, '=', 2, true) {
    }
 
    ~Base64Encoder() = default;
};
 
class Base32HexEncoder : public BaseNEncoder {
public:
    static const char* DIGIT_SET;
 
    static const std::vector<uint8_t> BITS_TABLE;
 
    Base32HexEncoder()
     : BaseNEncoder("base32Hex", DIGIT_SET, BITS_TABLE, 5, 8, '=', 6, false) {
    }
 
    ~Base32HexEncoder() = default;
};
 
class Base16Encoder : public BaseNEncoder {
public:
    static const char* DIGIT_SET;
 
    static const std::vector<uint8_t> BITS_TABLE;
 
    Base16Encoder()
     : BaseNEncoder("base16", DIGIT_SET, BITS_TABLE, 4, 2, '=', 0, false) {
    }
 
    ~Base16Encoder() = default;
};
 
std::string encodeBase32Hex(const std::vector<uint8_t>& binary);
 
void decodeBase32Hex(const std::string& encoded_str, std::vector<uint8_t>& output);
 
std::string encodeBase64(const std::vector<uint8_t>& binary);
 
void decodeBase64(const std::string& encoded_str, std::vector<uint8_t>& output);
 
std::string encodeHex(const std::vector<uint8_t>& binary);
 
void decodeHex(const std::string& encoded_str, std::vector<uint8_t>& output);
 
inline std::string toHex(std::string value) {
    std::vector<uint8_t> bin(value.begin(), value.end());
    return ("0x" + encodeHex(bin));
}
 
} // namespace encode
} // namespace util
} // namespace isc
 
#endif  // ENCODE_H