include/ascii-chat/crypto/crypto.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
// libsodium includes
#include <sodium.h>
 
// Include required types
#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 MIN_PASSWORD_LENGTH 8
#define MAX_PASSWORD_LENGTH 256
 
#define X25519_KEY_SIZE 32
#define ED25519_PUBLIC_KEY_SIZE 32
#define ED25519_PRIVATE_KEY_SIZE 64
#define ED25519_SIGNATURE_SIZE 64
#define XSALSA20_NONCE_SIZE 24
#define POLY1305_MAC_SIZE 16
#define HMAC_SHA256_SIZE 32
#define ARGON2ID_SALT_SIZE 32
#define SECRETBOX_KEY_SIZE 32
#define AES256_KEY_SIZE 32
#define AES_IV_SIZE 16
#define AES256_DERIVED_SIZE (AES256_KEY_SIZE + AES_IV_SIZE)
#define SESSION_ID_SIZE 16
 
#define CRYPTO_PUBLIC_KEY_SIZE X25519_KEY_SIZE
#define CRYPTO_PRIVATE_KEY_SIZE X25519_KEY_SIZE
#define CRYPTO_SHARED_KEY_SIZE X25519_KEY_SIZE
#define CRYPTO_ED25519_PUBLIC_KEY_SIZE ED25519_PUBLIC_KEY_SIZE
#define CRYPTO_ED25519_PRIVATE_KEY_SIZE ED25519_PRIVATE_KEY_SIZE
#define CRYPTO_ED25519_SIGNATURE_SIZE ED25519_SIGNATURE_SIZE
#define CRYPTO_NONCE_SIZE XSALSA20_NONCE_SIZE
#define CRYPTO_SALT_SIZE ARGON2ID_SALT_SIZE
#define CRYPTO_ENCRYPTION_KEY_SIZE SECRETBOX_KEY_SIZE
#define CRYPTO_MAC_SIZE POLY1305_MAC_SIZE
#define CRYPTO_HMAC_SIZE HMAC_SHA256_SIZE
 
#define AUTH_HMAC_SIZE 32
#define AUTH_CHALLENGE_SIZE 32
#define AUTH_COMBINED_SIZE (AUTH_HMAC_SIZE + AUTH_CHALLENGE_SIZE)
#define AUTH_SIGNATURE_SIZE 64
#define AUTH_SIGNATURE_COMBINED_SIZE (AUTH_SIGNATURE_SIZE + AUTH_CHALLENGE_SIZE)
 
#define AUTH_CHALLENGE_FLAGS_SIZE 1
#define AUTH_CHALLENGE_PACKET_SIZE (AUTH_CHALLENGE_FLAGS_SIZE + AUTH_CHALLENGE_SIZE)
 
#define AUTH_RESPONSE_PASSWORD_SIZE (AUTH_HMAC_SIZE + AUTH_CHALLENGE_SIZE)
#define AUTH_RESPONSE_SIGNATURE_SIZE (AUTH_SIGNATURE_SIZE + AUTH_CHALLENGE_SIZE)
 
#define SERVER_AUTH_RESPONSE_SIZE AUTH_HMAC_SIZE
 
#define MAX_AUTH_FAILED_PACKET_SIZE 256
#define MAX_ENCRYPTED_PACKET_SIZE 65536
 
#define HEX_STRING_SIZE_32 (32 * 2 + 1)
#define HEX_STRING_SIZE_64 (64 * 2 + 1)
#define PASSWORD_BUFFER_SIZE 256
#define ZERO_KEY_SIZE X25519_KEY_SIZE
 
#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[16]; 
  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;     
} 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
// =============================================================================
 
#define MAX_COMMENT_LEN 256    // Maximum key comment length
#define MAX_GPG_KEYGRIP_LEN 64 // Maximum GPG keygrip length
 
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[32]);
 
crypto_result_t crypto_compute_hmac(crypto_context_t *ctx, const uint8_t key[32], const uint8_t data[32],
                                    uint8_t hmac[32]);
 
crypto_result_t crypto_compute_hmac_ex(const crypto_context_t *ctx, const uint8_t key[32], const uint8_t *data,
                                       size_t data_len, uint8_t hmac[32]);
 
bool crypto_verify_hmac(const uint8_t key[32], const uint8_t data[32], const uint8_t expected_hmac[32]);
 
bool crypto_verify_hmac_ex(const uint8_t key[32], const uint8_t *data, size_t data_len,
                           const uint8_t expected_hmac[32]);
 
// =============================================================================
// 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[32],
                                             uint8_t hmac_out[32]);
 
bool crypto_verify_auth_response(const crypto_context_t *ctx, const uint8_t nonce[32], const uint8_t expected_hmac[32]);
 
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);