kcenon::pacs::security::detail Namespace Reference

Functions
std::string	base64_encode (const std::uint8_t *data, std::size_t size)
	Standard base64 encode (no line breaks)
bool	base64_decode (const std::string &in, std::vector< std::uint8_t > &out)
	Standard base64 decode; returns false on malformed input.
bool	hex_decode (const std::string &in, std::uint8_t *out, std::size_t out_size)
	Hex decode (lowercase or uppercase); returns false on malformed input.
bool	constant_time_equal (const std::uint8_t *a, const std::uint8_t *b, std::size_t n) noexcept
	Constant-time equality on byte buffers of equal length.

Function Documentation

base64_decode()

bool kcenon::pacs::security::detail::base64_decode ( const std::string & in, std::vector< std::uint8_t > & out )

nodiscard

Standard base64 decode; returns false on malformed input.

Definition at line 89 of file audit_log_cipher.cpp.

                                                                    {
    if (in.size() % 4 != 0) return false;
    out.clear();
    out.reserve((in.size() / 4) * 3);
 
    for (std::size_t i = 0; i < in.size(); i += 4) {
        const char c0 = in[i];
        const char c1 = in[i + 1];
        const char c2 = in[i + 2];
        const char c3 = in[i + 3];
 
        const int v0 = base64_value(c0);
        const int v1 = base64_value(c1);
        if (v0 < 0 || v1 < 0) return false;
 
        const std::uint32_t b0 = static_cast<std::uint32_t>(v0);
        const std::uint32_t b1 = static_cast<std::uint32_t>(v1);
 
        out.push_back(static_cast<std::uint8_t>((b0 << 2) | (b1 >> 4)));
 
        if (c2 == '=') {
            if (c3 != '=') return false;
            if (i + 4 != in.size()) return false;
            continue;
        }
        const int v2 = base64_value(c2);
        if (v2 < 0) return false;
        const std::uint32_t b2 = static_cast<std::uint32_t>(v2);
 
        out.push_back(static_cast<std::uint8_t>(((b1 & 0xF) << 4) | (b2 >> 2)));
 
        if (c3 == '=') {
            if (i + 4 != in.size()) return false;
            continue;
        }
        const int v3 = base64_value(c3);
        if (v3 < 0) return false;
        const std::uint32_t b3 = static_cast<std::uint32_t>(v3);
        out.push_back(static_cast<std::uint8_t>(((b2 & 0x3) << 6) | b3));
    }
    return true;
}

References out.

Referenced by kcenon::pacs::security::audit_key_manager::decode_key().

Here is the caller graph for this function:

base64_encode()

std::string kcenon::pacs::security::detail::base64_encode ( const std::uint8_t * data, std::size_t size )

nodiscard

Standard base64 encode (no line breaks)

Definition at line 56 of file audit_log_cipher.cpp.

                                                                {
    std::string out;
    out.reserve(((size + 2) / 3) * 4);
 
    std::size_t i = 0;
    for (; i + 3 <= size; i += 3) {
        std::uint32_t v = (static_cast<std::uint32_t>(data[i]) << 16) |
                          (static_cast<std::uint32_t>(data[i + 1]) << 8) |
                           static_cast<std::uint32_t>(data[i + 2]);
        out.push_back(kBase64Alphabet[(v >> 18) & 0x3F]);
        out.push_back(kBase64Alphabet[(v >> 12) & 0x3F]);
        out.push_back(kBase64Alphabet[(v >> 6) & 0x3F]);
        out.push_back(kBase64Alphabet[v & 0x3F]);
    }
 
    const std::size_t rem = size - i;
    if (rem == 1) {
        std::uint32_t v = static_cast<std::uint32_t>(data[i]) << 16;
        out.push_back(kBase64Alphabet[(v >> 18) & 0x3F]);
        out.push_back(kBase64Alphabet[(v >> 12) & 0x3F]);
        out.push_back('=');
        out.push_back('=');
    } else if (rem == 2) {
        std::uint32_t v = (static_cast<std::uint32_t>(data[i]) << 16) |
                          (static_cast<std::uint32_t>(data[i + 1]) << 8);
        out.push_back(kBase64Alphabet[(v >> 18) & 0x3F]);
        out.push_back(kBase64Alphabet[(v >> 12) & 0x3F]);
        out.push_back(kBase64Alphabet[(v >> 6) & 0x3F]);
        out.push_back('=');
    }
    return out;
}

References out.

constant_time_equal()

bool kcenon::pacs::security::detail::constant_time_equal ( const std::uint8_t * a, const std::uint8_t * b, std::size_t n )

nodiscardnoexcept

Constant-time equality on byte buffers of equal length.

Definition at line 145 of file audit_log_cipher.cpp.

                                               {
    std::uint8_t diff = 0;
    for (std::size_t i = 0; i < n; ++i) {
        diff |= static_cast<std::uint8_t>(a[i] ^ b[i]);
    }
    return diff == 0;
}

hex_decode()

bool kcenon::pacs::security::detail::hex_decode ( const std::string & in, std::uint8_t * out, std::size_t out_size )

nodiscard

Hex decode (lowercase or uppercase); returns false on malformed input.

Definition at line 132 of file audit_log_cipher.cpp.

                                    {
    if (in.size() != out_size * 2) return false;
    for (std::size_t i = 0; i < out_size; ++i) {
        const int hi = hex_value(in[2 * i]);
        const int lo = hex_value(in[2 * i + 1]);
        if (hi < 0 || lo < 0) return false;
        out[i] = static_cast<std::uint8_t>((hi << 4) | lo);
    }
    return true;
}

References out.

Referenced by kcenon::pacs::security::audit_key_manager::decode_key().

Here is the caller graph for this function: