crypto/handshake/common.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdbool.h>
#include "../../platform/socket.h"
#include "../../crypto/crypto.h"
#include "../../crypto/keys.h"
#include "../../network/packet/packet.h"
 
struct acip_transport;
 
#define AUTH_REQUIRE_PASSWORD 0x01
#define AUTH_REQUIRE_CLIENT_KEY 0x02
 
typedef enum {
  CRYPTO_HANDSHAKE_DISABLED = 0,   
  CRYPTO_HANDSHAKE_INIT,           
  CRYPTO_HANDSHAKE_KEY_EXCHANGE,   
  CRYPTO_HANDSHAKE_AUTHENTICATING, 
  CRYPTO_HANDSHAKE_READY,          
  CRYPTO_HANDSHAKE_FAILED          
} crypto_handshake_state_t;
 
typedef struct crypto_handshake_context_t {
  crypto_context_t crypto_ctx;    
  crypto_handshake_state_t state; 
  bool is_server;                 
  public_key_t server_public_key;   
  private_key_t server_private_key; 
  public_key_t client_public_key;   
  private_key_t client_private_key; 
  char expected_server_key[256];    
  char client_gpg_key_id[41]; 
  char server_hostname[256]; 
  char server_ip[256];       
  uint16_t server_port;      
  bool verify_server_key;                          
  bool require_client_auth;                        
  bool server_uses_client_auth;                    
  char client_keys_path[PLATFORM_MAX_PATH_LENGTH]; 
  public_key_t *client_whitelist;   
  size_t num_whitelisted_clients;   
  public_key_t client_ed25519_key;  
  bool client_ed25519_key_verified; 
  bool client_sent_identity;        
  bool has_password;  
  char password[256]; 
  uint8_t client_challenge_nonce[32]; 
} crypto_handshake_context_t;
 
asciichat_error_t crypto_handshake_init(const char *name, crypto_handshake_context_t *ctx, bool is_server);
 
asciichat_error_t crypto_handshake_set_parameters(crypto_handshake_context_t *ctx,
                                                  const crypto_parameters_packet_t *params);
 
asciichat_error_t crypto_handshake_validate_packet_size(const crypto_handshake_context_t *ctx, uint16_t packet_type,
                                                        size_t packet_size);
 
asciichat_error_t crypto_handshake_init_with_password(const char *name, crypto_handshake_context_t *ctx, bool is_server,
                                                      const char *password);
 
void crypto_handshake_destroy(crypto_handshake_context_t *ctx);
 
bool crypto_handshake_is_ready(const crypto_handshake_context_t *ctx);
 
const crypto_context_t *crypto_handshake_get_context(const crypto_handshake_context_t *ctx);
 
asciichat_error_t crypto_handshake_encrypt_packet(const crypto_handshake_context_t *ctx, const uint8_t *plaintext,
                                                  size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size,
                                                  size_t *ciphertext_len);
 
asciichat_error_t crypto_handshake_decrypt_packet(const crypto_handshake_context_t *ctx, const uint8_t *ciphertext,
                                                  size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size,
                                                  size_t *plaintext_len);
 
asciichat_error_t crypto_encrypt_packet_or_passthrough(const crypto_handshake_context_t *ctx, bool crypto_ready,
                                                       const uint8_t *plaintext, size_t plaintext_len,
                                                       uint8_t *ciphertext, size_t ciphertext_size,
                                                       size_t *ciphertext_len);
 
asciichat_error_t crypto_decrypt_packet_or_passthrough(const crypto_handshake_context_t *ctx, bool crypto_ready,
                                                       const uint8_t *ciphertext, size_t ciphertext_len,
                                                       uint8_t *plaintext, size_t plaintext_size,
                                                       size_t *plaintext_len);
 
asciichat_error_t crypto_handshake_rekey_request(crypto_handshake_context_t *ctx, struct acip_transport *transport);
 
asciichat_error_t crypto_handshake_rekey_response(crypto_handshake_context_t *ctx, struct acip_transport *transport);
 
asciichat_error_t crypto_handshake_rekey_complete(crypto_handshake_context_t *ctx, struct acip_transport *transport);
 
asciichat_error_t crypto_handshake_process_rekey_request(crypto_handshake_context_t *ctx, const uint8_t *packet,
                                                         size_t packet_len);
 
asciichat_error_t crypto_handshake_process_rekey_response(crypto_handshake_context_t *ctx, const uint8_t *packet,
                                                          size_t packet_len);
 
asciichat_error_t crypto_handshake_process_rekey_complete(crypto_handshake_context_t *ctx, const uint8_t *packet,
                                                          size_t packet_len);
 
bool crypto_handshake_should_rekey(const crypto_handshake_context_t *ctx);