VirgilByteArray.h

#ifndef VIRGIL_BYTE_ARRAY_H
#define VIRGIL_BYTE_ARRAY_H

#include <cstring>
#include <string>
#include <sstream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <tuple>

namespace virgil { namespace crypto {

typedef std::vector<unsigned char> VirgilByteArray;

}}

#define VIRGIL_BYTE_ARRAY_TO_PTR_AND_LEN(array) reinterpret_cast<const unsigned char *>(array.data()), array.size()

#define VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(ptr, len)\
        virgil::crypto::VirgilByteArray(reinterpret_cast<virgil::crypto::VirgilByteArray::const_pointer >(ptr), \
        reinterpret_cast<virgil::crypto::VirgilByteArray::const_pointer >((ptr) + (len)))

namespace virgil { namespace crypto {

inline VirgilByteArray str2bytes(const std::string& str) {
    return VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(str.data(), str.size());
}

inline std::string bytes2str(const VirgilByteArray& array) {
    return std::string(reinterpret_cast<const char*>(array.data()), array.size());
}

inline VirgilByteArray hex2bytes(const std::string hexStr) {
    VirgilByteArray result;
    std::istringstream istr(hexStr);
    char hexChars[3] = {0x00};
    while (istr.read(hexChars, 2)) {
        int byte = 0;
        std::istringstream(hexChars) >> std::hex >> byte;
        result.push_back((unsigned char) byte);
    }
    return result;
}

inline std::string bytes2hex(const VirgilByteArray& array, bool formatted = false) {
    std::ostringstream hexStream;
    hexStream << std::setfill('0');
    for (size_t i = 0; i < array.size(); ++i) {
        hexStream << std::hex << std::setw(2) << (int) array[i];
        if (formatted) {
            hexStream << (((i + 1) % 16 == 0) ? "\n" : " ");
        }
    }
    return hexStream.str();
}

inline void bytes_zeroize(VirgilByteArray& array) {
    size_t n = array.size();
    volatile unsigned char* p = const_cast<unsigned char*>(array.data());
    while (n--) { *p++ = 0; }
}

inline void string_zeroize(std::string& str) {
    size_t n = str.size();
    volatile char* p = const_cast<char*>(str.c_str());
    while (n--) { *p++ = '\0'; }
}

inline VirgilByteArray& bytes_append(VirgilByteArray& dst, const VirgilByteArray& src) {
    dst.insert(dst.end(), src.cbegin(), src.cend());
    return dst;
}

inline std::tuple<VirgilByteArray, VirgilByteArray> bytes_split(const VirgilByteArray& src, size_t pos) {
    return std::make_tuple(
            VirgilByteArray(src.cbegin(), src.cbegin() + pos),
            VirgilByteArray(src.cbegin() + pos, src.cend()));
}

inline std::tuple<VirgilByteArray, VirgilByteArray> bytes_split_half(const VirgilByteArray& src) {
    const auto halfPos = src.size() >> 1;
    return bytes_split(src, halfPos);
}

}}
#endif /* VIRGIL_BYTE_ARRAY_H */