siap.h

Go to the documentation of this file.

/* 2025 Quantum Resistant Cryptographic Solutions Corporation
 * All Rights Reserved.
 *
 * NOTICE: This software and all accompanying materials are the exclusive
 * property of Quantum Resistant Cryptographic Solutions Corporation (QRCS).
 * The intellectual and technical concepts contained within this implementation
 * are proprietary to QRCS and its authorized licensors and are protected under
 * applicable U.S. and international copyright, patent, and trade secret laws.
 *
 * CRYPTOGRAPHIC STANDARDS:
 * - This software includes implementations of cryptographic algorithms such as
 *   SHA3, AES, and others. These algorithms are public domain or standardized
 *   by organizations such as NIST and are NOT the property of QRCS.
 * - However, all source code, optimizations, and implementations in this library
 *   are original works of QRCS and are protected under this license.
 *
 * RESTRICTIONS:
 * - Redistribution, modification, or unauthorized distribution of this software,
 *   in whole or in part, is strictly prohibited.
 * - This software is provided for non-commercial, educational, and research
 *   purposes only. Commercial use in any form is expressly forbidden.
 * - Licensing and authorized distribution are solely at the discretion of QRCS.
 * - Any use of this software implies acceptance of these restrictions.
 *
 * DISCLAIMER:
 * This software is provided "as is," without warranty of any kind, express or
 * implied, including but not limited to warranties of merchantability or fitness
 * for a particular purpose. QRCS disclaims all liability for any direct, indirect,
 * incidental, or consequential damages resulting from the use or misuse of this software.
 *
 * FULL LICENSE:
 * This software is subject to the **Quantum Resistant Cryptographic Solutions
 * Proprietary License (QRCS-PL)**. The complete license terms are included
 * in the LICENSE.txt file distributed with this software.
 *
 * Written by: John G. Underhill
 * Contact: contact@qrcscorp.ca
 */
 
#ifndef SIAP_H
#define SIAP_H
 
#include "siapcommon.h"
#include "logger.h"
#include "sha3.h"
#include "socket.h"
#include "socketclient.h"


//#define SIAP_EXTENDED_ENCRYPTION

#define SIAP_CLIENT_PASSWORD_MAX 256U

#define SIAP_CLIENT_USERNAME_MAX 256U

#define SIAP_CONFIG_SIZE 26U

#define SIAP_DEVICE_ID_SIZE 4U
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_AUTHENTICATION_TOKEN_SIZE 64U
#else
#   define SIAP_AUTHENTICATION_TOKEN_SIZE 32U
#endif

#define SIAP_DOMAIN_ID_SIZE 2U

#define SIAP_ERROR_SIZE 1U

#define SIAP_EXPIRATION_SIZE 8U
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_HASH_SIZE 64U
#else
#   define SIAP_HASH_SIZE 32U
#endif

#define SIAP_KEY_DURATION_DAYS 365U

#define SIAP_KEY_DURATION_SECONDS (SIAP_KEY_DURATION_DAYS * 24U * 60U * 60U)

#define SIAP_KEY_ID_SIZE 4U

#define SIAP_KTREE_COUNT 1024
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_KTAG_STATE_HASH 64U
#else
#   define SIAP_KTAG_STATE_HASH 32U
#endif
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_MAC_SIZE 64U
#else
#   define SIAP_MAC_SIZE 32U
#endif

#define SIAP_NONCE_SIZE 32U
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_SALT_SIZE 64U
#else
#   define SIAP_SALT_SIZE 32U
#endif

#define SIAP_SERVER_GROUP_ID_SIZE 2U

#define SIAP_SERVER_ID_SIZE 2U
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
#   define SIAP_SERVER_KEY_SIZE 64U
#else
#   define SIAP_SERVER_KEY_SIZE 32U
#endif

#define SIAP_USER_GROUP_ID_SIZE 2U

#define SIAP_USER_ID_SIZE 4U
 
/* compound sizes */

#define SIAP_DID_SIZE (SIAP_DOMAIN_ID_SIZE + SIAP_SERVER_GROUP_ID_SIZE + SIAP_SERVER_ID_SIZE + SIAP_USER_GROUP_ID_SIZE + SIAP_USER_ID_SIZE + SIAP_DEVICE_ID_SIZE)

#define SIAP_SID_SIZE (SIAP_DOMAIN_ID_SIZE + SIAP_SERVER_GROUP_ID_SIZE + SIAP_SERVER_ID_SIZE)

#define SIAP_KID_SIZE (SIAP_DID_SIZE + SIAP_KEY_ID_SIZE)

#define SIAP_KTREE_SIZE (SIAP_AUTHENTICATION_TOKEN_SIZE * SIAP_KTREE_COUNT)

#define SIAP_DEVICE_KEY_ENCODED_SIZE ((SIAP_AUTHENTICATION_TOKEN_SIZE * SIAP_KTREE_COUNT) + SIAP_MAC_SIZE + SIAP_KID_SIZE + SIAP_EXPIRATION_SIZE)

#define SIAP_DEVICE_TAG_ENCODED_SIZE (SIAP_KID_SIZE + SIAP_KTAG_STATE_HASH + SIAP_HASH_SIZE)

#define SIAP_SERVER_KEY_ENCODED_SIZE (SIAP_SERVER_KEY_SIZE + SIAP_SID_SIZE + SIAP_SERVER_KEY_SIZE + SIAP_EXPIRATION_SIZE)
 
/* error code strings */
 
#if defined(SIAP_EXTENDED_ENCRYPTION)
static const char SIAP_CONFIG_STRING[SIAP_CONFIG_SIZE + 1U] = "r01-siap-rcs512-keccak512";
#else
static const char SIAP_CONFIG_STRING[SIAP_CONFIG_SIZE + 1U] = "r02-siap-rcs256-keccak256";
#endif

#define SIAP_ERROR_STRING_DEPTH 12U
#define SIAP_ERROR_STRING_WIDTH 128U
 
static const char SIAP_ERROR_STRINGS[SIAP_ERROR_STRING_DEPTH][SIAP_ERROR_STRING_WIDTH] =
{
    "The operation was succesful",
    "The authentication has failed",
    "The identity strings do not match",
    "The key card has expired",
    "The device passphrase is unrecognized",
    "The cards authentication tokens are invalid",
    "The key card decryption failed",
    "The authentication token is invalid",
    "The server could not generate the token",
    "The file could not be read",
    "The file path specified is invalid",
    "The file is locked or unavailable",
};

SIAP_EXPORT_API typedef enum siap_errors
{
    siap_error_none = 0x00U,                 
    siap_error_authentication_failure = 0x01U, 
    siap_error_identity_mismatch = 0x02U,       
    siap_error_key_expired = 0x03U,               
    siap_error_passphrase_unrecognized = 0x04U,   
    siap_error_token_tree_invalid = 0x05U,     
    siap_error_decryption_failure = 0x06U,     
    siap_error_token_invalid = 0x07U,           
    siap_error_token_not_created = 0x08U,       
    siap_error_file_read_failure = 0x09U,       
    siap_error_file_invalid_path = 0x0AU,       
    siap_error_file_copy_failure = 0x0BU        
} siap_errors;

SIAP_EXPORT_API typedef struct siap_device_key
{
    uint8_t ktree[SIAP_KTREE_SIZE + SIAP_MAC_SIZE];    
    uint8_t kid[SIAP_KID_SIZE];                 
    uint64_t expiration;                      
} siap_device_key;

SIAP_EXPORT_API typedef struct siap_device_tag
{
    uint8_t kid[SIAP_KID_SIZE];                 
    uint8_t khash[SIAP_KTAG_STATE_HASH];       
    uint8_t phash[SIAP_HASH_SIZE];               
} siap_device_tag;

SIAP_EXPORT_API typedef struct siap_server_key
{
    uint8_t kbase[SIAP_SERVER_KEY_SIZE];       
    uint8_t sid[SIAP_SID_SIZE];                 
    uint8_t dsalt[SIAP_SALT_SIZE];               
    uint64_t expiration;                      
} siap_server_key;

SIAP_EXPORT_API void siap_deserialize_device_key(siap_device_key* dkey, const uint8_t* input);

SIAP_EXPORT_API void siap_serialize_device_key(uint8_t* output, const siap_device_key* dkey);

SIAP_EXPORT_API const char* siap_error_to_string(siap_errors error);

SIAP_EXPORT_API const char* siap_get_error_description(siap_errors emsg);

SIAP_EXPORT_API void siap_log_error(siap_errors emsg, const char* msg);

SIAP_EXPORT_API void siap_log_system_error(siap_errors err);

SIAP_EXPORT_API void siap_deserialize_device_tag(siap_device_tag* dtag, const uint8_t* input);

SIAP_EXPORT_API void siap_serialize_device_tag(uint8_t* output, const siap_device_tag* dtag);

SIAP_EXPORT_API void siap_deserialize_server_key(siap_server_key* skey, const uint8_t* input);

SIAP_EXPORT_API void siap_serialize_server_key(uint8_t* output, const siap_server_key* skey);

SIAP_EXPORT_API void siap_increment_device_key(siap_device_key* dkey);
 
#endif