qsmp.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: john.underhill@protonmail.com
 */
 
#ifndef QSMP_H
#define QSMP_H
 
#include "../../QSC/QSC/rcs.h"
#include "../../QSC/QSC/sha3.h"


#define QSMP_CONFIG_DILITHIUM_KYBER

//* \def QSMP_CONFIG_DILITHIUM_MCELIECE
//* \brief Sets the asymmetric cryptographic primitive-set to Dilithium/McEliece.
//*/
//#define QSMP_CONFIG_DILITHIUM_MCELIECE

//* \def QSMP_CONFIG_SPHINCS_MCELIECE
//* \brief Sets the asymmetric cryptographic primitive-set to Sphincs+/McEliece.
//*/
//#define QSMP_CONFIG_SPHINCS_MCELIECE
 
#include "common.h"
#include "../../QSC/QSC/socketbase.h"
 
#if defined(QSMP_CONFIG_DILITHIUM_KYBER)
#   include "../../QSC/QSC/dilithium.h"
#   include "../../QSC/QSC/kyber.h"
#elif defined(QSMP_CONFIG_DILITHIUM_MCELIECE)
#   include "../../QSC/QSC/dilithium.h"
#   include "../../QSC/QSC/mceliece.h"
#elif defined(QSMP_CONFIG_SPHINCS_MCELIECE)
#   include "../../QSC/QSC/sphincsplus.h"
#   include "../../QSC/QSC/mceliece.h"
#else
#   error Invalid parameter set!
#endif

//* \def QSMP_ASYMMETRIC_RATCHET
//* \brief Enable the asymmetric ratchet option
//*/
//#define QSMP_ASYMMETRIC_RATCHET

#define QSMP_CONFIG_SIZE 48

#define QSMP_SIMPLEX_HASH_SIZE 32

#define QSMP_SIMPLEX_MACKEY_SIZE 32

#define QSMP_SIMPLEX_MACTAG_SIZE 32

#define QSMP_SIMPLEX_SYMMETRIC_KEY_SIZE 32

#define QSMP_SIMPLEX_SCHASH_SIZE 32

#define QSMP_DUPLEX_HASH_SIZE 64

#define QSMP_DUPLEX_MACKEY_SIZE 64

#define QSMP_DUPLEX_MACTAG_SIZE 64

#define QSMP_DUPLEX_SYMMETRIC_KEY_SIZE 64

#define QSMP_DUPLEX_SCHASH_SIZE 64

#define QSMP_ASYMMETRIC_KEYCHAIN_COUNT 10

#define QSMP_CLIENT_PORT 31118

#define QSMP_CONNECTIONS_INIT 1000

#define QSMP_CONNECTIONS_MAX 50000

#define QSMP_CONNECTION_MTU 1500

#define QSMP_ERROR_SEQUENCE 0xFF00000000000000ULL

#define QSMP_ERROR_MESSAGE_SIZE 1

#define QSMP_FLAG_SIZE 1

#define QSMP_HEADER_SIZE 21

#define QSMP_KEEPALIVE_STRING 20

#define QSMP_KEEPALIVE_TIMEOUT (120 * 1000)

#define QSMP_KEYID_SIZE 16

#define QSMP_MSGLEN_SIZE 4

#define QSMP_NETWORK_MTU_SIZE 1500

#define QSMP_NONCE_SIZE 32

#define QSMP_RTOK_SIZE 32

#define QSMP_SERVER_PORT 31119

#define QSMP_PACKET_TIME_THRESHOLD 60

#define QSMP_POLLING_INTERVAL (120 * 1000)

#define QSMP_PUBKEY_DURATION_DAYS 365

#define QSMP_PUBKEY_DURATION_SECONDS (QSMP_PUBKEY_DURATION_DAYS * 24 * 60 * 60)

#define QSMP_PUBKEY_LINE_LENGTH 64

#define QSMP_SECRET_SIZE 32

#define QSMP_SEQUENCE_SIZE 8

#define QSMP_SEQUENCE_TERMINATOR 0xFFFFFFFFUL

#define QSMP_SRVID_SIZE 8

#define QSMP_STOKEN_SIZE 64

#define QSMP_TIMESTAMP_SIZE 8

#define QSMP_TIMESTAMP_STRING_SIZE 20

#define QSMP_MESSAGE_MAX 0x3D090000
 
#if defined(QSMP_CONFIG_DILITHIUM_KYBER)

#   define qsmp_cipher_generate_keypair qsc_kyber_generate_keypair
#   define qsmp_cipher_decapsulate qsc_kyber_decapsulate
#   define qsmp_cipher_encapsulate qsc_kyber_encapsulate
#   define qsmp_signature_generate_keypair qsc_dilithium_generate_keypair
#   define qsmp_signature_sign qsc_dilithium_sign
#   define qsmp_signature_verify qsc_dilithium_verify

#   if defined(QSC_DILITHIUM_S1P2544) && defined(QSC_KYBER_S1P1632)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s1_kyber-s1_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S3P4016) && defined(QSC_KYBER_S3P2400)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s3_kyber-s3_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P4880) && defined(QSC_KYBER_S5P3168)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s5_kyber-s5_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P4880) && defined(QSC_KYBER_S6P3936)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s5_kyber-s6_sha3_rcs";
#   else
#       error Invalid parameter set!
#   endif

#   define QSMP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_KYBER_CIPHERTEXT_SIZE)

#   define QSMP_ASYMMETRIC_PRIVATE_KEY_SIZE (QSC_KYBER_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_PUBLIC_KEY_SIZE (QSC_KYBER_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_DILITHIUM_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_DILITHIUM_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNATURE_SIZE (QSC_DILITHIUM_SIGNATURE_SIZE)
 
#elif defined(QSMP_CONFIG_DILITHIUM_MCELIECE)
#   define qsmp_cipher_generate_keypair qsc_mceliece_generate_keypair
#   define qsmp_cipher_decapsulate qsc_mceliece_decapsulate
#   define qsmp_cipher_encapsulate qsc_mceliece_encapsulate
#   define qsmp_signature_generate_keypair qsc_dilithium_generate_keypair
#   define qsmp_signature_sign qsc_dilithium_sign
#   define qsmp_signature_verify qsc_dilithium_verify

#   if defined(QSC_DILITHIUM_S1P2544) && defined(QSC_MCELIECE_S1N3488T64)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s1_mceliece-s1_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S3P4016) && defined(QSC_MCELIECE_S3N4608T96)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s3_mceliece-s3_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P4880) && defined(QSC_MCELIECE_S5N6688T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s5_mceliece-s5_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P4880) && defined(QSC_MCELIECE_S6N6960T119)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s5_mceliece-s6_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P4880) && defined(QSC_MCELIECE_S7N8192T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "dilithium-s5_mceliece-s7_sha3_rcs";
#   else
#       error Invalid parameter set!
#   endif

#   define QSMP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_MCELIECE_CIPHERTEXT_SIZE)

#   define QSMP_ASYMMETRIC_PRIVATE_KEY_SIZE (QSC_MCELIECE_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_PUBLIC_KEY_SIZE (QSC_MCELIECE_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_DILITHIUM_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_DILITHIUM_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNATURE_SIZE (QSC_DILITHIUM_SIGNATURE_SIZE)
 
#elif defined(QSMP_CONFIG_SPHINCS_MCELIECE)

#   define qsmp_cipher_generate_keypair qsc_mceliece_generate_keypair
#   define qsmp_cipher_decapsulate qsc_mceliece_decapsulate
#   define qsmp_cipher_encapsulate qsc_mceliece_encapsulate
#   define qsmp_signature_generate_keypair qsc_sphincsplus_generate_keypair
#   define qsmp_signature_sign qsc_sphincsplus_sign
#   define qsmp_signature_verify qsc_sphincsplus_verify

#   if defined(QSC_SPHINCSPLUS_S1S128SHAKERF) && defined(QSC_MCELIECE_S1N3488T64)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s1f_mceliece-s1_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S1S128SHAKERS) && defined(QSC_MCELIECE_S1N3488T64)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s1s_mceliece-s1_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S3S192SHAKERF) && defined(QSC_MCELIECE_S3N4608T96)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-3f_mceliece-s3_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S3S192SHAKERS) && defined(QSC_MCELIECE_S3N4608T96)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-3s_mceliece-s3_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERF) && defined(QSC_MCELIECE_S5N6688T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5f_mceliece-s5_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERS) && defined(QSC_MCELIECE_S5N6688T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5s_mceliece-s5_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERF) && defined(QSC_MCELIECE_S6N6960T119)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5f_mceliece-s6_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERS) && defined(QSC_MCELIECE_S6N6960T119)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5s_mceliece-s6_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERF) && defined(QSC_MCELIECE_S7N8192T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5f_mceliece-s7_sha3_rcs";
#   elif defined(QSC_SPHINCSPLUS_S5S256SHAKERS) && defined(QSC_MCELIECE_S7N8192T128)
static const char QSMP_CONFIG_STRING[QSMP_CONFIG_SIZE] = "sphincs-s5s_mceliece-s7_sha3_rcs";
#   else
#       error Invalid parameter set!
#   endif

#   define QSMP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_MCELIECE_CIPHERTEXT_SIZE)

#   define QSMP_ASYMMETRIC_PRIVATE_KEY_SIZE (QSC_MCELIECE_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_PUBLIC_KEY_SIZE (QSC_MCELIECE_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_SPHINCSPLUS_PRIVATEKEY_SIZE)

#   define QSMP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_SPHINCSPLUS_PUBLICKEY_SIZE)

#   define QSMP_ASYMMETRIC_SIGNATURE_SIZE (QSC_SPHINCSPLUS_SIGNATURE_SIZE)
 
#else
#   error invalid parameter set!
#endif
 
/* public key encoding constants */

#define QSMP_SIGKEY_ENCODED_SIZE (QSMP_KEYID_SIZE + QSMP_TIMESTAMP_SIZE + QSMP_CONFIG_SIZE + QSMP_ASYMMETRIC_SIGNING_KEY_SIZE + QSMP_ASYMMETRIC_VERIFY_KEY_SIZE)

#define QSMP_PUBKEY_HEADER_SIZE 40
#define QSMP_PUBKEY_VERSION_SIZE 19
#define QSMP_PUBKEY_CONFIG_SIZE 16
#define QSMP_PUBKEY_KEYID_SIZE 10
#define QSMP_PUBKEY_EXPIRATION_SIZE 13
#define QSMP_PUBKEY_FOOTER_SIZE 38

static const char QSMP_PUBKEY_HEADER[QSMP_PUBKEY_HEADER_SIZE] = "------BEGIN QSMP PUBLIC KEY BLOCK------";

static const char QSMP_PUBKEY_VERSION[QSMP_PUBKEY_VERSION_SIZE] = "Version: QSMP v1.2";

static const char QSMP_PUBKEY_CONFIG_PREFIX[QSMP_PUBKEY_CONFIG_SIZE] = "Configuration: ";

static const char QSMP_PUBKEY_KEYID_PREFIX[QSMP_PUBKEY_KEYID_SIZE] = "Host ID: ";

static const char QSMP_PUBKEY_EXPIRATION_PREFIX[QSMP_PUBKEY_EXPIRATION_SIZE] = "Expiration: ";

static const char QSMP_PUBKEY_FOOTER[QSMP_PUBKEY_FOOTER_SIZE] = "------END QSMP PUBLIC KEY BLOCK------";
 
/* error code strings */

#define QSMP_ERROR_STRING_DEPTH 29
#define QSMP_ERROR_STRING_WIDTH 128

static const char QSMP_ERROR_STRINGS[QSMP_ERROR_STRING_DEPTH][QSMP_ERROR_STRING_WIDTH] =
{
    "No error was detected",
    "The socket accept function returned an error",
    "The symmetric cipher had an authentication failure",
    "The keep alive check failed",
    "The communications channel has failed",
    "The device could not make a connection to the remote host",
    "The transmission failed at the KEX connection phase",
    "The asymmetric cipher failed to decapsulate the shared secret",
    "The decryption authentication has failed",
    "The transmission failed at the KEX establish phase",
    "The transmission failed at the KEX exchange phase",
    "The public - key hash is invalid",
    "The server has run out of socket connections",
    "The expected input was invalid",
    "The packet flag was unexpected",
    "The keep alive has expired with no response",
    "The decryption authentication has failed",
    "The QSMP public key has expired ",
    "The key identity is unrecognized",
    "The ratchet operation has failed",
    "The listener function failed to initialize",
    "The server has run out of memory",
    "The packet has valid time expired",
    "The packet was received out of sequence",
    "The random generator has failed",
    "The receiver failed at the network layer",
    "The transmitter failed at the network layer",
    "The protocol string was not recognized",
    "The expected data could not be verified",
};

#define QSMP_MESSAGE_STRING_DEPTH 22
#define QSMP_MESSAGE_STRING_WIDTH 128

static const char QSMP_MESSAGE_STRINGS[QSMP_MESSAGE_STRING_DEPTH][QSMP_MESSAGE_STRING_WIDTH] =
{
    "The operation completed succesfully.",
    "The socket server accept function failed.",
    "The listener socket listener could not connect.",
    "The listener socket could not bind to the address.",
    "The listener socket could not be created.",
    "The server is connected to remote host: ",
    "The socket receive function failed.",
    "The server had a memory allocation failure.",
    "The key exchange has experienced a failure.",
    "The server has disconnected from the remote host: ",
    "The server has disconnected the client due to an error",
    "The server has had a socket level error: ",
    "The server has reached the maximum number of connections",
    "The server listener socket has failed.",
    "The server has run out of socket connections",
    "The message decryption has failed",
    "The keepalive function has failed",
    "The keepalive period has been exceeded",
    "The connection failed or was interrupted",
    "The function received an invalid request",
};

QSMP_EXPORT_API typedef enum qsmp_configuration
{
    qsmp_configuration_none = 0x00,                  
    qsmp_configuration_sphincs_mceliece = 0x01,      
    qsmp_configuration_dilithium_kyber = 0x02,        
    qsmp_configuration_dilithium_mceliece = 0x03,  
    qsmp_configuration_dilithium_ntru = 0x04,      
    qsmp_configuration_falcon_kyber = 0x05,          
    qsmp_configuration_falcon_mceliece = 0x06,        
    qsmp_configuration_falcon_ntru = 0x07,            
} qsmp_configuration;

QSMP_EXPORT_API typedef enum qsmp_messages
{
    qsmp_messages_none = 0x00,                        
    qsmp_messages_accept_fail = 0x01,              
    qsmp_messages_listen_fail = 0x02,              
    qsmp_messages_bind_fail = 0x03,                  
    qsmp_messages_create_fail = 0x04,              
    qsmp_messages_connect_success = 0x05,          
    qsmp_messages_receive_fail = 0x06,                
    qsmp_messages_allocate_fail = 0x07,              
    qsmp_messages_kex_fail = 0x08,                    
    qsmp_messages_disconnect = 0x09,                
    qsmp_messages_disconnect_fail = 0x0A,          
    qsmp_messages_socket_message = 0x0B,            
    qsmp_messages_queue_empty = 0x0C,              
    qsmp_messages_listener_fail = 0x0D,              
    qsmp_messages_sockalloc_fail = 0x0E,            
    qsmp_messages_decryption_fail = 0x0F,          
    qsmp_messages_keepalive_fail = 0x10,            
    qsmp_messages_keepalive_timeout = 0x11,          
    qsmp_messages_connection_fail = 0x12,          
    qsmp_messages_invalid_request = 0x13,          
} qsmp_messages;

QSMP_EXPORT_API typedef enum qsmp_errors
{
    qsmp_error_none = 0x00,                          
    qsmp_error_accept_fail = 0x01,                    
    qsmp_error_authentication_failure = 0x02,      
    qsmp_error_bad_keep_alive = 0x03,              
    qsmp_error_channel_down = 0x04,                  
    qsmp_error_connection_failure = 0x05,          
    qsmp_error_connect_failure = 0x06,                
    qsmp_error_decapsulation_failure = 0x07,        
    qsmp_error_decryption_failure = 0x08,          
    qsmp_error_establish_failure = 0x09,            
    qsmp_error_exchange_failure = 0x0A,              
    qsmp_error_hash_invalid = 0x0B,                  
    qsmp_error_hosts_exceeded = 0x0C,              
    qsmp_error_invalid_input = 0x0D,                
    qsmp_error_invalid_request = 0x0E,                
    qsmp_error_keepalive_expired = 0x0F,            
    qsmp_error_keepalive_timeout = 0x10,            
    qsmp_error_key_expired = 0x11,                    
    qsmp_error_key_unrecognized = 0x12,              
    qsmp_error_keychain_fail = 0x13,                
    qsmp_error_listener_fail = 0x14,                
    qsmp_error_memory_allocation = 0x15,            
    qsmp_error_message_time_invalid = 0x06,          
    qsmp_error_packet_unsequenced = 0x17,          
    qsmp_error_random_failure = 0x18,              
    qsmp_error_receive_failure = 0x19,                
    qsmp_error_transmit_failure = 0x1A,              
    qsmp_error_unknown_protocol = 0x1B,              
    qsmp_error_verify_failure = 0x1C,              
} qsmp_errors;

QSMP_EXPORT_API typedef enum qsmp_flags
{
    qsmp_flag_none = 0x00,                            
    qsmp_flag_connect_request = 0x01,              
    qsmp_flag_connect_response = 0x02,                
    qsmp_flag_connection_terminate = 0x03,            
    qsmp_flag_encrypted_message = 0x04,              
    qsmp_flag_exstart_request = 0x05,              
    qsmp_flag_exstart_response = 0x06,                
    qsmp_flag_exchange_request = 0x07,                
    qsmp_flag_exchange_response = 0x08,              
    qsmp_flag_establish_request = 0x09,              
    qsmp_flag_establish_response = 0x0A,            
    qsmp_flag_keep_alive_request = 0x0B,            
    qsmp_flag_keep_alive_response = 0x0C,          
    qsmp_flag_remote_connected = 0x0D,                
    qsmp_flag_remote_terminated = 0x0E,              
    qsmp_flag_session_established = 0x0F,          
    qsmp_flag_session_establish_verify = 0x10,        
    qsmp_flag_unrecognized_protocol = 0x11,          
    qsmp_flag_asymmetric_ratchet_request = 0x12,    
    qsmp_flag_asymmetric_ratchet_response = 0x13,  
    qsmp_flag_symmetric_ratchet_request = 0x14,      
    qsmp_flag_transfer_request = 0x15,                
    qsmp_flag_error_condition = 0xFF,              
} qsmp_flags;

QSMP_EXPORT_API typedef enum qsmp_mode
{
    qsmp_mode_simplex = 0x00,
    qsmp_mode_duplex = 0x01,
} qsmp_mode;

QSMP_EXPORT_API typedef struct qsmp_asymmetric_cipher_keypair
{
    uint8_t* prikey;
    uint8_t* pubkey;
} qsmp_asymmetric_cipher_keypair;

QSMP_EXPORT_API typedef struct qsmp_asymmetric_signature_keypair
{
    uint8_t* sigkey;
    uint8_t* verkey;
} qsmp_asymmetric_signature_keypair;

QSMP_EXPORT_API typedef struct qsmp_network_packet
{
    uint8_t flag;                                   
    uint32_t msglen;                              
    uint64_t sequence;                              
    uint64_t utctime;                                
    uint8_t* pmessage;                              
} qsmp_network_packet;

QSMP_EXPORT_API typedef struct qsmp_client_verification_key
{
    uint64_t expiration;                          
    uint8_t config[QSMP_CONFIG_SIZE];             
    uint8_t keyid[QSMP_KEYID_SIZE];                 
    uint8_t verkey[QSMP_ASYMMETRIC_VERIFY_KEY_SIZE];
} qsmp_client_verification_key;

QSMP_EXPORT_API typedef struct qsmp_server_signature_key
{
    uint64_t expiration;                          
    uint8_t config[QSMP_CONFIG_SIZE];             
    uint8_t keyid[QSMP_KEYID_SIZE];                 
    uint8_t sigkey[QSMP_ASYMMETRIC_SIGNING_KEY_SIZE];
    uint8_t verkey[QSMP_ASYMMETRIC_VERIFY_KEY_SIZE]; 
} qsmp_server_signature_key;

QSMP_EXPORT_API typedef struct qsmp_keep_alive_state
{
    qsc_socket target;                                
    uint64_t etime;                                    
    uint64_t seqctr;                              
    bool recd;                                      
} qsmp_keep_alive_state;

QSMP_EXPORT_API typedef struct qsmp_connection_state
{
    uint8_t rtcs[QSMP_DUPLEX_SYMMETRIC_KEY_SIZE]; 
    qsc_socket target;                                
    qsc_rcs_state rxcpr;                           
    qsc_rcs_state txcpr;                           
    uint64_t rxseq;                                    
    uint64_t txseq;                                    
    uint32_t cid;                                    
    qsmp_flags exflag;                              
    bool receiver;                                  
    qsmp_mode mode;                                    
} qsmp_connection_state;

QSMP_EXPORT_API void qsmp_asymmetric_cipher_keypair_dispose(qsmp_asymmetric_cipher_keypair* keypair);

QSMP_EXPORT_API qsmp_asymmetric_cipher_keypair* qsmp_asymmetric_cipher_keypair_initialize();

QSMP_EXPORT_API void qsmp_asymmetric_signature_keypair_dispose(qsmp_asymmetric_signature_keypair* keypair);

QSMP_EXPORT_API qsmp_asymmetric_signature_keypair* qsmp_asymmetric_signature_keypair_initialize();

QSMP_EXPORT_API void qsmp_connection_close(qsmp_connection_state* cns, qsmp_errors err, bool notify);

QSMP_EXPORT_API void qsmp_connection_state_dispose(qsmp_connection_state* cns);

QSMP_EXPORT_API const char* qsmp_error_to_string(qsmp_errors error);

QSMP_EXPORT_API void qsmp_header_create(qsmp_network_packet* packetout, qsmp_flags flag, uint64_t sequence, uint32_t msglen);

QSMP_EXPORT_API qsmp_errors qsmp_header_validate(qsmp_connection_state* cns, const qsmp_network_packet* packetin, qsmp_flags kexflag, qsmp_flags pktflag, uint64_t sequence, uint32_t msglen);

QSMP_EXPORT_API void qsmp_generate_keypair(qsmp_client_verification_key* pubkey, qsmp_server_signature_key* prikey, const uint8_t keyid[QSMP_KEYID_SIZE]);

QSMP_EXPORT_API const char* qsmp_get_error_description(qsmp_messages emsg);

QSMP_EXPORT_API void qsmp_log_error(qsmp_messages emsg, qsc_socket_exceptions err, const char* msg);

QSMP_EXPORT_API void qsmp_log_message(qsmp_messages emsg);

QSMP_EXPORT_API void qsmp_log_write(qsmp_messages emsg, const char* msg);

QSMP_EXPORT_API void qsmp_packet_clear(qsmp_network_packet* packet);

QSMP_EXPORT_API qsmp_errors qsmp_packet_decrypt(qsmp_connection_state* cns, uint8_t* message, size_t* msglen, const qsmp_network_packet* packetin);

QSMP_EXPORT_API qsmp_errors qsmp_packet_encrypt(qsmp_connection_state* cns, qsmp_network_packet* packetout, const uint8_t* message, size_t msglen);

QSMP_EXPORT_API void qsmp_packet_error_message(qsmp_network_packet* packet, qsmp_errors error);

QSMP_EXPORT_API void qsmp_packet_header_deserialize(const uint8_t* header, qsmp_network_packet* packet);

QSMP_EXPORT_API void qsmp_packet_header_serialize(const qsmp_network_packet* packet, uint8_t* header);

QSMP_EXPORT_API void qsmp_packet_set_utc_time(qsmp_network_packet* packet);

QSMP_EXPORT_API bool qsmp_packet_time_valid(const qsmp_network_packet* packet);

QSMP_EXPORT_API size_t qsmp_packet_to_stream(const qsmp_network_packet* packet, uint8_t* pstream);

QSMP_EXPORT_API bool qsmp_public_key_compare(const qsmp_client_verification_key* a, const qsmp_client_verification_key* b);

QSMP_EXPORT_API bool qsmp_public_key_decode(qsmp_client_verification_key* pubk, const char* enck, size_t enclen);

QSMP_EXPORT_API size_t qsmp_public_key_encode(char* enck, size_t enclen, const qsmp_client_verification_key* pubk);

QSMP_EXPORT_API size_t qsmp_public_key_encoding_size();

QSMP_EXPORT_API void qsmp_signature_key_deserialize(qsmp_server_signature_key* kset, const uint8_t serk[QSMP_SIGKEY_ENCODED_SIZE]);

QSMP_EXPORT_API void qsmp_signature_key_serialize(uint8_t serk[QSMP_SIGKEY_ENCODED_SIZE], const qsmp_server_signature_key* kset);

QSMP_EXPORT_API void qsmp_stream_to_packet(const uint8_t* pstream, qsmp_network_packet* packet);

QSMP_EXPORT_API bool qsmp_certificate_encoding_test();
 
#endif