identity.h File Reference

Go to the source code of this file.

Functions
asciichat_error_t	acds_identity_generate (uint8_t public_key[32], uint8_t secret_key[64])
	Generate new Ed25519 keypair.
asciichat_error_t	acds_identity_load (const char *path, uint8_t public_key[32], uint8_t secret_key[64])
	Load identity from file.
asciichat_error_t	acds_identity_save (const char *path, const uint8_t public_key[32], const uint8_t secret_key[64])
	Save identity to file.
void	acds_identity_fingerprint (const uint8_t public_key[32], char fingerprint[(32 *2+1)])
	Compute SHA256 fingerprint of public key.
asciichat_error_t	acds_identity_default_path (char *path_out, size_t path_size)
	Get default identity file path for current platform.

Function Documentation

acds_identity_default_path()

asciichat_error_t acds_identity_default_path	(	char *	path_out,
		size_t	path_size )

Get default identity file path for current platform.

Parameters

path_out	Output buffer for path (should be at least 256 bytes)
path_size	Size of output buffer

Returns

ASCIICHAT_OK on success, error code otherwise

Returns:

• Unix: ~/.config/ascii-chat/acds_identity
• Windows: APPDATA%\ascii-chat\acds_identity

Definition at line 155 of file identity.c.

                                                                               {
  if (!path_out || path_size == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "path_out cannot be NULL and path_size must be > 0");
  }
 
  // Get platform-specific config directory (~/.config/ascii-chat/ or %APPDATA%\ascii-chat\‍)
  char *config_dir = platform_get_config_dir();
  if (!config_dir) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to get config directory");
  }
 
  // Append "acds_identity" to config directory
  int written = safe_snprintf(path_out, path_size, "%sacds_identity", config_dir);
  SAFE_FREE(config_dir);
 
  if (written < 0 || (size_t)written >= path_size) {
    return SET_ERRNO(ERROR_CONFIG, "Path buffer too small");
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_INVALID_PARAM, SAFE_FREE, safe_snprintf(), and SET_ERRNO.

Referenced by discovery_session_create().

acds_identity_fingerprint()

void acds_identity_fingerprint	(	const uint8_t	public_key[32],
		char	fingerprint[(32 *2+1)] )

Compute SHA256 fingerprint of public key.

Parameters

public_key	32-byte Ed25519 public key
fingerprint	Output buffer for 65 bytes (64 hex chars + null terminator)

Definition at line 134 of file identity.c.

                                                                     {
  if (!public_key || !fingerprint) {
    log_error("NULL parameters");
    return;
  }
 
  // Compute SHA256 hash of public key
  uint8_t hash[crypto_hash_sha256_BYTES];
  if (key_fingerprint_digest(public_key, hash) != ASCIICHAT_OK) {
    fingerprint[0] = '\0';
    return;
  }
 
  // Convert to hex string
  for (int i = 0; i < 32; i++) {
    safe_snprintf(&fingerprint[i * 2], 3, "%02x", hash[i]);
  }
  fingerprint[64] = '\0';
}

References ASCIICHAT_OK, ED25519_PUBLIC_KEY_SIZE, HEX_STRING_SIZE_32, key_fingerprint_digest(), log_error, and safe_snprintf().

Referenced by discovery_session_create().

acds_identity_generate()

asciichat_error_t acds_identity_generate	(	uint8_t	public_key[32],
		uint8_t	secret_key[64] )

Generate new Ed25519 keypair.

Parameters

public_key	Output buffer for 32-byte public key
secret_key	Output buffer for 64-byte secret key

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 22 of file identity.c.

                                                                                       {
  if (!public_key || !secret_key) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "public_key and secret_key cannot be NULL");
  }
 
  // Generate Ed25519 keypair using libsodium
  if (crypto_sign_keypair(public_key, secret_key) != 0) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to generate Ed25519 keypair");
  }
 
  log_debug("Generated new Ed25519 identity keypair");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ED25519_PRIVATE_KEY_SIZE, ED25519_PUBLIC_KEY_SIZE, ERROR_CRYPTO, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.

Referenced by discovery_session_create().

acds_identity_load()

asciichat_error_t acds_identity_load	(	const char *	path,
		uint8_t	public_key[32],
		uint8_t	secret_key[64] )

Load identity from file.

Parameters

path	Path to identity file (e.g., ~/.config/ascii-chat/acds_identity)
public_key	Output buffer for 32-byte public key
secret_key	Output buffer for 64-byte secret key

Returns

ASCIICHAT_OK on success, ERROR_CONFIG if file doesn't exist

Definition at line 37 of file identity.c.

                                                                                   {
  if (!path || !public_key || !secret_key) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "path, public_key, and secret_key cannot be NULL");
  }
 
  // Open file for reading
  FILE *fp = platform_fopen("file_stream", path, "rb");
  if (!fp) {
    if (errno == ENOENT) {
      return SET_ERRNO(ERROR_CONFIG, "Identity file does not exist: %s", path);
    }
    return SET_ERRNO_SYS(ERROR_CONFIG, "Failed to open identity file: %s", path);
  }
 
  // Preserve the original raw libsodium identity format while accepting the
  // OpenSSH Ed25519 private keys used by the rest of ascii-chat.
  uint8_t raw_secret[crypto_sign_SECRETKEYBYTES];
  const size_t raw_bytes = fread(raw_secret, 1, sizeof(raw_secret), fp);
  const int trailing_byte = fgetc(fp);
  fclose(fp);
  if (raw_bytes == sizeof(raw_secret) && trailing_byte == EOF) {
    uint8_t derived_public[crypto_sign_PUBLICKEYBYTES];
    if (crypto_sign_ed25519_sk_to_pk(derived_public, raw_secret) != 0) {
      sodium_memzero(raw_secret, sizeof(raw_secret));
      return SET_ERRNO(ERROR_CONFIG, "Identity file contains an invalid Ed25519 secret key: %s", path);
    }
    memcpy(secret_key, raw_secret, sizeof(raw_secret));
    memcpy(public_key, derived_public, sizeof(derived_public));
    sodium_memzero(raw_secret, sizeof(raw_secret));
    log_info("Loaded raw Ed25519 identity from %s", path);
    return ASCIICHAT_OK;
  }
  sodium_memzero(raw_secret, sizeof(raw_secret));
 
  private_key_t parsed_key = {0};
  asciichat_error_t parse_result = parse_ssh_private_key(path, &parsed_key);
  if (parse_result != ASCIICHAT_OK) {
    sodium_memzero(&parsed_key, sizeof(parsed_key));
    return parse_result;
  }
  if (parsed_key.type != KEY_TYPE_ED25519) {
    sodium_memzero(&parsed_key, sizeof(parsed_key));
    return SET_ERRNO(ERROR_CONFIG, "Discovery identity key must be Ed25519: %s", path);
  }
 
  memcpy(secret_key, parsed_key.key.ed25519, crypto_sign_SECRETKEYBYTES);
  memcpy(public_key, parsed_key.public_key, crypto_sign_PUBLICKEYBYTES);
  sodium_memzero(&parsed_key, sizeof(parsed_key));
  log_info("Loaded OpenSSH Ed25519 identity from %s", path);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, private_key_t::ed25519, ED25519_PRIVATE_KEY_SIZE, ED25519_PUBLIC_KEY_SIZE, errno, ERROR_CONFIG, ERROR_INVALID_PARAM, private_key_t::key, KEY_TYPE_ED25519, log_info, parse_ssh_private_key(), private_key_t::public_key, SET_ERRNO, SET_ERRNO_SYS, and private_key_t::type.

Referenced by discovery_session_create().

acds_identity_save()

asciichat_error_t acds_identity_save	(	const char *	path,
		const uint8_t	public_key[32],
		const uint8_t	secret_key[64] )

Save identity to file.

Parameters

path	Path to identity file
public_key	32-byte public key
secret_key	64-byte secret key

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 90 of file identity.c.

                                                                                         {
  if (!path || !public_key || !secret_key) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "path, public_key, and secret_key cannot be NULL");
  }
 
  // Extract directory path and create all parent directories
  char dir_path[PLATFORM_MAX_PATH_LENGTH];
  SAFE_STRNCPY(dir_path, path, sizeof(dir_path));
 
  // Find last directory separator
  char *last_sep = strrchr(dir_path, '/');
  if (!last_sep) {
    last_sep = strrchr(dir_path, '\\');
  }
 
  if (last_sep) {
    *last_sep = '\0';
 
    // Create directory recursively (mkdir -p equivalent)
    asciichat_error_t result = platform_mkdir_recursive(dir_path, 0700);
    if (result != ASCIICHAT_OK) {
      return result;
    }
  }
 
  // Open file for writing (mode 0600 = owner read/write only)
  int fd = platform_open("identity_file", path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
  if (fd < 0) {
    return SET_ERRNO_SYS(ERROR_CONFIG, "Failed to create identity file: %s", path);
  }
 
  // Write secret key (64 bytes)
  ssize_t written = write(fd, secret_key, 64);
  close(fd);
 
  if (written != 64) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to write identity file (wrote %zd/64 bytes): %s", written, path);
  }
 
  log_info("Saved identity to %s", path);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ED25519_PRIVATE_KEY_SIZE, ED25519_PUBLIC_KEY_SIZE, ERROR_CONFIG, ERROR_INVALID_PARAM, log_info, PLATFORM_MAX_PATH_LENGTH, SAFE_STRNCPY, SET_ERRNO, and SET_ERRNO_SYS.

Referenced by discovery_session_create().