#include "sleela_wifi/wifi_manager.h" #include #include static int bssid_equal_ci(const char *a, const char *b) { size_t i; if (!a || !b || strlen(a) != strlen(b)) return 0; for (i = 0u; a[i]; ++i) if (tolower((unsigned char)a[i]) != tolower((unsigned char)b[i])) return 0; return 1; } static int is_enterprise(wifi_security_t s) { return s == WIFI_SECURITY_WPA_ENTERPRISE || s == WIFI_SECURITY_WPA2_ENTERPRISE || s == WIFI_SECURITY_WPA3_ENTERPRISE; } static int valid_ssid(const char *s) { size_t i, n; if (!s) return 0; n = strlen(s); if (n == 0u || n > WIFI_SSID_MAX_BYTES) return 0; for (i = 0u; i < n; ++i) { unsigned char c = (unsigned char)s[i]; if (c < 0x20u || c == 0x7fu) return 0; } return 1; } static int valid_bssid(const char *s) { size_t i; if (!s || strlen(s) != 17u) return 0; for (i = 0u; i < 17u; ++i) { if (i == 2u || i == 5u || i == 8u || i == 11u || i == 14u) { if (s[i] != ':') return 0; } else if (!isxdigit((unsigned char)s[i])) return 0; } return 1; } static int is_binary_value(int value) { return value == 0 || value == 1; } static int same_network(const wifi_network_t *a, const wifi_network_t *b) { return a && b && strcmp(a->ssid, b->ssid) == 0 && bssid_equal_ci(a->bssid, b->bssid) && a->security == b->security; } static int valid_network(const wifi_network_t *n) { return n && valid_ssid(n->ssid) && valid_bssid(n->bssid) && n->signal_percent <= WIFI_SIGNAL_PERCENT_MAX && n->security > WIFI_SECURITY_UNKNOWN && n->security <= WIFI_SECURITY_WPA3_ENTERPRISE; } static int valid_policy(const wifi_security_policy_t *p) { return p && p->minimum_security_rank >= 0 && p->minimum_security_rank <= 5 && is_binary_value(p->allow_open_networks) && is_binary_value(p->allow_legacy_wep) && is_binary_value(p->require_enterprise_tls_validation) && is_binary_value(p->require_protected_management_frames); } void wifi_security_policy_default(wifi_security_policy_t *p) { if (!p) return; p->minimum_security_rank = WIFI_DEFAULT_MINIMUM_SECURITY_RANK; p->allow_open_networks = WIFI_DEFAULT_ALLOW_OPEN_NETWORKS; p->allow_legacy_wep = WIFI_DEFAULT_ALLOW_LEGACY_WEP; p->require_enterprise_tls_validation = WIFI_DEFAULT_REQUIRE_ENTERPRISE_TLS_VALIDATION; p->require_protected_management_frames = WIFI_DEFAULT_REQUIRE_PROTECTED_MANAGEMENT_FRAMES; } wifi_status_t wifi_manager_init(wifi_manager_t *m, const wifi_backend_t *b, void *context, const wifi_security_policy_t *policy) { wifi_security_policy_t defaults; if (!m || !b || !b->scan || !b->connect || !b->disconnect) return WIFI_STATUS_INVALID_ARGUMENT; memset(m, 0, sizeof(*m)); wifi_security_policy_default(&defaults); m->backend = b; m->backend_context = context; m->policy = policy ? *policy : defaults; if (!valid_policy(&m->policy)) { m->backend = NULL; m->backend_context = NULL; memset(&m->policy, 0, sizeof(m->policy)); return WIFI_STATUS_INVALID_ARGUMENT; } m->initialized = 1; return WIFI_STATUS_OK; } wifi_status_t wifi_manager_scan(wifi_manager_t *m, wifi_network_t *out, size_t capacity, size_t *out_count) { size_t n = 0u, i, kept = 0u, copied; wifi_status_t s; if (!m || !m->initialized || !out_count || (!out && capacity)) return WIFI_STATUS_INVALID_ARGUMENT; *out_count = 0u; memset(m->last_scan, 0, sizeof(m->last_scan)); m->last_scan_count = 0u; s = m->backend->scan(m->backend_context, m->last_scan, WIFI_MAX_SCAN_RESULTS, &n); if (s != WIFI_STATUS_OK && s != WIFI_STATUS_BUFFER_TOO_SMALL) return s; /* The OOD deliberately retains at most the bounded native scan cache. */ if (n > WIFI_MAX_SCAN_RESULTS) n = WIFI_MAX_SCAN_RESULTS; for (i = 0u; i < n; ++i) { if (!valid_network(&m->last_scan[i])) continue; if (kept != i) m->last_scan[kept] = m->last_scan[i]; m->last_scan[kept].ssid[WIFI_SSID_MAX_BYTES] = '\0'; m->last_scan[kept].bssid[WIFI_BSSID_TEXT_SIZE - 1u] = '\0'; if (m->last_scan[kept].protected_management_frames < -1 || m->last_scan[kept].protected_management_frames > 1) m->last_scan[kept].protected_management_frames = -1; ++kept; } m->last_scan_count = kept; ++m->scan_generation; copied = capacity < kept ? capacity : kept; if (copied && out) memcpy(out, m->last_scan, copied * sizeof(*out)); *out_count = kept; return capacity < kept ? WIFI_STATUS_BUFFER_TOO_SMALL : WIFI_STATUS_OK; } wifi_status_t wifi_manager_select(const wifi_manager_t *m, size_t index, wifi_network_t *out) { if (!m || !m->initialized || !out) return WIFI_STATUS_INVALID_ARGUMENT; if (index >= m->last_scan_count) return WIFI_STATUS_NETWORK_NOT_FOUND; *out = m->last_scan[index]; return WIFI_STATUS_OK; } int wifi_security_rank(wifi_security_t s) { switch (s) { case WIFI_SECURITY_OPEN: return 0; case WIFI_SECURITY_WEP: return 1; case WIFI_SECURITY_WPA_PERSONAL: case WIFI_SECURITY_WPA_ENTERPRISE: return 3; case WIFI_SECURITY_WPA2_PERSONAL: case WIFI_SECURITY_WPA2_ENTERPRISE: case WIFI_SECURITY_OWE: return 4; case WIFI_SECURITY_WPA3_PERSONAL: case WIFI_SECURITY_WPA3_ENTERPRISE: return 5; default: return -1; } } wifi_status_t wifi_manager_connect(wifi_manager_t *m, const wifi_network_t *selected, const wifi_auth_t *auth) { size_t i; int found = 0, rank; const wifi_auth_t os_auth = { WIFI_AUTH_OS_MANAGED, NULL, NULL, NULL, NULL, NULL }; const wifi_auth_t *a = auth ? auth : &os_auth; if (!m || !m->initialized || !selected || !valid_network(selected)) return WIFI_STATUS_INVALID_ARGUMENT; for (i = 0u; i < m->last_scan_count; ++i) if (same_network(selected, &m->last_scan[i])) { found = 1; break; } if (!found) return WIFI_STATUS_NETWORK_NOT_FOUND; rank = wifi_security_rank(selected->security); if (rank < 0 || rank < m->policy.minimum_security_rank) return WIFI_STATUS_POLICY_BLOCKED; if (selected->security == WIFI_SECURITY_OPEN && !m->policy.allow_open_networks) return WIFI_STATUS_POLICY_BLOCKED; if (selected->security == WIFI_SECURITY_WEP && !m->policy.allow_legacy_wep) return WIFI_STATUS_POLICY_BLOCKED; if (m->policy.require_protected_management_frames && selected->protected_management_frames != 1) return WIFI_STATUS_POLICY_BLOCKED; if (a->mode == WIFI_AUTH_PASSPHRASE) { size_t len, j; int hex64; if (!a->password) return WIFI_STATUS_AUTH_REQUIRED; if (selected->security != WIFI_SECURITY_WPA_PERSONAL && selected->security != WIFI_SECURITY_WPA2_PERSONAL && selected->security != WIFI_SECURITY_WPA3_PERSONAL) return WIFI_STATUS_INVALID_ARGUMENT; len = strlen(a->password); hex64 = len == WIFI_RAW_PSK_HEX_BYTES; for (j = 0u; hex64 && j < len; ++j) if (!isxdigit((unsigned char)a->password[j])) hex64 = 0; if (selected->security == WIFI_SECURITY_WPA3_PERSONAL && hex64) return WIFI_STATUS_INVALID_ARGUMENT; if ((len < WIFI_MIN_PERSONAL_PASSPHRASE_BYTES || len > WIFI_MAX_PERSONAL_PASSPHRASE_BYTES) && !hex64) return WIFI_STATUS_INVALID_ARGUMENT; } else if (a->mode == WIFI_AUTH_ENTERPRISE_PASSWORD) { if (!is_enterprise(selected->security) || !a->username || !*a->username || !a->password || !*a->password) return WIFI_STATUS_AUTH_REQUIRED; if (m->policy.require_enterprise_tls_validation && (!a->ca_certificate_file || !*a->ca_certificate_file || !a->expected_server_name || !*a->expected_server_name)) return WIFI_STATUS_POLICY_BLOCKED; } else if (a->mode == WIFI_AUTH_SAVED_PROFILE) { if (!a->profile_name || !*a->profile_name) return WIFI_STATUS_AUTH_REQUIRED; } else if (a->mode != WIFI_AUTH_OS_MANAGED) return WIFI_STATUS_INVALID_ARGUMENT; return m->backend->connect(m->backend_context, selected, a); } wifi_status_t wifi_manager_disconnect(wifi_manager_t *m) { if (!m || !m->initialized) return WIFI_STATUS_INVALID_ARGUMENT; return m->backend->disconnect(m->backend_context); } const char *wifi_security_name(wifi_security_t s) { switch (s) { case WIFI_SECURITY_OPEN: return "Open"; case WIFI_SECURITY_WEP: return "WEP (legacy)"; case WIFI_SECURITY_WPA_PERSONAL: return "WPA-Personal"; case WIFI_SECURITY_WPA2_PERSONAL: return "WPA2-Personal"; case WIFI_SECURITY_WPA3_PERSONAL: return "WPA3-Personal"; case WIFI_SECURITY_OWE: return "Enhanced Open (OWE)"; case WIFI_SECURITY_WPA_ENTERPRISE: return "WPA-Enterprise"; case WIFI_SECURITY_WPA2_ENTERPRISE: return "WPA2-Enterprise"; case WIFI_SECURITY_WPA3_ENTERPRISE: return "WPA3-Enterprise"; default: return "Unknown"; } } const char *wifi_status_name(wifi_status_t s) { switch (s) { case WIFI_STATUS_OK: return "ok"; case WIFI_STATUS_INVALID_ARGUMENT: return "invalid argument"; case WIFI_STATUS_BACKEND_UNAVAILABLE: return "native Wi-Fi backend unavailable"; case WIFI_STATUS_BACKEND_ERROR: return "native Wi-Fi operation failed"; case WIFI_STATUS_BUFFER_TOO_SMALL: return "output buffer too small"; case WIFI_STATUS_NETWORK_NOT_FOUND: return "network not in latest scan"; case WIFI_STATUS_POLICY_BLOCKED: return "blocked by Wi-Fi security policy"; case WIFI_STATUS_AUTH_REQUIRED: return "OS-managed authentication or a valid profile is required"; case WIFI_STATUS_NOT_CONNECTED: return "no active Wi-Fi connection"; default: return "unknown status"; } } void wifi_secure_zero(void *memory, size_t length) { volatile unsigned char *p = (volatile unsigned char *)memory; if (!p) return; while (length--) *p++ = 0u; }