BastionGuard::Activation::anonymous_namespace{activation.cpp} Namespace Reference

Functions
uint32_t	rotr (uint32_t value, unsigned int count)
std::string	sha256_hex (const std::string &input)
std::string	uppercase (std::string value)
std::string	lowercase (std::string value)
std::string	trim (const std::string &value)
std::string	normalize_engine_id (const std::string &value)
std::string	compact_key (const std::string &raw)
std::string	extract_activation_key (const std::string &raw)
std::string	compact_hex_machine_id (const std::string &raw)
std::string	collapse_spaces (const std::string &value)
std::string	canonical_serial (std::string value)
bool	all_zero_like (const std::string &value)
bool	is_placeholder_serial (const std::string &value)
std::string	read_first_valid_serial (const std::vector< std::string > &paths)
std::string	read_first_existing_file (const std::vector< std::string > &paths)
std::string	legacy_application_machine_id ()
int	b64url_value (char c)
std::optional< std::string >	base64url_decode (const std::string &input)
std::string	percent_decode (const std::string &value)
std::map< std::string, std::string >	parse_payload (const std::string &payload)
std::string	today_ymd ()
bool	is_valid_expiry (const std::string &expires)
bool	has_expired (const std::string &expires)
bool	is_running_as_root ()
std::string	user_config_dir ()
std::string	system_config_dir ()
std::string	user_activation_key_path ()
std::string	system_activation_key_path ()
std::string	preferred_activation_key_path_for_save ()
std::string	read_file_all (const std::string &path)
std::string	sign_payload_v1 (const std::string &payload)
std::string	sign_payload_v2 (const std::string &canonical_payload)
uint64_t	fnv1a64 (const std::string &input)
std::string	normalize_activation_code (std::string value)
std::string	group_activation_code (const std::string &compact)
std::string	field_or_empty (const std::map< std::string, std::string > &fields, const std::string &name)
std::string	code_payload_v3 (const std::map< std::string, std::string > &fields)
std::string	generate_activation_code_v3 (const std::string &canonical_payload)
std::map< std::string, std::string >	parse_key_block (const std::string &key)
std::string	canonical_v2_payload (const std::map< std::string, std::string > &fields)

Variables
constexpr std::string_view	kActivationSecret
constexpr std::string_view	kProductId = "BastionGuardRecoveryData"
constexpr std::string_view	kActivationEngineId = "supportterdonation"
constexpr std::string_view	kKeyPrefixV1 = "BGRD1"
constexpr std::string_view	kKeyPrefixV2 = "BGRD2"
constexpr std::string_view	kKeyPrefixV3 = "BGRD3"
constexpr std::string_view	kKeyBeginMarker = "-----BEGIN BASTIONGUARD ACTIVATION KEY-----"
constexpr std::string_view	kKeyEndMarker = "-----END BASTIONGUARD ACTIVATION KEY-----"

Function Documentation

all_zero_like()

bool BastionGuard::Activation::anonymous_namespace{activation.cpp}::all_zero_like

(

const std::string &

value

)

Definition at line 296 of file activation.cpp.

                                           {
    bool has_alnum = false;
    for (unsigned char c : value) {
        if (std::isalnum(c) == 0) continue;
        has_alnum = true;
        if (c != '0') return false;
    }
    return has_alnum;
}

References all_zero_like().

Referenced by all_zero_like(), and is_placeholder_serial().

b64url_value()

int BastionGuard::Activation::anonymous_namespace{activation.cpp}::b64url_value

(

char

c

)

Definition at line 375 of file activation.cpp.

                         {
    if (c >= 'A' && c <= 'Z') return c - 'A';
    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
    if (c >= '0' && c <= '9') return c - '0' + 52;
    if (c == '-' || c == '+') return 62;
    if (c == '_' || c == '/') return 63;
    return -1;
}

References b64url_value().

Referenced by b64url_value(), and base64url_decode().

base64url_decode()

std::optional< std::string > BastionGuard::Activation::anonymous_namespace{activation.cpp}::base64url_decode

(

const std::string &

input

)

Definition at line 384 of file activation.cpp.

                                                                {
    std::string output;
    int val = 0;
    int valb = -8;
 
    for (char c : input) {
        if (c == '=') break;
        const int decoded = b64url_value(c);
        if (decoded < 0) return std::nullopt;
        val = (val << 6) + decoded;
        valb += 6;
        if (valb >= 0) {
            output.push_back(static_cast<char>((val >> valb) & 0xff));
            valb -= 8;
        }
    }
 
    return output;
}

References b64url_value(), and base64url_decode().

Referenced by base64url_decode().

canonical_serial()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::canonical_serial

(

std::string

value

)

Definition at line 290 of file activation.cpp.

                                            {
    value = trim(value);
    value = collapse_spaces(value);
    return uppercase(value);
}

References canonical_serial(), collapse_spaces(), trim(), and uppercase().

Referenced by canonical_serial(), canonical_v2_payload(), code_payload_v3(), is_placeholder_serial(), and read_first_valid_serial().

canonical_v2_payload()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::canonical_v2_payload

(

const std::map< std::string, std::string > &

fields

)

Definition at line 650 of file activation.cpp.

                                                                           {
    const std::string product = trim(field_or_empty(fields, "PRODUCT"));
    const std::string engine = normalize_engine_id(field_or_empty(fields, "ENGINE"));
    const std::string machine = compact_hex_machine_id(field_or_empty(fields, "MACHINE"));
    const std::string motherboard = canonical_serial(field_or_empty(fields, "MOTHERBOARD"));
    const std::string owner = trim(field_or_empty(fields, "OWNER"));
    std::string edition = trim(field_or_empty(fields, "EDITION"));
    std::string expires = lowercase(trim(field_or_empty(fields, "EXPIRES")));
 
    if (edition.empty()) edition = "Donation";
    if (expires.empty()) expires = "never";
 
    std::ostringstream out;
    out << "product=" << product << "\n"
        << "engine=" << engine << "\n"
        << "machine=" << machine << "\n"
        << "motherboard=" << motherboard << "\n"
        << "owner=" << owner << "\n"
        << "edition=" << edition << "\n"
        << "expires=" << expires;
    return out.str();
}

References canonical_serial(), canonical_v2_payload(), compact_hex_machine_id(), field_or_empty(), lowercase(), normalize_engine_id(), and trim().

Referenced by canonical_v2_payload().

code_payload_v3()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::code_payload_v3

(

const std::map< std::string, std::string > &

fields

)

Definition at line 578 of file activation.cpp.

                                                                      {
    const std::string product = trim(field_or_empty(fields, "PRODUCT"));
    const std::string engine = normalize_engine_id(field_or_empty(fields, "ENGINE"));
    const std::string machine = compact_hex_machine_id(field_or_empty(fields, "MACHINE"));
    const std::string motherboard = canonical_serial(field_or_empty(fields, "MOTHERBOARD"));
    const std::string key_id = trim(field_or_empty(fields, "KEYID"));
    std::string edition = trim(field_or_empty(fields, "EDITION"));
    std::string expires = lowercase(trim(field_or_empty(fields, "EXPIRES")));
 
    if (edition.empty()) edition = "Donation";
    if (expires.empty()) expires = "never";
 
    std::ostringstream out;
    out << "product=" << product << "\n"
        << "engine=" << engine << "\n"
        << "machine=" << machine << "\n"
        << "motherboard=" << motherboard << "\n"
        << "edition=" << edition << "\n"
        << "expires=" << expires;
 
    // BGRD3.1: optional random KEYID. When present, it is part of the
    // activation code calculation so the same hardware can receive different
    // valid keys without making the readable BGRD3 block fragile.
    if (!key_id.empty()) {
        out << "\nkeyid=" << key_id;
    }
 
    return out.str();
}

References canonical_serial(), code_payload_v3(), compact_hex_machine_id(), field_or_empty(), lowercase(), normalize_engine_id(), and trim().

Referenced by code_payload_v3().

collapse_spaces()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::collapse_spaces

(

const std::string &

value

)

Definition at line 266 of file activation.cpp.

                                                  {
    std::string out;
    out.reserve(value.size());
    bool last_space = false;
 
    for (unsigned char c : value) {
        if (c == '\0') continue;
        if (std::isspace(c) != 0) {
            if (!last_space && !out.empty()) {
                out.push_back(' ');
            }
            last_space = true;
        } else {
            out.push_back(static_cast<char>(c));
            last_space = false;
        }
    }
 
    while (!out.empty() && out.back() == ' ') {
        out.pop_back();
    }
    return out;
}

References collapse_spaces().

Referenced by canonical_serial(), and collapse_spaces().

compact_hex_machine_id()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::compact_hex_machine_id

(

const std::string &

raw

)

Definition at line 255 of file activation.cpp.

                                                       {
    std::string out;
    out.reserve(raw.size());
    for (unsigned char c : raw) {
        if (std::isxdigit(c)) {
            out.push_back(static_cast<char>(std::toupper(c)));
        }
    }
    return out;
}

References compact_hex_machine_id().

Referenced by canonical_v2_payload(), code_payload_v3(), and compact_hex_machine_id().

compact_key()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::compact_key

(

const std::string &

raw

)

Definition at line 184 of file activation.cpp.

                                            {
    std::string out;
    out.reserve(raw.size());
    for (unsigned char c : raw) {
        if (!std::isspace(c)) out.push_back(static_cast<char>(c));
    }
    return out;
}

References compact_key().

Referenced by compact_key(), and extract_activation_key().

extract_activation_key()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::extract_activation_key

(

const std::string &

raw

)

Definition at line 193 of file activation.cpp.

                                                       {
    const std::string text = trim(raw);
    if (text.empty()) return {};
 
    const std::string begin_marker(kKeyBeginMarker);
    const std::string end_marker(kKeyEndMarker);
    const auto begin = text.find(begin_marker);
    if (begin != std::string::npos) {
        const auto end = text.find(end_marker, begin + begin_marker.size());
        if (end != std::string::npos) {
            return trim(text.substr(begin, end + end_marker.size() - begin));
        }
        return trim(text.substr(begin));
    }
 
    // BGRD2/BGRD3 can also be pasted without BEGIN/END markers. Keep the
    // multiline field block intact because validation is calculated from
    // field values, not from a compact one-line token.
    if (((text.find(std::string(kKeyPrefixV2)) != std::string::npos &&
          text.find("SIGNATURE=") != std::string::npos) ||
         (text.find(std::string(kKeyPrefixV3)) != std::string::npos &&
          text.find("CODE=") != std::string::npos))) {
        return text;
    }
 
    // Legacy BGRD1 support. Paste operations from GUI toolkits can include
    // invisible Unicode bytes or labels around the key. Keep only characters
    // valid in the BGRD1 token and extract exactly one
    // BGRD1.<payload>.<40-hex-signature> token.
    std::string filtered;
    filtered.reserve(raw.size());
    for (unsigned char c : raw) {
        if (std::isalnum(c) != 0 || c == '.' || c == '-' || c == '_') {
            filtered.push_back(static_cast<char>(c));
        }
    }
 
    const std::string prefix = std::string(kKeyPrefixV1) + ".";
    const auto start = filtered.find(prefix);
    if (start == std::string::npos) {
        return compact_key(raw);
    }
 
    const auto payload_dot = filtered.find('.', start + prefix.size());
    if (payload_dot == std::string::npos) {
        return filtered.substr(start);
    }
 
    const size_t sig_start = payload_dot + 1;
    size_t sig_end = sig_start;
    while (sig_end < filtered.size() && sig_end - sig_start < 40 &&
           std::isxdigit(static_cast<unsigned char>(filtered[sig_end])) != 0) {
        ++sig_end;
    }
 
    if (sig_end - sig_start == 40) {
        return filtered.substr(start, sig_end - start);
    }
 
    return filtered.substr(start);
}

References compact_key(), extract_activation_key(), kKeyBeginMarker, kKeyEndMarker, kKeyPrefixV1, kKeyPrefixV2, kKeyPrefixV3, and trim().

Referenced by extract_activation_key().

field_or_empty()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::field_or_empty	(	const std::map< std::string, std::string > &	fields,
		const std::string &	name )

Definition at line 573 of file activation.cpp.

                                                                                            {
    const auto it = fields.find(name);
    return it == fields.end() ? std::string{} : it->second;
}

References field_or_empty().

Referenced by canonical_v2_payload(), code_payload_v3(), and field_or_empty().

fnv1a64()

uint64_t BastionGuard::Activation::anonymous_namespace{activation.cpp}::fnv1a64

(

const std::string &

input

)

Definition at line 543 of file activation.cpp.

                                         {
    uint64_t hash = 14695981039346656037ULL;
    for (unsigned char c : input) {
        hash ^= static_cast<uint64_t>(c);
        hash *= 1099511628211ULL;
    }
    return hash;
}

References fnv1a64().

Referenced by fnv1a64(), and generate_activation_code_v3().

generate_activation_code_v3()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::generate_activation_code_v3

(

const std::string &

canonical_payload

)

Definition at line 608 of file activation.cpp.

                                                                          {
    static constexpr std::string_view alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
    const std::string material = std::string(kKeyPrefixV3) + "\n" + canonical_payload + "\n" + std::string(kActivationSecret);
 
    std::string compact;
    compact.reserve(25);
    for (int block = 0; block < 5; ++block) {
        uint64_t h = fnv1a64(material + "\nblock=" + std::to_string(block));
        for (int i = 0; i < 5; ++i) {
            const uint64_t mixed = h ^ (h >> 29U) ^ (h >> 47U);
            compact.push_back(alphabet[static_cast<size_t>(mixed & 31ULL)]);
            h = (h >> 5U) ^ (h << 17U) ^ (0x9E3779B97F4A7C15ULL + static_cast<uint64_t>(block * 131 + i));
        }
    }
 
    return group_activation_code(compact);
}

References fnv1a64(), generate_activation_code_v3(), group_activation_code(), kActivationSecret, and kKeyPrefixV3.

Referenced by generate_activation_code_v3().

group_activation_code()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::group_activation_code

(

const std::string &

compact

)

Definition at line 564 of file activation.cpp.

                                                          {
    std::string out;
    for (size_t i = 0; i < compact.size(); ++i) {
        if (i > 0 && i % 5 == 0) out.push_back('-');
        out.push_back(compact[i]);
    }
    return out;
}

References group_activation_code().

Referenced by generate_activation_code_v3(), and group_activation_code().

has_expired()

bool BastionGuard::Activation::anonymous_namespace{activation.cpp}::has_expired

(

const std::string &

expires

)

Definition at line 484 of file activation.cpp.

                                           {
    if (expires == "never") return false;
    if (!is_valid_expiry(expires)) return true;
    return expires < today_ymd();
}

References has_expired(), is_valid_expiry(), and today_ymd().

Referenced by has_expired().

is_placeholder_serial()

bool BastionGuard::Activation::anonymous_namespace{activation.cpp}::is_placeholder_serial

(

const std::string &

value

)

Definition at line 306 of file activation.cpp.

                                                   {
    const std::string serial = canonical_serial(value);
    if (serial.empty()) return true;
    if (all_zero_like(serial)) return true;
 
    static constexpr std::string_view placeholders[] = {
        "0",
        "00",
        "00000000",
        "0000000000000000",
        "00000000000000000000000000000000",
        "NONE",
        "UNKNOWN",
        "UNKNOWN SERIAL",
        "UNKNOWN SERIAL NUMBER",
        "NOT SPECIFIED",
        "NOT APPLICABLE",
        "N/A",
        "NA",
        "DEFAULT STRING",
        "SYSTEM SERIAL NUMBER",
        "BASE BOARD SERIAL NUMBER",
        "TO BE FILLED BY O.E.M.",
        "TO BE FILLED BY OEM"
    };
 
    for (std::string_view placeholder : placeholders) {
        if (serial == placeholder) return true;
    }
    return false;
}

References all_zero_like(), canonical_serial(), and is_placeholder_serial().

Referenced by is_placeholder_serial(), and read_first_valid_serial().

is_running_as_root()

bool BastionGuard::Activation::anonymous_namespace{activation.cpp}::is_running_as_root

(

)

Definition at line 490 of file activation.cpp.

                          {
    return ::geteuid() == 0;
}

References is_running_as_root().

Referenced by is_running_as_root(), and preferred_activation_key_path_for_save().

is_valid_expiry()

bool BastionGuard::Activation::anonymous_namespace{activation.cpp}::is_valid_expiry

(

const std::string &

expires

)

Definition at line 469 of file activation.cpp.

                                               {
    if (expires == "never") return true;
    if (expires.size() != 10) return false;
    return std::isdigit(static_cast<unsigned char>(expires[0])) &&
           std::isdigit(static_cast<unsigned char>(expires[1])) &&
           std::isdigit(static_cast<unsigned char>(expires[2])) &&
           std::isdigit(static_cast<unsigned char>(expires[3])) &&
           expires[4] == '-' &&
           std::isdigit(static_cast<unsigned char>(expires[5])) &&
           std::isdigit(static_cast<unsigned char>(expires[6])) &&
           expires[7] == '-' &&
           std::isdigit(static_cast<unsigned char>(expires[8])) &&
           std::isdigit(static_cast<unsigned char>(expires[9]));
}

References is_valid_expiry().

Referenced by has_expired(), and is_valid_expiry().

legacy_application_machine_id()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::legacy_application_machine_id

(

)

Definition at line 352 of file activation.cpp.

                                          {
    std::string seed = read_first_existing_file({
        "/etc/machine-id",
        "/var/lib/dbus/machine-id"
    });
 
    if (seed.empty()) {
        char hostname[256] = {};
        if (gethostname(hostname, sizeof(hostname) - 1) == 0) {
            seed = hostname;
        }
    }
 
    if (seed.empty()) {
        seed = "unknown-machine";
    }
 
    seed += "|";
    seed += kProductId;
 
    return uppercase(sha256_hex(seed)).substr(0, 16);
}

References kProductId, legacy_application_machine_id(), read_first_existing_file(), sha256_hex(), and uppercase().

Referenced by legacy_application_machine_id().

lowercase()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::lowercase

(

std::string

value

)

Definition at line 160 of file activation.cpp.

                                     {
    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
        return static_cast<char>(std::tolower(c));
    });
    return value;
}

References lowercase().

Referenced by canonical_v2_payload(), code_payload_v3(), lowercase(), and normalize_engine_id().

normalize_activation_code()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::normalize_activation_code

(

std::string

value

)

Definition at line 552 of file activation.cpp.

                                                     {
    value = uppercase(value);
    std::string out;
    out.reserve(value.size());
    for (unsigned char c : value) {
        if (std::isalnum(c) != 0) {
            out.push_back(static_cast<char>(c));
        }
    }
    return out;
}

References normalize_activation_code(), and uppercase().

Referenced by normalize_activation_code().

normalize_engine_id()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::normalize_engine_id

(

const std::string &

value

)

Definition at line 180 of file activation.cpp.

                                                      {
    return lowercase(trim(value));
}

References lowercase(), normalize_engine_id(), and trim().

Referenced by canonical_v2_payload(), code_payload_v3(), and normalize_engine_id().

parse_key_block()

std::map< std::string, std::string > BastionGuard::Activation::anonymous_namespace{activation.cpp}::parse_key_block

(

const std::string &

key

)

Definition at line 626 of file activation.cpp.

                                                                   {
    std::map<std::string, std::string> fields;
    std::stringstream ss(key);
    std::string line;
 
    while (std::getline(ss, line)) {
        line = trim(line);
        if (line.empty()) continue;
        if (line == kKeyBeginMarker || line == kKeyEndMarker) continue;
        if (line == kKeyPrefixV2 || line == kKeyPrefixV3) {
            fields["FORMAT"] = line;
            continue;
        }
 
        const auto eq = line.find('=');
        if (eq == std::string::npos) continue;
        std::string name = uppercase(trim(line.substr(0, eq)));
        std::string value = trim(line.substr(eq + 1));
        fields[name] = value;
    }
 
    return fields;
}

References kKeyBeginMarker, kKeyEndMarker, kKeyPrefixV2, kKeyPrefixV3, parse_key_block(), trim(), and uppercase().

Referenced by parse_key_block().

parse_payload()

std::map< std::string, std::string > BastionGuard::Activation::anonymous_namespace{activation.cpp}::parse_payload

(

const std::string &

payload

)

Definition at line 428 of file activation.cpp.

                                                                     {
    std::map<std::string, std::string> fields;
    std::stringstream ss(payload);
    std::string item;
 
    while (std::getline(ss, item, ';')) {
        const auto eq = item.find('=');
        if (eq == std::string::npos) continue;
        const std::string key = item.substr(0, eq);
        const std::string value = item.substr(eq + 1);
        fields[key] = percent_decode(value);
    }
 
    return fields;
}

References parse_payload(), and percent_decode().

Referenced by parse_payload().

percent_decode()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::percent_decode

(

const std::string &

value

)

Definition at line 404 of file activation.cpp.

                                                 {
    std::string out;
    out.reserve(value.size());
 
    for (size_t i = 0; i < value.size(); ++i) {
        if (value[i] == '%' && i + 2 < value.size()) {
            const char h1 = value[i + 1];
            const char h2 = value[i + 2];
            if (std::isxdigit(static_cast<unsigned char>(h1)) &&
                std::isxdigit(static_cast<unsigned char>(h2))) {
                const std::string hex{h1, h2};
                const char ch = static_cast<char>(std::strtol(hex.c_str(), nullptr, 16));
                out.push_back(ch);
                i += 2;
                continue;
            }
        }
        if (value[i] == '+') out.push_back(' ');
        else out.push_back(value[i]);
    }
 
    return out;
}

References percent_decode().

Referenced by parse_payload(), and percent_decode().

preferred_activation_key_path_for_save()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::preferred_activation_key_path_for_save

(

)

Definition at line 516 of file activation.cpp.

                                                   {
    // When the GUI is launched through pkexec/root, save a system-wide key so
    // the activation is not tied to /root/.config and survives future root runs.
    if (is_running_as_root()) {
        return system_activation_key_path();
    }
    return user_activation_key_path();
}

References is_running_as_root(), preferred_activation_key_path_for_save(), system_activation_key_path(), and user_activation_key_path().

Referenced by preferred_activation_key_path_for_save().

read_file_all()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::read_file_all

(

const std::string &

path

)

Definition at line 525 of file activation.cpp.

                                               {
    std::ifstream input(path, std::ios::binary);
    if (!input.is_open()) return {};
    std::ostringstream content;
    content << input.rdbuf();
    return content.str();
}

References read_file_all().

Referenced by read_file_all().

read_first_existing_file()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::read_first_existing_file

(

const std::vector< std::string > &

paths

)

Definition at line 444 of file activation.cpp.

                                                                      {
    for (const auto& path : paths) {
        std::ifstream input(path);
        if (!input.is_open()) continue;
        std::string line;
        std::getline(input, line);
        line = trim(line);
        if (!line.empty()) return line;
    }
    return {};
}

References read_first_existing_file(), and trim().

Referenced by legacy_application_machine_id(), and read_first_existing_file().

read_first_valid_serial()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::read_first_valid_serial

(

const std::vector< std::string > &

paths

)

Definition at line 338 of file activation.cpp.

                                                                     {
    for (const auto& path : paths) {
        std::ifstream input(path);
        if (!input.is_open()) continue;
        std::string line;
        std::getline(input, line);
        line = canonical_serial(line);
        if (!is_placeholder_serial(line)) return line;
    }
    return {};
}

References canonical_serial(), is_placeholder_serial(), and read_first_valid_serial().

Referenced by read_first_valid_serial().

rotr()

uint32_t BastionGuard::Activation::anonymous_namespace{activation.cpp}::rotr	(	uint32_t	value,
		unsigned int	count )

Definition at line 51 of file activation.cpp.

                                                  {
    return (value >> count) | (value << (32U - count));
}

References rotr().

Referenced by rotr(), and sha256_hex().

sha256_hex()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::sha256_hex

(

const std::string &

input

)

Definition at line 55 of file activation.cpp.

                                             {
    static constexpr std::array<uint32_t, 64> k = {
        0x428a2f98U, 0x71374491U, 0xb5c0fbcfU, 0xe9b5dba5U,
        0x3956c25bU, 0x59f111f1U, 0x923f82a4U, 0xab1c5ed5U,
        0xd807aa98U, 0x12835b01U, 0x243185beU, 0x550c7dc3U,
        0x72be5d74U, 0x80deb1feU, 0x9bdc06a7U, 0xc19bf174U,
        0xe49b69c1U, 0xefbe4786U, 0x0fc19dc6U, 0x240ca1ccU,
        0x2de92c6fU, 0x4a7484aaU, 0x5cb0a9dcU, 0x76f988daU,
        0x983e5152U, 0xa831c66dU, 0xb00327c8U, 0xbf597fc7U,
        0xc6e00bf3U, 0xd5a79147U, 0x06ca6351U, 0x14292967U,
        0x27b70a85U, 0x2e1b2138U, 0x4d2c6dfcU, 0x53380d13U,
        0x650a7354U, 0x766a0abbU, 0x81c2c92eU, 0x92722c85U,
        0xa2bfe8a1U, 0xa81a664bU, 0xc24b8b70U, 0xc76c51a3U,
        0xd192e819U, 0xd6990624U, 0xf40e3585U, 0x106aa070U,
        0x19a4c116U, 0x1e376c08U, 0x2748774cU, 0x34b0bcb5U,
        0x391c0cb3U, 0x4ed8aa4aU, 0x5b9cca4fU, 0x682e6ff3U,
        0x748f82eeU, 0x78a5636fU, 0x84c87814U, 0x8cc70208U,
        0x90befffaU, 0xa4506cebU, 0xbef9a3f7U, 0xc67178f2U
    };
 
    std::array<uint32_t, 8> h = {
        0x6a09e667U, 0xbb67ae85U, 0x3c6ef372U, 0xa54ff53aU,
        0x510e527fU, 0x9b05688cU, 0x1f83d9abU, 0x5be0cd19U
    };
 
    std::vector<uint8_t> msg(input.begin(), input.end());
    const uint64_t bit_len = static_cast<uint64_t>(msg.size()) * 8ULL;
 
    msg.push_back(0x80U);
    while ((msg.size() % 64U) != 56U) {
        msg.push_back(0x00U);
    }
 
    for (int i = 7; i >= 0; --i) {
        msg.push_back(static_cast<uint8_t>((bit_len >> (i * 8)) & 0xffU));
    }
 
    for (size_t offset = 0; offset < msg.size(); offset += 64) {
        std::array<uint32_t, 64> w{};
        for (size_t i = 0; i < 16; ++i) {
            const size_t j = offset + i * 4;
            w[i] = (static_cast<uint32_t>(msg[j]) << 24U) |
                   (static_cast<uint32_t>(msg[j + 1]) << 16U) |
                   (static_cast<uint32_t>(msg[j + 2]) << 8U) |
                   static_cast<uint32_t>(msg[j + 3]);
        }
 
        for (size_t i = 16; i < 64; ++i) {
            const uint32_t s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3U);
            const uint32_t s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10U);
            w[i] = w[i - 16] + s0 + w[i - 7] + s1;
        }
 
        uint32_t a = h[0];
        uint32_t b = h[1];
        uint32_t c = h[2];
        uint32_t d = h[3];
        uint32_t e = h[4];
        uint32_t f = h[5];
        uint32_t g = h[6];
        uint32_t hh = h[7];
 
        for (size_t i = 0; i < 64; ++i) {
            const uint32_t s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
            const uint32_t ch = (e & f) ^ ((~e) & g);
            const uint32_t temp1 = hh + s1 + ch + k[i] + w[i];
            const uint32_t s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
            const uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
            const uint32_t temp2 = s0 + maj;
 
            hh = g;
            g = f;
            f = e;
            e = d + temp1;
            d = c;
            c = b;
            b = a;
            a = temp1 + temp2;
        }
 
        h[0] += a;
        h[1] += b;
        h[2] += c;
        h[3] += d;
        h[4] += e;
        h[5] += f;
        h[6] += g;
        h[7] += hh;
    }
 
    std::ostringstream out;
    out << std::hex << std::setfill('0');
    for (uint32_t part : h) {
        out << std::setw(8) << part;
    }
    return out.str();
}

References rotr(), and sha256_hex().

Referenced by legacy_application_machine_id(), sha256_hex(), sign_payload_v1(), and sign_payload_v2().

sign_payload_v1()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::sign_payload_v1

(

const std::string &

payload

)

Definition at line 533 of file activation.cpp.

                                                    {
    const std::string input = std::string(kKeyPrefixV1) + "|" + payload + "|" + std::string(kActivationSecret);
    return uppercase(sha256_hex(input)).substr(0, 40);
}

References kActivationSecret, kKeyPrefixV1, sha256_hex(), sign_payload_v1(), and uppercase().

Referenced by sign_payload_v1().

sign_payload_v2()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::sign_payload_v2

(

const std::string &

canonical_payload

)

Definition at line 538 of file activation.cpp.

                                                              {
    const std::string input = std::string(kKeyPrefixV2) + "\n" + canonical_payload + "\n" + std::string(kActivationSecret);
    return uppercase(sha256_hex(input)).substr(0, 40);
}

References kActivationSecret, kKeyPrefixV2, sha256_hex(), sign_payload_v2(), and uppercase().

Referenced by sign_payload_v2().

system_activation_key_path()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::system_activation_key_path

(

)

Definition at line 512 of file activation.cpp.

                                       {
    return (std::filesystem::path(system_config_dir()) / "activation.key").string();
}

References system_activation_key_path(), and system_config_dir().

Referenced by preferred_activation_key_path_for_save(), and system_activation_key_path().

system_config_dir()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::system_config_dir

(

)

Definition at line 504 of file activation.cpp.

                              {
    return "/etc/bastionguard-recovery-data";
}

References system_config_dir().

Referenced by system_activation_key_path(), and system_config_dir().

today_ymd()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::today_ymd

(

)

Definition at line 456 of file activation.cpp.

                      {
    const std::time_t now = std::time(nullptr);
    std::tm tm{};
#if defined(_POSIX_VERSION)
    localtime_r(&now, &tm);
#else
    tm = *std::localtime(&now);
#endif
    char buffer[16] = {};
    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d", &tm);
    return buffer;
}

References today_ymd().

Referenced by has_expired(), and today_ymd().

trim()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::trim

(

const std::string &

value

)

Definition at line 167 of file activation.cpp.

                                       {
    const auto begin = std::find_if_not(value.begin(), value.end(), [](unsigned char c) {
        return std::isspace(c) != 0;
    });
    if (begin == value.end()) return {};
 
    const auto end = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char c) {
        return std::isspace(c) != 0;
    }).base();
 
    return std::string(begin, end);
}

References trim().

Referenced by canonical_serial(), canonical_v2_payload(), code_payload_v3(), extract_activation_key(), normalize_engine_id(), parse_key_block(), read_first_existing_file(), and trim().

uppercase()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::uppercase

(

std::string

value

)

Definition at line 153 of file activation.cpp.

                                     {
    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
        return static_cast<char>(std::toupper(c));
    });
    return value;
}

References uppercase().

Referenced by canonical_serial(), legacy_application_machine_id(), normalize_activation_code(), parse_key_block(), sign_payload_v1(), sign_payload_v2(), and uppercase().

user_activation_key_path()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::user_activation_key_path

(

)

Definition at line 508 of file activation.cpp.

                                     {
    return (std::filesystem::path(user_config_dir()) / "activation.key").string();
}

References user_activation_key_path(), and user_config_dir().

Referenced by preferred_activation_key_path_for_save(), and user_activation_key_path().

user_config_dir()

std::string BastionGuard::Activation::anonymous_namespace{activation.cpp}::user_config_dir

(

)

Definition at line 494 of file activation.cpp.

                            {
    if (const char* xdg = std::getenv("XDG_CONFIG_HOME"); xdg && *xdg) {
        return (std::filesystem::path(xdg) / "bastionguard-recovery-data").string();
    }
    if (const char* home = std::getenv("HOME"); home && *home) {
        return (std::filesystem::path(home) / ".config" / "bastionguard-recovery-data").string();
    }
    return ".";
}

References user_config_dir().

Referenced by user_activation_key_path(), and user_config_dir().

Variable Documentation

kActivationEngineId

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kActivationEngineId = "supportterdonation"

constexpr

Definition at line 44 of file activation.cpp.

kActivationSecret

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kActivationSecret

constexpr

Initial value:

                                         =
"BastionGuard-Recovery-Data-2026-Calogero-Scarna-Donation-Activation-v1"

Definition at line 37 of file activation.cpp.

Referenced by generate_activation_code_v3(), sign_payload_v1(), and sign_payload_v2().

kKeyBeginMarker

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kKeyBeginMarker = "-----BEGIN BASTIONGUARD ACTIVATION KEY-----"

constexpr

Definition at line 48 of file activation.cpp.

Referenced by extract_activation_key(), and parse_key_block().

kKeyEndMarker

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kKeyEndMarker = "-----END BASTIONGUARD ACTIVATION KEY-----"

constexpr

Definition at line 49 of file activation.cpp.

Referenced by extract_activation_key(), and parse_key_block().

kKeyPrefixV1

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kKeyPrefixV1 = "BGRD1"

constexpr

Definition at line 45 of file activation.cpp.

Referenced by extract_activation_key(), and sign_payload_v1().

kKeyPrefixV2

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kKeyPrefixV2 = "BGRD2"

constexpr

Definition at line 46 of file activation.cpp.

Referenced by extract_activation_key(), parse_key_block(), and sign_payload_v2().

kKeyPrefixV3

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kKeyPrefixV3 = "BGRD3"

constexpr

Definition at line 47 of file activation.cpp.

Referenced by extract_activation_key(), generate_activation_code_v3(), and parse_key_block().

kProductId

std::string_view BastionGuard::Activation::anonymous_namespace{activation.cpp}::kProductId = "BastionGuardRecoveryData"

constexpr

Definition at line 40 of file activation.cpp.

Referenced by legacy_application_machine_id().