Integration guides

C++ client SDK

Complete guide to integrating the Vaultix C++ client library into your application.

Features

Two authentication methods (key and username/password)
Automatic HWID detection (Windows & Linux)
Encrypted file downloads with AES-256-GCM
Folder downloads (ZIP archives)
Product variable fetching
Subscription status checking
Token refresh support
Debug mode for troubleshooting

Installation

Include the following files in your C++ project:

VaultixClient.hDownloadVaultixClient.cppDownload

Requirements

Dependency	Used for
libcurl	HTTP requests
OpenSSL	AES-256-GCM decryption

Basic setup

C++Copy

#include "VaultixClient.h"
#include <iostream>

int main() {
    // Initialize client
    Vaultix::VaultixClient client("https://vaultix.cc/api");

    // Enable debug mode (optional)
    client.SetDebugMode(true);

    // Set your app's API key
    client.SetApiKey("ap_your_api_key_here");

    // End-to-end encryption: the SDK key from App Settings
    client.SetContentKey("vxk_your_app_key");

    // Your code here...

    return 0;
}

Usage examples

Authentication method 1: key-based

Users authenticate with a unique key (e.g., MYAPP-1234-5678-ABCD-EFGH).

C++Copy

std::string userKey;
std::cout << "Enter your key: ";
std::cin >> userKey;

if (client.AuthenticateWithKey(userKey)) {
    std::cout << "Authentication successful!" << std::endl;

    auto session = client.GetCurrentSession();
    std::cout << "App ID: " << session.appId << std::endl;
    std::cout << "Token expires: " << session.tokenExpiry << std::endl;

    // User is now authenticated - proceed with your app logic
} else {
    std::cout << "Authentication failed: " << client.GetLastError() << std::endl;
}

Authentication method 2: username and password

Traditional login with username/email and password.

C++Copy

std::string username, password;
std::cout << "Username: ";
std::cin >> username;
std::cout << "Password: ";
std::cin >> password;

if (client.AuthenticateWithUsername(username, password)) {
    std::cout << "Authentication successful!" << std::endl;

    auto session = client.GetCurrentSession();
    std::cout << "Welcome, " << username << "!" << std::endl;
    std::cout << "App ID: " << session.appId << std::endl;

    // User is now authenticated
} else {
    std::cout << "Login failed: " << client.GetLastError() << std::endl;
}

Downloading files

Download encrypted files from a product. Files are automatically decrypted.

C++Copy

std::string productId = "your-product-id";
std::string fileName = "update.exe";
std::string outputPath = "./update.exe";

if (client.DownloadFile(productId, fileName, outputPath)) {
    std::cout << "File downloaded successfully!" << std::endl;
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

// Download to memory instead of file
auto fileData = client.DownloadFileToMemory(productId, fileName);
if (!fileData.empty()) {
    std::cout << "Downloaded " << fileData.size() << " bytes" << std::endl;
    // Use fileData...
}

Downloading folders

Download entire folders as encrypted ZIP archives.

C++Copy

std::string productId = "your-product-id";
std::string folderName = "Release";
std::string outputPath = "./Release.zip";

if (client.DownloadFolder(productId, folderName, outputPath)) {
    std::cout << "Folder downloaded successfully!" << std::endl;
    // Extract the ZIP file...
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

Fetching product variables

Get configuration variables set for a product (e.g., version numbers, feature flags).

C++Copy

auto variables = client.GetProductVariables(productId);
if (!variables.empty()) {
    std::cout << "Product Variables:" << std::endl;
    for (const auto& [name, value] : variables) {
        std::cout << "  " << name << " = " << value << std::endl;
    }
}

// Example output:
//   VERSION = 1.2.3
//   FEATURE_X_ENABLED = true
//   API_ENDPOINT = https://api.example.com

Checking subscription status

Verify the user’s subscription to a specific product.

C++Copy

auto subscription = client.GetUserSubscriptionByProduct(productId);

if (!subscription.subscriptionId.empty()) {
    std::cout << "Subscription Status: " << subscription.status << std::endl;
    std::cout << "Expires At: "
              << (subscription.expiresAt.empty() ? "Lifetime" : subscription.expiresAt)
              << std::endl;
    std::cout << "Is Paused: " << (subscription.isPaused ? "Yes" : "No") << std::endl;

    if (subscription.status == "active" && !subscription.isPaused) {
        // User has valid subscription
        std::cout << "Access granted!" << std::endl;
    }
} else {
    std::cout << "No subscription found for this product" << std::endl;
}

Complete example

main.cppC++Copy

#include "VaultixClient.h"
#include <iostream>

int main() {
    // Initialize client
    Vaultix::VaultixClient client("https://vaultix.cc/api");
    client.SetDebugMode(false);
    client.SetApiKey("ap_your_api_key_here");
    client.SetContentKey("vxk_your_app_key");  // decrypts end-to-end encrypted downloads

    // Authenticate
    std::string userKey;
    std::cout << "Enter your key: ";
    std::cin >> userKey;

    if (!client.AuthenticateWithKey(userKey)) {
        std::cout << "Authentication failed!" << std::endl;
        return 1;
    }

    std::cout << "Authenticated successfully!" << std::endl;

    // Define product and file
    std::string productId = "your-product-id";

    // Check subscription
    auto subscription = client.GetUserSubscriptionByProduct(productId);
    if (subscription.subscriptionId.empty()) {
        std::cout << "No subscription found" << std::endl;
        return 1;
    }

    if (subscription.status != "active" || subscription.isPaused) {
        std::cout << "Subscription is not active" << std::endl;
        return 1;
    }

    // Get variables
    auto vars = client.GetProductVariables(productId);
    for (const auto& [name, value] : vars) {
        std::cout << name << " = " << value << std::endl;
    }

    // Download file
    if (client.DownloadFile(productId, "update.exe", "./update.exe")) {
        std::cout << "File downloaded!" << std::endl;
    }

    // Clean up
    client.EndSession();

    return 0;
}

Security notes

The API key is cleared from memory after authentication using ClearApiKey()
All file downloads are encrypted with AES-256-GCM, and a download that arrives without its encryption key is rejected
Every server response is signed by Vaultix and verified by the client, so a fake or tampered server can't answer for it
The device clock must be within 10 minutes of the real time, or responses are rejected
HWID is automatically detected and sent with authentication
Session tokens automatically expire and can be refreshed

Function reference

Every public method of the client, grouped by task.

Authentication

AuthenticateWithKey()
AuthenticateWithUsernamePassword()
RefreshToken()
TryAutoLogin()
ClearAutoLoginToken()
EndSession()
IsSessionValid()
IsTokenExpired()
GetCurrentSession()

Products and subscriptions

GetProductVariables()
GetProductStatus()
GetProductNews()
GetUserProducts()
HasProductAccess()
GetUserSubscriptionByProduct()
GetUserSubscription()

Files and folders

DownloadFile()
DownloadFileToMemory()
GetFileInfo()
StreamFile()
DownloadFolder()
GetFolderInfo()
DownloadFolderToMemory()
GetFileList()
IsValidFileHash()
GetFolderList()

Encryption

DecryptFile()
DecryptData()

Configuration

SetApiKey()
ClearApiKey()
SetContentKey()
GetContentKeyFingerprint()
SetDebugMode()
SetSSLVerify()
GetLastError()

Security

SetRequireSignedResponses()
SetResponseClockSkewTolerance()
EnableCertificatePinning()
DisableCertificatePinning()
EnableOCSPCheck()
SetMinTlsVersion()
EnableRequestSigning()
DisableRequestSigning()

Authentication

AuthenticateWithKey()

Authenticate a user using a unique key.

Declaration

bool AuthenticateWithKey(const std::string& key)

Parameters

keystring: The user's unique authentication key

Return value

true: Authentication successful
false: Authentication failed (check GetLastError() for details)

Discussion

Authenticates an app user using their unique key. This is the recommended authentication method for most applications as it doesn't require storing passwords. The key is tied to the user's hardware ID (HWID) for additional security.

ExampleC++Copy

VaultixClient client("https://vaultix.cc/api");
client.SetApiKey("ap_your_api_key");

if (client.AuthenticateWithKey("user_abc123_key")) {
    std::cout << "Authenticated successfully!" << std::endl;
} else {
    std::cout << "Authentication failed: " << client.GetLastError() << std::endl;
}

AuthenticateWithUsernamePassword()

Authenticate a user using username and password.

Declaration

bool AuthenticateWithUsernamePassword(const std::string& username, const std::string& password)

Parameters

usernamestring: The user's username
passwordstring: The user's password

Return value

true: Authentication successful
false: Authentication failed (check GetLastError() for details)

Discussion

Authenticates an app user using their username and password combination. The password is sent over HTTPS (encrypted in transit). After successful authentication, a session token is stored for subsequent API calls.

ExampleC++Copy

VaultixClient client("https://vaultix.cc/api");
client.SetApiKey("ap_your_api_key");

if (client.AuthenticateWithUsernamePassword("john_doe", "SecurePass123!")) {
    std::cout << "Logged in as john_doe" << std::endl;
} else {
    std::cout << "Login failed: " << client.GetLastError() << std::endl;
}

RefreshToken()

Refresh an expired authentication token.

Declaration

bool RefreshToken()

Discussion

Refreshes the current authentication token when it expires. Tokens typically expire after 5 minutes. You should call this function if you receive a 401 Unauthorized error during API calls.

ExampleC++Copy

// After initial authentication
client.AuthenticateWithKey("user_key");

// ... time passes (token expires) ...

// Try to download file - fails with 401
if (!client.DownloadFile("product_id", "file.dll", "./output.dll")) {
    // Token might be expired, try refreshing
    if (client.RefreshToken()) {
        std::cout << "Token refreshed, retrying download..." << std::endl;
        client.DownloadFile("product_id", "file.dll", "./output.dll");
    }
}

TryAutoLogin()

Attempt to automatically log in using a persistent token stored locally.

Declaration

bool TryAutoLogin()

Return value

true: Auto-login successful, session is now active
false: Auto-login failed (no persistent token found, token invalid, or server error)

Discussion

Attempts to automatically authenticate the user using a persistent token that was saved during a previous successful authentication. The token is stored locally and sent to the server along with the current hardware ID (HWID) for validation. If successful, the session is initialized without requiring the user to enter credentials again. This is useful for applications that want to provide a "remember me" feature. If the token is invalid or expired, it will be automatically deleted.

ExampleC++Copy

// On application startup, try auto-login first
if (client.TryAutoLogin()) {
    std::cout << "Auto-login successful!" << std::endl;
    // User is already authenticated, proceed with app logic
} else {
    std::cout << "Auto-login failed, requesting credentials..." << std::endl;
    // Prompt user for key or username/password
    std::string userKey;
    std::cout << "Enter your key: ";
    std::cin >> userKey;
    client.AuthenticateWithKey(userKey);
}

ClearAutoLoginToken()

Clear the persistent auto-login token from both local storage and the server.

Declaration

void ClearAutoLoginToken()

Discussion

Clears the persistent auto-login token that was saved during authentication. This function both deletes the local token file and notifies the server to revoke the token. After calling this function, the user will need to enter their credentials again on the next login attempt. Use this when implementing a "logout" or "forget me" feature, or when you want to force re-authentication for security reasons. Note that EndSession() does not clear the persistent token - you must call this function explicitly to clear it.

ExampleC++Copy

// User wants to logout and clear auto-login
client.ClearAutoLoginToken();  // Clear persistent token
client.EndSession();  // End current session
std::cout << "Logged out and auto-login disabled" << std::endl;

// Next time the app starts, TryAutoLogin() will fail
// and user will need to enter credentials again

EndSession()

End the current session and clear authentication.

Declaration

void EndSession()

Discussion

Ends the current session by logging out the user and clearing the session token and user information from memory. After calling this function, you'll need to authenticate again to make API calls.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Use the client...
client.DownloadFile("product_id", "file.dll", "./output.dll");

// Done - end session
client.EndSession();
std::cout << "Session ended successfully" << std::endl;

IsSessionValid()

Check if the current session is valid.

Declaration

bool IsSessionValid() const

Discussion

Returns whether the current session is valid. A session is valid if the user has successfully authenticated and the session hasn't been ended.

IsTokenExpired()

Check if the authentication token has expired.

Declaration

bool IsTokenExpired() const

Discussion

Checks if the current authentication token has expired. Tokens typically expire after 5 minutes. Use this before making API calls to determine if you need to refresh the token.

GetCurrentSession()

Get the current session information.

Declaration

Session GetCurrentSession() const

Discussion

Returns a Session struct containing information about the current session, including HWID, session token, app ID, app user information, and token expiry time.

Products and subscriptions

GetProductVariables()

Fetch variables associated with a product.

Declaration

std::map<std::string, std::string> GetProductVariables(const std::string& productId)

Discussion

Retrieves all variables associated with a specific product. Variables are key-value pairs you can configure in the Vaultix dashboard to store configuration data, version numbers, feature flags, etc.

ExampleC++Copy

// Authenticate first
client.AuthenticateWithKey("user_key");

// Get product variables
auto vars = client.GetProductVariables("prod_abc123");

if (!vars.empty()) {
    std::cout << "Product Variables:" << std::endl;
    for (const auto& [key, value] : vars) {
        std::cout << "  " << key << " = " << value << std::endl;
    }
} else {
    std::cout << "Error: " << client.GetLastError() << std::endl;
}

GetProductStatus()

Get status information for a product (e.g., maintenance mode, updates available).

Declaration

bool GetProductStatus(const std::string& productId, ProductStatusInfo& statusInfo)

Parameters

productIdstring: The ID of the product
statusInfoProductStatusInfo&: Reference to a ProductStatusInfo struct that will be populated with status information

Discussion

Retrieves status information for a product, such as maintenance mode status, update availability, or other status messages. The statusInfo struct contains fields: hasStatus, name, color, and action.

GetProductNews()

Get news/announcements for a product.

Declaration

bool GetProductNews(const std::string& productId, ProductNewsInfo& newsInfo)

Parameters

productIdstring: The ID of the product
newsInfoProductNewsInfo&: Reference to a ProductNewsInfo struct that will be populated with news information

Discussion

Retrieves news and announcements for a product. The newsInfo struct contains fields: hasNews, headline, content, and updatedAt. Use this to display product updates or announcements to users.

GetUserProducts()

Get all products the current user has access to.

Declaration

std::vector<std::map<std::string, std::string>> GetUserProducts()

Return value

std::vector<std::map<std::string, std::string>>: A vector of maps, where each map contains product information (id, name, description, appId, status, fileCount, subscriptionsCount)

Returns an empty vector on failure (check GetLastError() for details)

Discussion

Retrieves a list of all products that the currently authenticated user has access to. Each product is returned as a map containing product metadata such as ID, name, description, and statistics.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Get all user products
auto products = client.GetUserProducts();

if (!products.empty()) {
    std::cout << "User has access to " << products.size() << " products:" << std::endl;
    for (const auto& product : products) {
        std::cout << "  - " << product.at("name") << " (ID: " << product.at("id") << ")" << std::endl;
        std::cout << "    Status: " << product.at("status") << std::endl;
        std::cout << "    Files: " << product.at("fileCount") << std::endl;
    }
} else {
    std::cout << "No products found: " << client.GetLastError() << std::endl;
}

HasProductAccess()

Check if the current user has access to a specific product.

Declaration

bool HasProductAccess(const std::string& productId) const

Parameters

productIdstring: The ID of the product to check access for

Return value

true: User has access to the product
false: User does not have access or session is invalid

Discussion

Checks if the currently authenticated user has access to a specific product. This is determined by checking if the product ID is in the user's subscription list. If the user has no subscriptions (empty list), access is granted to all products.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Check product access
if (client.HasProductAccess("prod_abc123")) {
    std::cout << "User has access to this product" << std::endl;
    // Proceed with product operations...
} else {
    std::cout << "User does not have access to this product" << std::endl;
}

GetUserSubscriptionByProduct()

Get user's subscription details for a specific product.

Declaration

Subscription GetUserSubscriptionByProduct(const std::string& productId)

Discussion

Retrieves the current user's subscription information for a specific product, including status, expiry date, download count, and pause state.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Get subscription
Subscription sub = client.GetUserSubscriptionByProduct("prod_abc123");

if (!sub.subscriptionId.empty()) {
    std::cout << "Subscription Status: " << sub.status << std::endl;
    std::cout << "Expires: " << sub.expiresAt << std::endl;
    std::cout << "Downloads: " << sub.downloads << std::endl;
    std::cout << "Paused: " << (sub.isPaused ? "Yes" : "No") << std::endl;

    // Check if active
    if (sub.status == "active" && !sub.isPaused) {
        std::cout << "Subscription is active!" << std::endl;
    }
} else {
    std::cout << "No subscription found: " << client.GetLastError() << std::endl;
}

GetUserSubscription()

Get user's subscription by subscription ID.

Declaration

Subscription GetUserSubscription(const std::string& subscriptionId)

Discussion

Retrieves subscription details by subscription ID. Use this when you already know the subscription ID (e.g., stored from a previous call).

Files and folders

DownloadFile()

Download and decrypt a file from a product.

Declaration

bool DownloadFile(const std::string& productId,
                  const std::string& fileName,
                  const std::string& outputPath)

Discussion

Downloads an encrypted file from the specified product, automatically decrypts it using AES-256-GCM, and saves it to the specified output path. The file is streamed during download for memory efficiency.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Download file
if (client.DownloadFile("prod_abc123", "game.exe", "./game.exe")) {
    std::cout << "File downloaded successfully!" << std::endl;
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

DownloadFileToMemory()

Download and decrypt a file from a product into memory.

Declaration

std::vector<uint8_t> DownloadFileToMemory(const std::string& productId,
                                    const std::string& fileName)

Parameters

productIdstring: The ID of the product containing the file
fileNamestring: The name of the file to download

Return value

std::vector<uint8_t>: The decrypted file data as bytes

Returns an empty vector on failure (check GetLastError() for details)

Discussion

Downloads an encrypted file from the specified product, automatically decrypts it using AES-256-GCM, and returns the decrypted data as a byte vector in memory. This is useful when you need to process the file data without writing it to disk, or when you want to load the file directly into memory for immediate use.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Download file to memory
auto fileData = client.DownloadFileToMemory("prod_abc123", "config.json");

if (!fileData.empty()) {
    std::cout << "Downloaded " << fileData.size() << " bytes" << std::endl;
    
    // Process the data in memory
    std::string content(fileData.begin(), fileData.end());
    std::cout << "File content: " << content << std::endl;
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

GetFileInfo()

Get metadata about a specific file in a product.

Declaration

FileInfo GetFileInfo(const std::string& productId, const std::string& fileName)

Parameters

productIdstring: The ID of the product containing the file
fileNamestring: The name of the file

Return value

FileInfo: A struct containing file metadata (id, name, size, encrypted, downloads, etc.)

Returns an empty FileInfo struct on failure (check GetLastError() for details)

Discussion

Retrieves detailed information about a specific file, including its size, encryption status, download count, and upload timestamp. Use this to check if a file exists and get its properties before downloading.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Get file info
FileInfo fileInfo = client.GetFileInfo("prod_abc123", "update.exe");

if (!fileInfo.id.empty()) {
    std::cout << "File: " << fileInfo.name << std::endl;
    std::cout << "Size: " << fileInfo.size << " bytes" << std::endl;
    std::cout << "Encrypted: " << (fileInfo.encrypted ? "Yes" : "No") << std::endl;
    std::cout << "Downloads: " << fileInfo.downloads << std::endl;
} else {
    std::cout << "File not found: " << client.GetLastError() << std::endl;
}

StreamFile()

Download and stream a file in chunks using a callback function.

Declaration

bool StreamFile(const std::string& productId,
                  const std::string& fileName,
                  std::function<void(const std::vector<uint8_t>&, size_t, size_t)> callback)

Parameters

productIdstring: The ID of the product containing the file
fileNamestring: The name of the file to download
callbackfunction: A callback function that receives chunks of data. Parameters: (chunk data, bytes processed so far, total size)

Return value

true: Streaming completed successfully
false: Streaming failed (check GetLastError() for details)

Discussion

Downloads a file and streams it in 4KB chunks to a callback function. This is useful for processing large files without loading the entire file into memory at once, or for displaying download progress.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Stream file with progress callback
bool success = client.StreamFile("prod_abc123", "large_file.bin",
    [](const std::vector<uint8_t>& chunk, size_t processed, size_t total) {
        double percent = (double)processed / total * 100.0;
        std::cout << "Progress: " << percent << "% (" << processed << "/" << total << " bytes)" << std::endl;
        // Process chunk here...
    });

if (success) {
    std::cout << "File streamed successfully!" << std::endl;
} else {
    std::cout << "Streaming failed: " << client.GetLastError() << std::endl;
}

DownloadFolder()

Download an entire folder as a ZIP archive and extract it.

Declaration

FolderDownloadResult DownloadFolder(const std::string& productId,
                                    const std::string& folderName,
                                    const std::string& outputDir)

Discussion

Downloads a folder from the product as an encrypted ZIP archive, decrypts it, and extracts all contents to the specified directory. This is more efficient than downloading files individually.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Download entire folder
auto result = client.DownloadFolder("prod_abc123", "game_assets", "./assets/");

if (result.success) {
    std::cout << "Folder downloaded successfully!" << std::endl;
    std::cout << "Extracted " << result.extractedFiles.size() << " files" << std::endl;
} else {
    std::cout << "Download failed: " << result.error << std::endl;
}

GetFolderInfo()

Get metadata about a specific folder in a product.

Declaration

FolderInfo GetFolderInfo(const std::string& productId, const std::string& folderName)

Parameters

productIdstring: The ID of the product containing the folder
folderNamestring: The name of the folder

Return value

FolderInfo: A struct containing folder metadata (id, name, totalSize, fileCount, downloads, etc.)

Returns an empty FolderInfo struct on failure (check GetLastError() for details)

Discussion

Retrieves detailed information about a specific folder, including its total size, file count, and download statistics. Use this to check if a folder exists and get its properties before downloading.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Get folder info
FolderInfo folderInfo = client.GetFolderInfo("prod_abc123", "Release");

if (!folderInfo.id.empty()) {
    std::cout << "Folder: " << folderInfo.name << std::endl;
    std::cout << "Total Size: " << folderInfo.totalSize << " bytes" << std::endl;
    std::cout << "File Count: " << folderInfo.fileCount << std::endl;
    std::cout << "Downloads: " << folderInfo.downloads << std::endl;
} else {
    std::cout << "Folder not found: " << client.GetLastError() << std::endl;
}

DownloadFolderToMemory()

Download a folder as a ZIP archive into memory.

Declaration

std::vector<uint8_t> DownloadFolderToMemory(const std::string& productId,
                                          const std::string& folderName)

Parameters

productIdstring: The ID of the product containing the folder
folderNamestring: The name of the folder to download

Return value

std::vector<uint8_t>: The folder ZIP archive data as bytes

Returns an empty vector on failure (check GetLastError() for details)

Discussion

Downloads a folder from the product as an encrypted ZIP archive and returns the decrypted ZIP data in memory. This is useful when you need to process the folder archive without writing it to disk first.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Download folder to memory
auto folderData = client.DownloadFolderToMemory("prod_abc123", "game_assets");

if (!folderData.empty()) {
    std::cout << "Downloaded " << folderData.size() << " bytes" << std::endl;
    // Process ZIP data in memory or save to file...
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

GetFileList()

List all files available in a product.

Declaration

std::vector<FileInfo> GetFileList(const std::string& productId)

Discussion

Retrieves a list of all files associated with a product. Use this to display available downloads to users or to check if a specific file exists before downloading.

IsValidFileHash()

Check a local file against the server's stored hash (a keyed hash, computed with your SDK key, for end-to-end encrypted apps).

Declaration

bool IsValidFileHash(const std::string& productId,
                        const std::string& fileName,
                        const std::string& filePath)

Parameters

productIdstring: The ID of the product containing the file
fileNamestring: The name of the file on the server
filePathstring: The local path to the file to verify

Return value

true: File hash matches the server's stored hash
false: Hash mismatch, file not found, or verification failed (check GetLastError() for details)

Discussion

Calculates the SHA256 hash of a local file and compares it with the hash stored on the server. This is useful for verifying file integrity after download, ensuring the file hasn't been corrupted or tampered with. The function reads the local file, computes its SHA256 hash, sends it to the server for verification, and returns whether the hashes match.

ExampleC++Copy

// Authenticate
client.AuthenticateWithKey("user_key");

// Download a file
if (client.DownloadFile("prod_abc123", "update.exe", "./update.exe")) {
    std::cout << "File downloaded successfully!" << std::endl;
    
    // Verify file integrity by checking hash
    if (client.IsValidFileHash("prod_abc123", "update.exe", "./update.exe")) {
        std::cout << "File hash verified - file is intact!" << std::endl;
    } else {
        std::cout << "File hash verification failed: " << client.GetLastError() << std::endl;
        std::cout << "File may be corrupted or tampered with!" << std::endl;
    }
} else {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

GetFolderList()

List all folders available in a product.

Declaration

std::vector<FolderInfo> GetFolderList(const std::string& productId)

Discussion

Retrieves a list of all folders associated with a product. Use this to show available folder downloads or to get folder metadata before downloading.

Encryption

DecryptFile()

Decrypt a previously downloaded encrypted file.

Declaration

bool DecryptFile(const std::string& encryptedFilePath,
                 const std::string& outputPath,
                 const std::string& key,
                 const std::string& iv)

Discussion

Decrypts a file that was previously downloaded in encrypted form. Uses AES-256-GCM for decryption. Normally you don't need this as DownloadFile() handles decryption automatically.

DecryptData()

Decrypt encrypted data in memory.

Declaration

std::vector<uint8_t> DecryptData(const std::vector<uint8_t>& encryptedData,
                                 const std::string& key,
                                 const std::string& iv)

Discussion

Decrypts data in memory using AES-256-GCM. Use this for decrypting data without writing to disk.

Configuration

SetApiKey()

Set the application API key.

Declaration

void SetApiKey(const std::string& key)

Discussion

Sets the API key that identifies your application to the Vaultix backend. This must be called before any authentication or API calls. Get your API key from the Vaultix dashboard.

ClearApiKey()

Clear the API key from memory for security.

Declaration

void ClearApiKey()

Discussion

Securely clears the API key from memory by overwriting it with zeros. This is recommended after authentication is complete to prevent the API key from being exposed in memory dumps. The API key is only needed during authentication.

SetDebugMode()

Enable/disable debug output.

Declaration

void SetDebugMode(bool debug)

Discussion

Enables or disables debug mode. When enabled, the client prints detailed information about HTTP requests, responses, and operations to stdout. Useful for troubleshooting.

SetSSLVerify()

Enable/disable SSL certificate verification.

Declaration

void SetSSLVerify(bool verify)

Discussion

Controls whether SSL/TLS certificates are verified. By default, certificate verification is enabled which is the secure setting. Only disable this for local development with self-signed certificates.

GetLastError()

Get the last error message.

Declaration

std::string GetLastError() const

Discussion

Returns a human-readable description of the last error that occurred. Call this when an operation returns false or fails to get details about what went wrong.

ExampleC++Copy

if (!client.AuthenticateWithKey("user_key")) {
    std::cout << "Authentication failed: " << client.GetLastError() << std::endl;
}

if (!client.DownloadFile("prod_id", "file.exe", "./file.exe")) {
    std::cout << "Download failed: " << client.GetLastError() << std::endl;
}

Security

SetRequireSignedResponses()

Choose whether server responses must carry a valid Vaultix signature.

Declaration

void SetRequireSignedResponses(bool require)
bool GetRequireSignedResponses() const

Discussion

On by default. Every request carries a random nonce, and the client checks Vaultix's signature over the response, the nonce and the request. A response that is unsigned, tampered with, replayed or from another server is rejected, and the call fails with GetLastError() starting with "Server response could not be verified". Turn it off only to test against your own local server; never ship a build with it off.

SetResponseClockSkewTolerance()

Set how far the device clock may differ from the server's.

Declaration

void SetResponseClockSkewTolerance(long seconds)

Discussion

Signed responses carry the time they were signed. Responses signed more than this many seconds before or after the device's current time are rejected. Default 600 (10 minutes). Raise it if your users often have badly set clocks.

EnableCertificatePinning()

Enable certificate pinning for enhanced security.

Declaration

void EnableCertificatePinning(const std::vector<std::string>& certHashes)

Discussion

Enables certificate pinning by specifying which certificates are trusted. This prevents man-in-the-middle attacks even if a Certificate Authority is compromised. Only use this for high-security applications.

DisableCertificatePinning()

Disable certificate pinning.

Declaration

void DisableCertificatePinning()

Discussion

Disables certificate pinning that was previously enabled. After calling this, the client will use standard certificate validation instead of pinned certificates.

EnableOCSPCheck()

Enable OCSP certificate revocation checking.

Declaration

void EnableOCSPCheck()

Discussion

Enables Online Certificate Status Protocol (OCSP) checking to detect revoked certificates. This is enabled by default and adds minimal overhead.

SetMinTlsVersion()

Set minimum TLS version required.

Declaration

void SetMinTlsVersion(const std::string& version)

Discussion

Sets the minimum TLS version required for connections. Default is TLS 1.2. Use TLS 1.3 for maximum security.

EnableRequestSigning()

Enable request signing to prevent replay attacks.

Declaration

void EnableRequestSigning(const std::string& signingKey)

Discussion

Enables request signing using HMAC-SHA256. Each request is signed with a timestamp to prevent replay attacks and ensure request integrity. The backend must also have request signing enabled with the same key.

DisableRequestSigning()

Disable request signing.

Declaration

void DisableRequestSigning()

Discussion

Disables request signing that was previously enabled. After calling this, requests will no longer be signed with HMAC-SHA256.

Vaultix · Features · Pricing · Documentation · Changelog · llms.txt