dktp.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 DKTP_H
#define DKTP_H
 
#include "rcs.h"
#include "sha3.h"


#define DKTP_CONFIG_DILITHIUM_KYBER

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

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

#define DKTP_DOMAIN_IDENTITY_SIZE 16U

static const char DKTP_DOMAIN_IDENTITY_STRING[DKTP_DOMAIN_IDENTITY_SIZE] = "QRCS:PDEF:DKTP1A";

#define DKTP_ASYMMETRIC_RATCHET

#define DKTP_CONFIG_SIZE 48U

#define DKTP_HASH_SIZE 64U

#define DKTP_MACKEY_SIZE 64U

#define DKTP_MACTAG_SIZE 64U

#define DKTP_SYMMETRIC_KEY_SIZE 64U

#define DKTP_SYMMETRIC_NONCE_SIZE 32U

#define DKTP_ASYMMETRIC_KEYCHAIN_COUNT 10U

#define DKTP_CLIENT_PORT 31118U

#define DKTP_CONNECTIONS_INIT 1000U

#define DKTP_CONNECTIONS_MAX 50000U

#define DKTP_CONNECTION_MTU 1500U

#define DKTP_ERROR_SEQUENCE 0xFF00000000000000ULL

#define DKTP_ERROR_MESSAGE_SIZE 1U

#define DKTP_FLAG_SIZE 1U

#define DKTP_HEADER_SIZE 21U

#define DKTP_KEEPALIVE_STRING 20U

#define DKTP_KEEPALIVE_TIMEOUT (120U * 1000U)

#define DKTP_KEYID_SIZE 16U

#define DKTP_MSGLEN_SIZE 4U

#define DKTP_NONCE_SIZE 32U

#define DKTP_SERVER_PORT 31119U

#define DKTP_PACKET_TIME_THRESHOLD 60U

#define DKTP_POLLING_INTERVAL (120U * 1000U)

#define DKTP_PUBKEY_DURATION_DAYS 365U

#define DKTP_PUBKEY_DURATION_SECONDS (DKTP_PUBKEY_DURATION_DAYS * 24U * 60U * 60U)

#define DKTP_PUBKEY_LINE_LENGTH 64U

#define DKTP_SECRET_SIZE 32U

#define DKTP_SEQUENCE_SIZE 8U

#define DKTP_SEQUENCE_TERMINATOR 0xFFFFFFFFUL

#define DKTP_TIMESTAMP_SIZE 8U

#define DKTP_TIMESTAMP_STRING_SIZE 20U

#define DKTP_MESSAGE_MAX 0x3D090000UL
 
#if defined(DKTP_CONFIG_DILITHIUM_KYBER)

#   define dktp_cipher_generate_keypair qsc_kyber_generate_keypair
#   define dktp_cipher_decapsulate qsc_kyber_decapsulate
#   define dktp_cipher_encapsulate qsc_kyber_encapsulate
#   define dktp_signature_generate_keypair qsc_dilithium_generate_keypair
#   define dktp_signature_sign qsc_dilithium_sign
#   define dktp_signature_verify qsc_dilithium_verify

#   if defined(QSC_DILITHIUM_S1P44) && defined(QSC_KYBER_S1K2P512)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s1_kyber-s1_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S3P65) && defined(QSC_KYBER_S3K3P768)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s3_kyber-s3_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P87) && defined(QSC_KYBER_S5K4P1024)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s5_kyber-s5_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P87) && defined(QSC_KYBER_S6K5P1280)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s5_kyber-s6_sha3_rcs";
#   else
#       error Invalid parameter set!
#   endif

#   define DKTP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_KYBER_CIPHERTEXT_SIZE)

#   define DKTP_ASYMMETRIC_DECAPSULATION_KEY_SIZE (QSC_KYBER_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_ENCAPSULATION_KEY_SIZE (QSC_KYBER_PUBLICKEY_SIZE)

#   define DKTP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_DILITHIUM_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_DILITHIUM_PUBLICKEY_SIZE)

#   define DKTP_ASYMMETRIC_SIGNATURE_SIZE (QSC_DILITHIUM_SIGNATURE_SIZE)
 
#elif defined(DKTP_CONFIG_DILITHIUM_MCELIECE)
#   define dktp_cipher_generate_keypair qsc_mceliece_generate_keypair
#   define dktp_cipher_decapsulate qsc_mceliece_decapsulate
#   define dktp_cipher_encapsulate qsc_mceliece_encapsulate
#   define dktp_signature_generate_keypair qsc_dilithium_generate_keypair
#   define dktp_signature_sign qsc_dilithium_sign
#   define dktp_signature_verify qsc_dilithium_verify

#   if defined(QSC_DILITHIUM_S1P44) && defined(QSC_MCELIECE_S1N3488T64)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s1_mceliece-s1_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S3P65) && defined(QSC_MCELIECE_S3N4608T96)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s3_mceliece-s3_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P87) && defined(QSC_MCELIECE_S5N6688T128)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s5_mceliece-s5_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P87) && defined(QSC_MCELIECE_S6N6960T119)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s5_mceliece-s6_sha3_rcs";
#   elif defined(QSC_DILITHIUM_S5P87) && defined(QSC_MCELIECE_S7N8192T128)
static const char DKTP_CONFIG_STRING[DKTP_CONFIG_SIZE] = "dilithium-s5_mceliece-s7_sha3_rcs";
#   else
#       error Invalid parameter set!
#   endif

#   define DKTP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_MCELIECE_CIPHERTEXT_SIZE)

#   define DKTP_ASYMMETRIC_DECAPSULATION_KEY_SIZE (QSC_MCELIECE_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_ENCAPSULATION_KEY_SIZE (QSC_MCELIECE_PUBLICKEY_SIZE)

#   define DKTP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_DILITHIUM_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_DILITHIUM_PUBLICKEY_SIZE)

#   define DKTP_ASYMMETRIC_SIGNATURE_SIZE (QSC_DILITHIUM_SIGNATURE_SIZE)
 
#elif defined(DKTP_CONFIG_SPHINCS_MCELIECE)

#   define dktp_cipher_generate_keypair qsc_mceliece_generate_keypair
#   define dktp_cipher_decapsulate qsc_mceliece_decapsulate
#   define dktp_cipher_encapsulate qsc_mceliece_encapsulate
#   define dktp_signature_generate_keypair qsc_sphincsplus_generate_keypair
#   define dktp_signature_sign qsc_sphincsplus_sign
#   define dktp_signature_verify qsc_sphincsplus_verify

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

#   define DKTP_ASYMMETRIC_CIPHER_TEXT_SIZE (QSC_MCELIECE_CIPHERTEXT_SIZE)

#   define DKTP_ASYMMETRIC_DECAPSULATION_KEY_SIZE (QSC_MCELIECE_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_ENCAPSULATION_KEY_SIZE (QSC_MCELIECE_PUBLICKEY_SIZE)

#   define DKTP_ASYMMETRIC_SIGNING_KEY_SIZE (QSC_SPHINCSPLUS_PRIVATEKEY_SIZE)

#   define DKTP_ASYMMETRIC_VERIFY_KEY_SIZE (QSC_SPHINCSPLUS_PUBLICKEY_SIZE)

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

#define DKTP_REMOTE_PEER_KEY_ENCODED_SIZE (DKTP_KEYID_SIZE + DKTP_TIMESTAMP_SIZE + DKTP_CONFIG_SIZE + DKTP_SECRET_SIZE + DKTP_ASYMMETRIC_VERIFY_KEY_SIZE)

#define DKTP_LOCAL_PEER_KEY_ENCODED_SIZE (DKTP_KEYID_SIZE + DKTP_KEYID_SIZE + DKTP_TIMESTAMP_SIZE + DKTP_CONFIG_SIZE + DKTP_SECRET_SIZE + DKTP_ASYMMETRIC_SIGNING_KEY_SIZE + DKTP_ASYMMETRIC_VERIFY_KEY_SIZE)
 
/* error code strings */

#define DKTP_ERROR_STRING_DEPTH 30U

#define DKTP_ERROR_STRING_WIDTH 128U

static const char DKTP_ERROR_STRINGS[DKTP_ERROR_STRING_DEPTH][DKTP_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 DKTP 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",
    "The remote peer key identity does not match the local key",
};

#define DKTP_MESSAGE_STRING_DEPTH 21U
#define DKTP_MESSAGE_STRING_WIDTH 128U

static const char DKTP_MESSAGE_STRINGS[DKTP_MESSAGE_STRING_DEPTH][DKTP_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",
    "The remote peer identity does not match the local key",
};

DKTP_EXPORT_API typedef enum dktp_configuration
{
    dktp_configuration_none = 0x00U,             
    dktp_configuration_sphincs_mceliece = 0x01U, 
    dktp_configuration_dilithium_kyber = 0x02U,       
    dktp_configuration_dilithium_mceliece = 0x03U, 
    dktp_configuration_dilithium_ntru = 0x04U,     
    dktp_configuration_falcon_kyber = 0x05U,     
    dktp_configuration_falcon_mceliece = 0x06U,       
    dktp_configuration_falcon_ntru = 0x07U,           
} dktp_configuration;

DKTP_EXPORT_API typedef enum dktp_messages
{
    dktp_messages_none = 0x00U,                       
    dktp_messages_accept_fail = 0x01U,             
    dktp_messages_listen_fail = 0x02U,             
    dktp_messages_bind_fail = 0x03U,             
    dktp_messages_create_fail = 0x04U,             
    dktp_messages_connect_success = 0x05U,         
    dktp_messages_receive_fail = 0x06U,               
    dktp_messages_allocate_fail = 0x07U,         
    dktp_messages_kex_fail = 0x08U,                   
    dktp_messages_disconnect = 0x09U,               
    dktp_messages_disconnect_fail = 0x0AU,         
    dktp_messages_socket_message = 0x0BU,           
    dktp_messages_queue_empty = 0x0CU,             
    dktp_messages_listener_fail = 0x0DU,         
    dktp_messages_sockalloc_fail = 0x0EU,           
    dktp_messages_decryption_fail = 0x0FU,         
    dktp_messages_keepalive_fail = 0x10U,           
    dktp_messages_keepalive_timeout = 0x11U,     
    dktp_messages_connection_fail = 0x12U,         
    dktp_messages_invalid_request = 0x13U,         
    dktp_messages_peer_key_mismatch = 0x14U,     
} dktp_messages;

DKTP_EXPORT_API typedef enum dktp_errors
{
    dktp_error_none = 0x00U,                     
    dktp_error_accept_fail = 0x01U,                   
    dktp_error_authentication_failure = 0x02U,     
    dktp_error_bad_keep_alive = 0x03U,             
    dktp_error_channel_down = 0x04U,             
    dktp_error_connection_failure = 0x05U,         
    dktp_error_connect_failure = 0x06U,               
    dktp_error_decapsulation_failure = 0x07U,       
    dktp_error_decryption_failure = 0x08U,         
    dktp_error_establish_failure = 0x09U,           
    dktp_error_exchange_failure = 0x0AU,         
    dktp_error_hash_invalid = 0x0BU,             
    dktp_error_hosts_exceeded = 0x0CU,             
    dktp_error_invalid_input = 0x0DU,               
    dktp_error_invalid_request = 0x0EU,               
    dktp_error_keepalive_expired = 0x0FU,           
    dktp_error_keepalive_timeout = 0x10U,           
    dktp_error_key_expired = 0x11U,                   
    dktp_error_key_unrecognized = 0x12U,         
    dktp_error_keychain_fail = 0x13U,               
    dktp_error_listener_fail = 0x14U,               
    dktp_error_memory_allocation = 0x15U,           
    dktp_error_message_time_invalid = 0x06U,     
    dktp_error_packet_unsequenced = 0x17U,         
    dktp_error_random_failure = 0x18U,             
    dktp_error_receive_failure = 0x19U,               
    dktp_error_transmit_failure = 0x1AU,         
    dktp_error_unknown_protocol = 0x1BU,         
    dktp_error_verify_failure = 0x1CU,             
    dktp_error_peer_key_mismatch = 0x1DU,           
} dktp_errors;

DKTP_EXPORT_API typedef enum dktp_flags
{
    dktp_flag_none = 0x00U,                           
    dktp_flag_connect_request = 0x01U,             
    dktp_flag_connect_response = 0x02U,               
    dktp_flag_connection_terminate = 0x03U,           
    dktp_flag_encrypted_message = 0x04U,         
    dktp_flag_exstart_request = 0x05U,             
    dktp_flag_exstart_response = 0x06U,               
    dktp_flag_exchange_request = 0x07U,               
    dktp_flag_exchange_response = 0x08U,         
    dktp_flag_establish_request = 0x09U,         
    dktp_flag_establish_response = 0x0AU,           
    dktp_flag_keep_alive_request = 0x0BU,           
    dktp_flag_keep_alive_response = 0x0CU,         
    dktp_flag_remote_connected = 0x0DU,               
    dktp_flag_remote_terminated = 0x0EU,         
    dktp_flag_session_established = 0x0FU,         
    dktp_flag_session_establish_verify = 0x10U,       
    dktp_flag_unrecognized_protocol = 0x11U,     
    dktp_flag_asymmetric_ratchet_request = 0x12U,   
    dktp_flag_asymmetric_ratchet_response = 0x13U, 
    dktp_flag_symmetric_ratchet_request = 0x14U, 
    dktp_flag_transfer_request = 0x15U,               
    dktp_flag_error_condition = 0xFFU,             
} dktp_flags;

DKTP_EXPORT_API typedef struct dktp_asymmetric_cipher_keypair
{
    uint8_t* deckey;
    uint8_t* enckey;
} dktp_asymmetric_cipher_keypair;

DKTP_EXPORT_API typedef struct dktp_asymmetric_signature_keypair
{
    uint8_t* sigkey;
    uint8_t* verkey;
} dktp_asymmetric_signature_keypair;

DKTP_EXPORT_API typedef struct dktp_network_packet
{
    uint8_t flag;                                   
    uint32_t msglen;                              
    uint64_t sequence;                              
    uint64_t utctime;                                
    uint8_t* pmessage;                              
} dktp_network_packet;

DKTP_EXPORT_API typedef struct dktp_remote_peer_key
{
    uint64_t expiration;                          
    uint8_t config[DKTP_CONFIG_SIZE];             
    uint8_t keyid[DKTP_KEYID_SIZE];                 
    uint8_t pss[DKTP_SECRET_SIZE];       
    uint8_t verkey[DKTP_ASYMMETRIC_VERIFY_KEY_SIZE];
} dktp_remote_peer_key;

DKTP_EXPORT_API typedef struct dktp_local_peer_key
{
    uint64_t expiration;                          
    uint8_t config[DKTP_CONFIG_SIZE];             
    uint8_t keyid[DKTP_KEYID_SIZE];                 
    uint8_t peerid[DKTP_KEYID_SIZE];               
    uint8_t pss[DKTP_SECRET_SIZE];                   
    uint8_t sigkey[DKTP_ASYMMETRIC_SIGNING_KEY_SIZE];
    uint8_t verkey[DKTP_ASYMMETRIC_VERIFY_KEY_SIZE]; 
} dktp_local_peer_key;

DKTP_EXPORT_API typedef struct dktp_keepalive_state
{
    qsc_socket target;                                
    uint64_t etime;                                    
    uint64_t seqctr;                              
    bool recd;                                      
} dktp_keepalive_state;

DKTP_EXPORT_API typedef struct dktp_connection_state
{
    qsc_socket target;                                
    qsc_rcs_state rxcpr;                           
    qsc_rcs_state txcpr;                           
#if defined(DKTP_ASYMMETRIC_RATCHET)
    uint8_t deckey[DKTP_ASYMMETRIC_DECAPSULATION_KEY_SIZE]; 
    uint8_t enckey[DKTP_ASYMMETRIC_ENCAPSULATION_KEY_SIZE]; 
    uint8_t pssl[DKTP_SECRET_SIZE];                 
    uint8_t pssr[DKTP_SECRET_SIZE];                 
    uint8_t sigkey[DKTP_ASYMMETRIC_SIGNING_KEY_SIZE]; 
    uint8_t verkey[DKTP_ASYMMETRIC_VERIFY_KEY_SIZE];  
#endif
    uint64_t rxseq;                                    
    uint64_t txseq;                                    
    uint32_t cid;                                    
    dktp_flags exflag;                              
    bool receiver;                                  
} dktp_connection_state;

DKTP_EXPORT_API void dktp_connection_close(dktp_connection_state* cns, dktp_errors err, bool notify);

DKTP_EXPORT_API void dktp_connection_state_dispose(dktp_connection_state* cns);

DKTP_EXPORT_API const char* dktp_error_to_string(dktp_errors error);

DKTP_EXPORT_API void dktp_header_create(dktp_network_packet* packetout, dktp_flags flag, uint64_t sequence, uint32_t msglen);

DKTP_EXPORT_API dktp_errors dktp_header_validate(dktp_connection_state* cns, const dktp_network_packet* packetin, dktp_flags kexflag, dktp_flags pktflag, uint64_t sequence, uint32_t msglen);

DKTP_EXPORT_API void dktp_generate_keypair(dktp_remote_peer_key* enckey, dktp_local_peer_key* deckey, const uint8_t keyid[DKTP_KEYID_SIZE]);

DKTP_EXPORT_API const char* dktp_get_error_description(dktp_messages emsg);

DKTP_EXPORT_API void dktp_log_error(dktp_messages emsg, qsc_socket_exceptions err, const char* msg);

DKTP_EXPORT_API void dktp_log_message(dktp_messages emsg);

DKTP_EXPORT_API void dktp_log_write(dktp_messages emsg, const char* msg);

DKTP_EXPORT_API void dktp_packet_clear(dktp_network_packet* packet);

DKTP_EXPORT_API dktp_errors dktp_packet_decrypt(dktp_connection_state* cns, uint8_t* message, size_t* msglen, const dktp_network_packet* packetin);

DKTP_EXPORT_API dktp_errors dktp_packet_encrypt(dktp_connection_state* cns, dktp_network_packet* packetout, const uint8_t* message, size_t msglen);

DKTP_EXPORT_API void dktp_packet_error_message(dktp_network_packet* packet, dktp_errors error);

DKTP_EXPORT_API void dktp_packet_header_deserialize(const uint8_t* header, dktp_network_packet* packet);

DKTP_EXPORT_API void dktp_packet_header_serialize(const dktp_network_packet* packet, uint8_t* header);

DKTP_EXPORT_API void dktp_packet_set_utc_time(dktp_network_packet* packet);

DKTP_EXPORT_API bool dktp_packet_time_valid(const dktp_network_packet* packet);

DKTP_EXPORT_API size_t dktp_packet_to_stream(const dktp_network_packet* packet, uint8_t* pstream);

DKTP_EXPORT_API void dktp_local_peer_key_deserialize(dktp_local_peer_key* lpk, const uint8_t slpk[DKTP_LOCAL_PEER_KEY_ENCODED_SIZE]);

DKTP_EXPORT_API void dktp_local_peer_key_erase(dktp_local_peer_key* lpk);

DKTP_EXPORT_API void dktp_local_peer_key_serialize(uint8_t slpk[DKTP_LOCAL_PEER_KEY_ENCODED_SIZE], const dktp_local_peer_key* lpk);

DKTP_EXPORT_API void dktp_remote_peer_key_erase(dktp_remote_peer_key* rpk);

DKTP_EXPORT_API bool dktp_remote_peer_key_compare(const dktp_remote_peer_key* a, const dktp_remote_peer_key* b);

DKTP_EXPORT_API void dktp_remote_peer_key_deserialize(dktp_remote_peer_key* rpk, const uint8_t srpk[DKTP_REMOTE_PEER_KEY_ENCODED_SIZE]);

DKTP_EXPORT_API void dktp_remote_peer_key_serialize(uint8_t srpk[DKTP_REMOTE_PEER_KEY_ENCODED_SIZE], const dktp_remote_peer_key* rpk);

DKTP_EXPORT_API void dktp_stream_to_packet(const uint8_t* pstream, dktp_network_packet* packet);
 
#endif