keys_validation.c

Go to the documentation of this file.

 
#include <ascii-chat/crypto/keys_validation.h>
#include <ascii-chat/common.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/util/utf8.h>
#include <ascii-chat/crypto/crypto.h> // Includes <sodium.h>
#include <ascii-chat/platform/filesystem.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/stat.h>
 
// =============================================================================
// Key Validation Implementation
// =============================================================================
 
asciichat_error_t validate_public_key(const public_key_t *key) {
  if (!key) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p", key);
    return ERROR_INVALID_PARAM;
  }
 
  // Check key type
  if (key->type == KEY_TYPE_UNKNOWN) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Key type is unknown");
    return ERROR_CRYPTO_KEY;
  }
 
  if (key->type != KEY_TYPE_ED25519 && key->type != KEY_TYPE_X25519 && key->type != KEY_TYPE_GPG) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Unsupported key type: %d", key->type);
    return ERROR_CRYPTO_KEY;
  }
 
  // Check key data is not all zeros
  bool is_zero = true;
  for (int i = 0; i < 32; i++) {
    if (key->key[i] != 0) {
      is_zero = false;
      break;
    }
  }
 
  if (is_zero) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Key data is all zeros");
    return ERROR_CRYPTO_KEY;
  }
 
  // Check comment length
  if (strlen(key->comment) >= MAX_COMMENT_LEN) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Key comment too long: %zu (maximum %d)", strlen(key->comment), MAX_COMMENT_LEN - 1);
    return ERROR_CRYPTO_KEY;
  }
 
  // Validate comment is valid UTF-8 (user-provided text in key files)
  if (key->comment[0] != '\0' && !utf8_is_valid(key->comment)) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Key comment contains invalid UTF-8 sequence");
    return ERROR_CRYPTO_KEY;
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t validate_private_key(const private_key_t *key) {
  if (!key) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p", key);
    return ERROR_INVALID_PARAM;
  }
 
  // Check key type
  if (key->type == KEY_TYPE_UNKNOWN) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Private key type is unknown");
    return ERROR_CRYPTO_KEY;
  }
 
  if (key->type != KEY_TYPE_ED25519 && key->type != KEY_TYPE_X25519) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Unsupported private key type: %d", key->type);
    return ERROR_CRYPTO_KEY;
  }
 
  // Check key data is not all zeros
  bool is_zero = true;
  size_t key_size = (key->type == KEY_TYPE_ED25519) ? 64 : 32;
 
  for (size_t i = 0; i < key_size; i++) {
    if (key->key.ed25519[i] != 0) {
      is_zero = false;
      break;
    }
  }
 
  if (is_zero) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Private key data is all zeros");
    return ERROR_CRYPTO_KEY;
  }
 
  // Check comment length
  if (strlen(key->key_comment) >= MAX_COMMENT_LEN) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Private key comment too long: %zu (maximum %d)", strlen(key->key_comment),
              MAX_COMMENT_LEN - 1);
    return ERROR_CRYPTO_KEY;
  }
 
  // Validate comment is valid UTF-8 (user-provided text in key files)
  if (key->key_comment[0] != '\0' && !utf8_is_valid(key->key_comment)) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "Private key comment contains invalid UTF-8 sequence");
    return ERROR_CRYPTO_KEY;
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t check_key_expiry(const public_key_t *key, bool *is_expired) {
  if (!key || !is_expired) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p, is_expired=%p", key, is_expired);
    return ERROR_INVALID_PARAM;
  }
 
  // For now, we don't implement key expiry checking
  // This would require parsing key creation dates and expiration times
  *is_expired = false;
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t validate_key_security(const char *key_path) {
  if (!key_path) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key_path=%p", key_path);
    return ERROR_INVALID_PARAM;
  }
 
  // Check file permissions
  asciichat_error_t perm_result = platform_validate_key_file_permissions(key_path);
  if (perm_result != ASCIICHAT_OK) {
    return perm_result;
  }
 
  // Additional security checks have been implemented in check_key_strength()
  // and check_key_patterns() functions. File permissions check is the critical one.
  // Known weak keys database would require periodic updates and is beyond scope.
 
  return ASCIICHAT_OK;
}
 
// =============================================================================
// Key Format Validation
// =============================================================================
 
asciichat_error_t validate_ssh_key_format(const char *key_text) {
  if (!key_text) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key_text=%p", key_text);
    return ERROR_INVALID_PARAM;
  }
 
  // Check for SSH key format
  if (strncmp(key_text, "ssh-ed25519 ", 12) != 0) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "SSH key does not start with 'ssh-ed25519 '");
    return ERROR_CRYPTO_KEY;
  }
 
  // Check for base64 data
  const char *base64_start = key_text + 12;
  while (*base64_start == ' ' || *base64_start == '\t') {
    base64_start++;
  }
 
  if (*base64_start == '\0' || *base64_start == '\n' || *base64_start == '\r') {
    SET_ERRNO(ERROR_CRYPTO_KEY, "SSH key has no base64 data");
    return ERROR_CRYPTO_KEY;
  }
 
  // Additional comprehensive SSH key validation (base64, blob structure, etc.)
  // would require full OpenSSH format parsing. Basic format check above is sufficient
  // to catch malformed keys. Full validation happens during key loading.
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t validate_gpg_key_format(const char *key_text) {
  if (!key_text) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key_text=%p", key_text);
    return ERROR_INVALID_PARAM;
  }
 
  // Check for GPG armor header
  if (strncmp(key_text, "-----BEGIN PGP", 14) != 0) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "GPG key does not start with armor header");
    return ERROR_CRYPTO_KEY;
  }
 
  // Check for GPG armor footer
  if (strstr(key_text, "-----END PGP") == NULL) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "GPG key does not contain armor footer");
    return ERROR_CRYPTO_KEY;
  }
 
  // Additional GPG key validation
  // Validate armor format (should have valid armor headers)
  bool has_version_header = (strstr(key_text, "Version:") != NULL);
  bool has_charset_header = (strstr(key_text, "Charset:") != NULL || strstr(key_text, "Version:") != NULL);
 
  if (!has_version_header && !has_charset_header) {
    // Missing common armor headers - might be incomplete
    log_warn("GPG armor missing version/charset headers - key might be incomplete");
  }
 
  // Validate base64 content (keys must have non-empty body between headers and footer)
  const char *start_pos = strstr(key_text, "\n\n");
  const char *end_pos = strstr(key_text, "\n-----END");
  if (start_pos && end_pos && start_pos < end_pos) {
    // -2 for \n\n at start_pos; check for underflow before casting to size_t
    ptrdiff_t diff = end_pos - start_pos - 2;
    if (diff <= 0) {
      SET_ERRNO(ERROR_CRYPTO_KEY, "GPG key has empty or malformed body content");
      return ERROR_CRYPTO_KEY;
    }
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t validate_x25519_key_format(const char *key_hex) {
  if (!key_hex) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key_hex=%p", key_hex);
    return ERROR_INVALID_PARAM;
  }
 
  // Check hex string length (32 bytes = 64 hex characters)
  size_t hex_len = strlen(key_hex);
  if (hex_len != 64) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "X25519 key has invalid length: %zu (expected 64)", hex_len);
    return ERROR_CRYPTO_KEY;
  }
 
  // Check that all characters are valid hex
  for (size_t i = 0; i < hex_len; i++) {
    if (!isxdigit(key_hex[i])) {
      SET_ERRNO(ERROR_CRYPTO_KEY, "X25519 key contains invalid hex character at position %zu: '%c'", i, key_hex[i]);
      return ERROR_CRYPTO_KEY;
    }
  }
 
  return ASCIICHAT_OK;
}
 
// =============================================================================
// Key Security Checks
// =============================================================================
 
asciichat_error_t check_key_strength(const public_key_t *key, bool *is_weak) {
  if (!key || !is_weak) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p, is_weak=%p", key, is_weak);
    return ERROR_INVALID_PARAM;
  }
 
  *is_weak = false;
 
  // Check for all zeros (already checked in validate_public_key)
  // Check for all ones
  bool is_ones = true;
  for (int i = 0; i < 32; i++) {
    if (key->key[i] != 0xFF) {
      is_ones = false;
      break;
    }
  }
 
  if (is_ones) {
    *is_weak = true;
    return ASCIICHAT_OK;
  }
 
  // Check for low entropy: Count unique bytes
  // A properly random 32-byte key should have ~24-32 unique values
  // Low entropy keys will have very few unique bytes
  bool byte_seen[256] = {0};
  int unique_bytes = 0;
  for (int i = 0; i < 32; i++) {
    uint8_t byte_val = key->key[i];
    if (!byte_seen[byte_val]) {
      byte_seen[byte_val] = true;
      unique_bytes++;
    }
  }
 
  // If less than 8 unique bytes in 32 bytes, entropy is very low
  // This indicates non-random key generation (e.g., PRNG seed not properly initialized)
  if (unique_bytes < 8) {
    *is_weak = true;
    return ASCIICHAT_OK;
  }
 
  // Additional weak key pattern detection:
  // - Check for repeated patterns (handled in check_key_patterns)
  // - Check for known weak sequences (see check_key_patterns)
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t check_key_patterns(const public_key_t *key, bool *has_weak_patterns) {
  if (!key || !has_weak_patterns) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p, has_weak_patterns=%p", key, has_weak_patterns);
    return ERROR_INVALID_PARAM;
  }
 
  *has_weak_patterns = false;
 
  // Check for sequential patterns
  bool is_sequential = true;
  for (int i = 1; i < 32; i++) {
    if (key->key[i] != key->key[i - 1] + 1) {
      is_sequential = false;
      break;
    }
  }
 
  if (is_sequential) {
    *has_weak_patterns = true;
    return ASCIICHAT_OK;
  }
 
  // Check for repeated byte patterns (e.g., all 0xAA, all 0x55)
  // Common weak patterns to check
  const uint8_t weak_bytes[] = {0x00, 0xFF, 0xAA, 0x55, 0x11, 0x22, 0x33, 0x44,
                                0x66, 0x77, 0x88, 0x99, 0xBB, 0xCC, 0xDD, 0xEE};
  for (size_t pattern_idx = 0; pattern_idx < sizeof(weak_bytes); pattern_idx++) {
    uint8_t pattern_byte = weak_bytes[pattern_idx];
    bool is_repeated = true;
    for (size_t j = 0; j < 32; j++) {
      // CORRECT: Compare against pattern_byte, not key->key[0]
      if (key->key[j] != pattern_byte) {
        is_repeated = false;
        break;
      }
    }
    if (is_repeated) {
      *has_weak_patterns = true;
      return ASCIICHAT_OK;
    }
  }
 
  // Check for alternating bit patterns (e.g., 0xAA 0xBB 0xAA 0xBB or 0x55 0xAA 0x55 0xAA)
  // A proper alternating pattern has at most 2 unique byte values that truly alternate
  bool byte_appeared[256] = {0};
  int unique_values = 0;
  for (size_t i = 0; i < 32; i++) {
    if (!byte_appeared[key->key[i]]) {
      byte_appeared[key->key[i]] = true;
      unique_values++;
    }
  }
 
  // Only consider it weak if there are 2 or fewer unique values AND they properly alternate
  if (unique_values <= 2) {
    bool is_alternating = true;
    for (size_t i = 1; i < 32; i++) {
      // In a true alternating pattern:
      // 1. Adjacent bytes must be different
      // 2. Pattern must repeat every 2 bytes (byte[i] == byte[i-2])
      if (key->key[i] == key->key[i - 1] || (i >= 2 && key->key[i] != key->key[i - 2])) {
        is_alternating = false;
        break;
      }
    }
    if (is_alternating) {
      *has_weak_patterns = true;
      return ASCIICHAT_OK;
    }
  }
 
  // Check for common cryptographic initialization patterns
  // OpenSSL weak keys, old Debian SSH keys, etc.
  uint32_t *words = (uint32_t *)key->key;
  // Check if all 32-bit words are identical
  bool all_words_same = true;
  for (size_t i = 1; i < 8; i++) {
    if (words[i] != words[0]) {
      all_words_same = false;
      break;
    }
  }
  if (all_words_same) {
    *has_weak_patterns = true;
    return ASCIICHAT_OK;
  }
 
  return ASCIICHAT_OK;
}
 
// =============================================================================
// Key Comparison and Matching
// =============================================================================
 
asciichat_error_t compare_public_keys(const public_key_t *key1, const public_key_t *key2, bool *are_equal) {
  if (!key1 || !key2 || !are_equal) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key1=%p, key2=%p, are_equal=%p", key1, key2, are_equal);
    return ERROR_INVALID_PARAM;
  }
 
  *are_equal = false;
 
  // Compare key types
  if (key1->type != key2->type) {
    return ASCIICHAT_OK;
  }
 
  // Compare key data using constant-time comparison
  if (sodium_memcmp(key1->key, key2->key, 32) == 0) {
    *are_equal = true;
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t check_key_fingerprint(const public_key_t *key, const uint8_t *fingerprint, size_t fingerprint_len,
                                        bool *matches) {
  if (!key || !fingerprint || !matches) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p, fingerprint=%p, matches=%p", key, fingerprint, matches);
    return ERROR_INVALID_PARAM;
  }
 
  *matches = false;
 
  // Generate fingerprint for the key
  uint8_t key_fingerprint[32];
  asciichat_error_t fingerprint_result = generate_key_fingerprint(key, key_fingerprint, 32);
  if (fingerprint_result != ASCIICHAT_OK) {
    return fingerprint_result;
  }
 
  // Compare fingerprints
  size_t compare_len = (fingerprint_len < 32) ? fingerprint_len : 32;
  if (sodium_memcmp(key_fingerprint, fingerprint, compare_len) == 0) {
    *matches = true;
  }
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t generate_key_fingerprint(const public_key_t *key, uint8_t *fingerprint_out, size_t fingerprint_size) {
  if (!key || !fingerprint_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: key=%p, fingerprint_out=%p", key, fingerprint_out);
    return ERROR_INVALID_PARAM;
  }
 
  if (fingerprint_size < 32) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Fingerprint buffer too small: %zu (minimum 32)", fingerprint_size);
    return ERROR_INVALID_PARAM;
  }
 
  // Generate SHA-256 fingerprint of the key
  if (crypto_hash_sha256(fingerprint_out, key->key, 32) != 0) {
    SET_ERRNO(ERROR_CRYPTO, "Failed to generate key fingerprint");
    return ERROR_CRYPTO;
  }
 
  return ASCIICHAT_OK;
}