include/ascii-chat/crypto/crypto.h

Go to the documentation of this file.

#pragma once

 
#include <ascii-chat/crypto/sizes.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
// libsodium includes
#include <sodium.h>
 
// Include required types
#include "sizes.h"
#include "key_types.h"    // For private_key_t
#include "../common.h"    // For asciichat_error_t
#include "../util/time.h" // For NS_PER_SEC_INT


#define CRYPTO_MAX_PLAINTEXT_SIZE ((size_t)1024 * 1024)
#define CRYPTO_MAX_CIPHERTEXT_SIZE (CRYPTO_MAX_PLAINTEXT_SIZE + CRYPTO_MAC_SIZE)


typedef struct crypto_context_t {
  uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];      
  uint8_t private_key[CRYPTO_PRIVATE_KEY_SIZE];    
  uint8_t peer_public_key[CRYPTO_PUBLIC_KEY_SIZE]; 
  uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];      

  uint8_t password_key[CRYPTO_ENCRYPTION_KEY_SIZE]; 
  uint8_t password_salt[CRYPTO_SALT_SIZE];          

  uint8_t nonce_size;          
  uint8_t mac_size;            
  uint8_t hmac_size;           
  uint8_t encryption_key_size; 
  uint8_t auth_challenge_size; 

  uint16_t public_key_size;      
  uint16_t private_key_size;     
  uint16_t shared_key_size;      
  uint16_t auth_public_key_size; 
  uint16_t salt_size;            
  uint16_t signature_size;       

  bool initialized;           
  bool has_password;          
  bool key_exchange_complete; 
  bool peer_key_received;     
  bool handshake_complete;    
  bool encrypt_data;          

  uint8_t auth_nonce[AUTH_CHALLENGE_SIZE]; 
  uint8_t auth_hmac[CRYPTO_HMAC_SIZE];     

  uint64_t nonce_counter;              
  uint8_t session_id[SESSION_ID_SIZE]; 

  uint64_t rekey_packet_count;    
  time_t rekey_last_time;         
  time_t rekey_last_request_time; 
  bool rekey_in_progress;         
  uint8_t rekey_failure_count;    

  uint8_t temp_public_key[CRYPTO_PUBLIC_KEY_SIZE];   
  uint8_t temp_private_key[CRYPTO_PRIVATE_KEY_SIZE]; 
  uint8_t temp_shared_key[CRYPTO_SHARED_KEY_SIZE];   
  bool has_temp_key;                                 

  uint64_t rekey_packet_threshold; 
  time_t rekey_time_threshold;     

  uint64_t bytes_encrypted; 
  uint64_t bytes_decrypted; 
  uint64_t rekey_count;     

  struct crypto_session *session; 
  bool server_role, server_role_known;
 
} crypto_context_t;

typedef enum {
  CRYPTO_OK = 0,                              
  CRYPTO_ERROR_INIT_FAILED = -1,              
  CRYPTO_ERROR_INVALID_PARAMS = -2,           
  CRYPTO_ERROR_MEMORY = -3,                   
  CRYPTO_ERROR_LIBSODIUM = -4,                
  CRYPTO_ERROR_KEY_GENERATION = -5,           
  CRYPTO_ERROR_PASSWORD_DERIVATION = -6,      
  CRYPTO_ERROR_ENCRYPTION = -7,               
  CRYPTO_ERROR_DECRYPTION = -8,               
  CRYPTO_ERROR_INVALID_MAC = -9,              
  CRYPTO_ERROR_BUFFER_TOO_SMALL = -10,        
  CRYPTO_ERROR_KEY_EXCHANGE_INCOMPLETE = -11, 
  CRYPTO_ERROR_NONCE_EXHAUSTED = -12,         
  CRYPTO_ERROR_REKEY_IN_PROGRESS = -13,       
  CRYPTO_ERROR_REKEY_FAILED = -14,            
  CRYPTO_ERROR_REKEY_RATE_LIMITED = -15       
} crypto_result_t;
 
// =============================================================================
// SSH Key Structure Constants
// =============================================================================
 
// SSH key blob structure sizes
#define SSH_KEY_TYPE_LENGTH_SIZE 4       // Length of "ssh-ed25519" (4 bytes)
#define SSH_KEY_TYPE_STRING_SIZE 11      // "ssh-ed25519" string length
#define SSH_KEY_PUBLIC_KEY_LENGTH_SIZE 4 // Length of public key (4 bytes)
#define SSH_KEY_PUBLIC_KEY_SIZE 32       // Ed25519 public key size
#define SSH_KEY_HEADER_SIZE                                                                                            \
  (SSH_KEY_TYPE_LENGTH_SIZE + SSH_KEY_TYPE_STRING_SIZE + SSH_KEY_PUBLIC_KEY_LENGTH_SIZE + SSH_KEY_PUBLIC_KEY_SIZE)
 
// =============================================================================
// Cryptographic Key Size Constants
// =============================================================================

#define CRYPTO_KEY_SIZE 32

#define CRYPTO_FINGERPRINT_SIZE 32
 
// =============================================================================
// Hex String Size Constants
// =============================================================================


#define CRYPTO_HEX_KEY_SIZE 64
#define CRYPTO_HEX_KEY_SIZE_NULL 65
#define CRYPTO_HEX_KEY64_SIZE 128
#define CRYPTO_HEX_KEY64_SIZE_NULL 129

 
// =============================================================================
// String Literal Constants
// =============================================================================


#define SSH_ED25519_KEY_TYPE "ssh-ed25519"
#define X25519_KEY_TYPE "x25519"
#define NO_IDENTITY_MARKER "no-identity"

 
// =============================================================================
// File Permission Constants
// =============================================================================
 
#ifndef _WIN32
#define SSH_KEY_PERMISSIONS_MASK (S_IRWXG | S_IRWXO) // Group and other permissions mask
#define SSH_KEY_RECOMMENDED_PERMISSIONS 0600         // Recommended SSH key permissions
#endif
 
// =============================================================================
// String and Display Constants
// =============================================================================


crypto_result_t crypto_init(crypto_context_t *ctx);

crypto_result_t crypto_init_with_password(crypto_context_t *ctx, const char *password);

void crypto_destroy(crypto_context_t *ctx);

crypto_result_t crypto_generate_keypair(crypto_context_t *ctx);



crypto_result_t crypto_get_public_key(const crypto_context_t *ctx, uint8_t *public_key_out);

crypto_result_t crypto_set_peer_public_key(crypto_context_t *ctx, const uint8_t *peer_public_key);

bool crypto_is_ready(const crypto_context_t *ctx);



crypto_result_t crypto_validate_password(const char *password);

crypto_result_t crypto_derive_password_key(crypto_context_t *ctx, const char *password);

bool crypto_verify_password(const crypto_context_t *ctx, const char *password);

crypto_result_t crypto_derive_password_encryption_key(const char *password,
                                                      uint8_t encryption_key[CRYPTO_ENCRYPTION_KEY_SIZE]);


crypto_result_t crypto_encrypt(crypto_context_t *ctx, const uint8_t *plaintext, size_t plaintext_len,
                               uint8_t *ciphertext_out, size_t ciphertext_out_size, size_t *ciphertext_len_out);

crypto_result_t crypto_decrypt(crypto_context_t *ctx, const uint8_t *ciphertext, size_t ciphertext_len,
                               uint8_t *plaintext_out, size_t plaintext_out_size, size_t *plaintext_len_out);



const char *crypto_result_to_string(crypto_result_t result);

void crypto_get_status(const crypto_context_t *ctx, char *status_buffer, size_t buffer_size);

bool crypto_secure_compare(const uint8_t *lhs, const uint8_t *rhs, size_t len);

crypto_result_t crypto_random_bytes(uint8_t *buffer, size_t len);



crypto_result_t crypto_generate_nonce(uint8_t nonce[AUTH_CHALLENGE_SIZE]);

crypto_result_t crypto_compute_hmac(crypto_context_t *ctx, const uint8_t key[HMAC_SHA256_KEY_SIZE],
                                    const uint8_t data[AUTH_CHALLENGE_SIZE], uint8_t hmac[HMAC_SHA256_SIZE]);

crypto_result_t crypto_compute_hmac_ex(const crypto_context_t *ctx, const uint8_t key[HMAC_SHA256_KEY_SIZE],
                                       const uint8_t *data, size_t data_len, uint8_t hmac[HMAC_SHA256_SIZE]);

bool crypto_verify_hmac(const uint8_t key[HMAC_SHA256_KEY_SIZE], const uint8_t data[AUTH_CHALLENGE_SIZE],
                        const uint8_t expected_hmac[HMAC_SHA256_SIZE]);

bool crypto_verify_hmac_ex(const uint8_t key[HMAC_SHA256_KEY_SIZE], const uint8_t *data, size_t data_len,
                           const uint8_t expected_hmac[HMAC_SHA256_SIZE]);

 
// =============================================================================
// High-level authentication helpers (shared between client and server)
// =============================================================================


crypto_result_t crypto_compute_auth_response(const crypto_context_t *ctx, const uint8_t nonce[AUTH_CHALLENGE_SIZE],
                                             uint8_t hmac_out[HMAC_SHA256_SIZE]);

bool crypto_verify_auth_response(const crypto_context_t *ctx, const uint8_t nonce[AUTH_CHALLENGE_SIZE],
                                 const uint8_t expected_hmac[HMAC_SHA256_SIZE]);

crypto_result_t crypto_create_auth_challenge(const crypto_context_t *ctx, uint8_t *packet_out, size_t packet_size,
                                             size_t *packet_len_out);

crypto_result_t crypto_process_auth_challenge(crypto_context_t *ctx, const uint8_t *packet, size_t packet_len);

crypto_result_t crypto_process_auth_response(crypto_context_t *ctx, const uint8_t *packet, size_t packet_len);



crypto_result_t crypto_create_public_key_packet(const crypto_context_t *ctx, uint8_t *packet_out, size_t packet_size,
                                                size_t *packet_len_out);

crypto_result_t crypto_process_public_key_packet(crypto_context_t *ctx, const uint8_t *packet, size_t packet_len);

crypto_result_t crypto_create_encrypted_packet(crypto_context_t *ctx, const uint8_t *data, size_t data_len,
                                               uint8_t *packet_out, size_t packet_size, size_t *packet_len_out);

crypto_result_t crypto_process_encrypted_packet(crypto_context_t *ctx, const uint8_t *packet, size_t packet_len,
                                                uint8_t *data_out, size_t data_size, size_t *data_len_out);



asciichat_error_t crypto_compute_password_hmac(crypto_context_t *ctx, const uint8_t *password_key, const uint8_t *nonce,
                                               const uint8_t *shared_secret, uint8_t *hmac_out);

asciichat_error_t crypto_verify_peer_signature(const uint8_t *peer_public_key, const uint8_t *ephemeral_key,
                                               size_t ephemeral_key_size, const uint8_t *signature);

asciichat_error_t crypto_sign_ephemeral_key(const private_key_t *private_key, const uint8_t *ephemeral_key,
                                            size_t ephemeral_key_size, uint8_t *signature_out);

void crypto_combine_auth_data(const uint8_t *hmac, const uint8_t *challenge_nonce, uint8_t *combined_out);

void crypto_extract_auth_data(const uint8_t *combined_data, uint8_t *hmac_out, uint8_t *challenge_out);



#define REKEY_MIN_INTERVAL (3LL * NS_PER_SEC_INT)
#define REKEY_DEFAULT_TIME_THRESHOLD (3600LL * NS_PER_SEC_INT)
#define REKEY_DEFAULT_PACKET_THRESHOLD 1000000
#define REKEY_TEST_TIME_THRESHOLD (30LL * NS_PER_SEC_INT)
#define REKEY_TEST_PACKET_THRESHOLD 1000
#define REKEY_MAX_FAILURE_COUNT 10
#define REKEY_MIN_REQUEST_INTERVAL (60LL * NS_PER_SEC_INT)

bool crypto_should_rekey(const crypto_context_t *ctx);

crypto_result_t crypto_rekey_init(crypto_context_t *ctx);

crypto_result_t crypto_rekey_process_request(crypto_context_t *ctx, const uint8_t *peer_new_public_key);

crypto_result_t crypto_rekey_process_response(crypto_context_t *ctx, const uint8_t *peer_new_public_key);

crypto_result_t crypto_rekey_commit(crypto_context_t *ctx);

void crypto_rekey_abort(crypto_context_t *ctx);

void crypto_get_rekey_status(const crypto_context_t *ctx, char *status_buffer, size_t buffer_size);
 /* Session Rekeying Protocol */
 /* crypto */