/* wifi: ring-3 WiFi command for the Intel 7265D/3165 and 6200/6300 (see wifi.c). * * wifi status * wifi up load the firmware, show the MAC address * wifi scan list networks (strongest first) * wifi connect [pass] [bssid] * join an open or WPA2-PSK (CCMP) network, * run DHCP; quote an SSID with spaces; a * BSSID picks one of several APs * wifi connectfile join using an SSID/passphrase/BSSID record * staged by the network menu (SYS_SPAWN's * argument buffer is only 64 bytes) * wifi saved list the networks saved in /data/WIFI.CFG * wifi autoconnect join any saved network found (boot helper) * wifi forget [ssid] remove one saved network, or all without an * argument * wifi disconnect * * A successful connect adds the SSID/passphrase to a most-recently-used list * (up to WIFI_CFG_MAX networks) in /data/WIFI.CFG. The WPA2 handshake (wpa.c) * runs here; a small background copy of this command (`wifi __keep `) * stays alive after `connect` to answer group-key rekeys, and exits when the * connection changes. */ #include "ucmd_lib.h" #include "tls_rng.h" #include "wifi_store.h" #include "wpa.h" #define MAX_BSS 32 static struct sys_wifi_bss bss[MAX_BSS]; static int wifi(int op, int a2, int a3) { return u_syscall3(SYS_WIFI, op, a2, a3); } static int name_eq(const char *a, const char *b) { while (*a && *b) { if (*a != *b) return 0; a++; b++; } return *a == *b; } /* Add the network to /data/WIFI.CFG, replacing an older record for the same * SSID and moving it to the front (most recently used). The BSSID is * deliberately left zero so a mesh/repeater AP with the same SSID still * works; /data is a plain FAT partition, so the file is 8.3 and the * passphrase is stored in clear. */ static int remember_wifi(const unsigned char *ssid, unsigned int ssid_len, const char *pass, unsigned int pass_len) { struct wifi_cfg rec; unsigned int i; int r; if (ssid_len > 32) ssid_len = 32; if (pass_len > 64) pass_len = 64; for (i = 0; i < sizeof(rec); i++) ((unsigned char *)&rec)[i] = 0; rec.magic = WIFI_CFG_MAGIC; rec.ssid_len = (unsigned char)ssid_len; rec.pass_len = (unsigned char)pass_len; for (i = 0; i < ssid_len; i++) rec.ssid[i] = ssid[i]; for (i = 0; i < pass_len; i++) rec.pass[i] = pass[i]; r = wifi_store_remember(&rec); for (i = 0; i < sizeof(rec); i++) ((volatile unsigned char *)&rec)[i] = 0; return r; } static void put_ssid(const unsigned char *s, unsigned int n) { unsigned int i; for (i = 0; i < n; i++) u_putc(s[i] >= 32 && s[i] < 127 ? (char)s[i] : '?'); } static int slen(const char *s) { int n = 0; while (s[n]) n++; return n; } static int starts(const char *s, const char *p) { while (*p) if (*s++ != *p++) return 0; return 1; } static const char *skip_ws(const char *s) { while (*s == ' ') s++; return s; } /* Next word or "quoted string" into out; returns the rest. */ static const char *word(const char *s, char *out, unsigned int max) { unsigned int n = 0; char end = ' '; s = skip_ws(s); if (*s == '"') { end = '"'; s++; } while (*s && *s != end) { if (end == '"' && *s == '\\' && s[1]) s++; if (n + 1 < max) out[n++] = *s; s++; } if (*s == end) s++; out[n] = 0; return s; } static void put_dbm(int v) { if (v < 0) { u_putc('-'); v = -v; } u_putdec((unsigned int)v); u_puts(" dBm"); } static const char *sec_name(unsigned int s) { return s == SYS_WIFI_SEC_OPEN ? "open" : s == SYS_WIFI_SEC_PSK ? "WPA2" : "other"; } static int cmd_status(void) { struct sys_wifi_status st; static const char *const names[] = { "down", "idle", "associated", "connected" }; unsigned char ip[4]; if (wifi(SYS_WIFI_STATUS, (int)&st, 0) < 0) { u_puts("wifi: status failed\n"); return 1; } if (!st.present) { u_puts("wifi: no Intel 7265/3165/6200/6300 card found\n"); return 1; } u_puts("chip: "); u_puts(st.chip); u_puts("\nstate: "); u_puts(names[st.state & 3]); u_puts(" ("); u_puts(st.detail); u_puts(")\n"); if (st.fw[0]) { u_puts("firmware: "); u_puts(st.fw); u_puts("\n"); } if (st.state != SYS_WIFI_ST_DOWN) { u_puts("mac: "); u_put_mac(st.mac); u_puts("\n"); } if (st.state >= SYS_WIFI_ST_ASSOC) { u_puts("network: \""); put_ssid(st.ssid, st.ssid_len); u_puts("\" "); u_put_mac(st.bssid); u_puts(" ch "); u_putdec(st.channel); u_puts(" "); put_dbm(st.rssi); u_puts("\n"); u_syscall1(SYS_NET_GET_IP, (int)ip); u_puts("ip: "); u_put_ip(ip); u_puts("\n"); u_puts("frames: rx "); u_putdec(st.rx_frames); u_puts(" tx "); u_putdec(st.tx_frames); u_puts(" dropped "); u_putdec(st.rx_dropped); u_puts("\n"); } return 0; } static int bring_up(void) { struct sys_wifi_status st; u_puts("wifi: loading firmware...\n"); if (wifi(SYS_WIFI_UP, 0, 0) < 0) { wifi(SYS_WIFI_STATUS, (int)&st, 0); u_puts("wifi: bring-up failed: "); u_puts(st.detail); u_puts(" (details on the serial/netmon log)\n"); return -1; } return 0; } /* Scan and return the number of entries, sorted by RSSI. */ static int do_scan(void) { int n, i, j; unsigned int t0; if (wifi(SYS_WIFI_SCAN, 0, 0) < 0) { u_puts("wifi: scan failed (disconnect first?)\n"); return -1; } t0 = u_ticks_ms(); while ((n = wifi(SYS_WIFI_RESULTS, (int)bss, MAX_BSS)) == -2) { if (u_ticks_ms() - t0 > 15000) { u_puts("wifi: scan timed out\n"); return -1; } u_sleep_ms(100); } if (n < 0) return -1; for (i = 1; i < n; i++) for (j = i; j > 0 && bss[j].rssi > bss[j - 1].rssi; j--) { struct sys_wifi_bss t = bss[j]; bss[j] = bss[j - 1]; bss[j - 1] = t; } return n; } static int cmd_scan(void) { int n, i; if (bring_up() < 0) return 1; u_puts("wifi: scanning...\n"); n = do_scan(); if (n < 0) return 1; if (n == 0) u_puts("no networks found\n"); for (i = 0; i < n; i++) { u_put_mac(bss[i].bssid); u_puts(" "); put_dbm(bss[i].rssi); u_puts(bss[i].channel < 10 ? " ch " : bss[i].channel < 100 ? " ch " : " ch "); u_putdec(bss[i].channel); u_puts(" "); u_puts(sec_name(bss[i].security)); u_puts(bss[i].security == SYS_WIFI_SEC_PSK ? " " : " "); if (bss[i].ssid_len) put_ssid(bss[i].ssid, bss[i].ssid_len); else u_puts("(hidden)"); u_puts("\n"); } return 0; } static int hexval(char c) { if (c >= '0' && c <= '9') return c - '0'; if (c >= 'a' && c <= 'f') return c - 'a' + 10; if (c >= 'A' && c <= 'F') return c - 'A' + 10; return -1; } static int unhex(const char *s, unsigned char *out, unsigned int n) { unsigned int i; for (i = 0; i < n; i++) { int a = hexval(s[2 * i]), b = hexval(s[2 * i + 1]); if (a < 0 || b < 0) return -1; out[i] = (unsigned char)(a * 16 + b); } return 0; } static void tohex(const unsigned char *in, unsigned int n, char *out) { static const char hx[] = "0123456789abcdef"; unsigned int i; for (i = 0; i < n; i++) { out[2 * i] = hx[in[i] >> 4]; out[2 * i + 1] = hx[in[i] & 15]; } out[2 * n] = 0; } static int set_gtk(struct wpa_sm *sm) { struct sys_wifi_key k; unsigned int i; k.pairwise = 0; k.keyidx = sm->gtk_idx; for (i = 0; i < 16; i++) k.key[i] = sm->gtk[i]; for (i = 0; i < 8; i++) k.rsc[i] = sm->gtk_rsc[i]; return wifi(SYS_WIFI_SET_KEY, (int)&k, 0); } /* Run the 4-way handshake: msg1 -> msg2, msg3 -> msg4 + keys. */ static int handshake(struct wpa_sm *sm) { static unsigned char frame[1024], reply[256]; unsigned int t0 = u_ticks_ms(), rlen; int n, r; while (u_ticks_ms() - t0 < 8000) { n = wifi(SYS_WIFI_EAPOL_RX, (int)frame, sizeof(frame)); if (n < 0) return -1; if (n == 0) { u_sleep_ms(20); continue; } r = wpa_rx(sm, frame, (unsigned int)n, reply, &rlen, tls_random); if (r == WPA_ERR) { u_puts("wifi: handshake: "); u_puts(sm->error ? sm->error : "error"); u_puts("\n"); return -1; } if (r == WPA_NONE) continue; if (wifi(SYS_WIFI_EAPOL_TX, (int)reply, (int)rlen) < 0) return -1; if (r == WPA_PTK) { struct sys_wifi_key k; unsigned int i; k.pairwise = 1; k.keyidx = 0; for (i = 0; i < 16; i++) k.key[i] = WPA_TK(sm)[i]; for (i = 0; i < 8; i++) k.rsc[i] = 0; u_sleep_ms(20); /* let message 4 leave in the clear */ if (wifi(SYS_WIFI_SET_KEY, (int)&k, 0) < 0 || set_gtk(sm) < 0) { u_puts("wifi: key install failed\n"); return -1; } return 0; } } u_puts("wifi: handshake timed out (no EAPOL from the AP)\n"); return -1; } static void spawn_keeper(struct wpa_sm *sm, unsigned int conn_id) { static char arg[16]; struct sys_wifi_ptk p; unsigned char id[4]; char *q = arg; unsigned int i; p.conn_id = conn_id; for (i = 0; i < 48; i++) p.ptk[i] = sm->ptk[i]; for (i = 0; i < 8; i++) p.replay[i] = sm->replay[i]; if (wifi(SYS_WIFI_SET_PTK, (int)&p, 0) < 0) { u_puts("wifi: note: could not store rekey state; the link will " "drop at the next group rekey\n"); return; } for (i = 0; "__keep "[i]; i++) *q++ = "__keep "[i]; id[0] = conn_id >> 24; id[1] = conn_id >> 16; id[2] = conn_id >> 8; id[3] = conn_id; tohex(id, 4, q); q += 8; *q = 0; if (u_spawn_detached("/ramfs/bin/wifi", arg, 0, "/") < 0) u_puts("wifi: note: rekey helper did not start; the link will " "drop at the next group rekey\n"); } /* Join one BSS from a completed scan. `pass` is empty for an open network. * Returns 0 when the data port is open, 1 on failure. */ static int join_bss(const struct sys_wifi_bss *b, const char *pass) { struct sys_wifi_connect c; struct sys_wifi_status st; static struct wpa_sm sm; unsigned char pmk[32]; unsigned int ssid_len = b->ssid_len; int i, r; if (ssid_len == 0 || ssid_len > 32) { u_puts("wifi: malformed SSID in scan result\n"); return 1; } if (b->security == SYS_WIFI_SEC_OTHER) { u_puts("wifi: unsupported security (only open and WPA2-PSK/CCMP)\n"); return 1; } if (b->security == SYS_WIFI_SEC_PSK && !pass[0]) { u_puts("wifi: this network needs a passphrase\n"); return 1; } for (i = 0; i < (int)sizeof(c); i++) ((unsigned char *)&c)[i] = 0; for (i = 0; i < 6; i++) c.bssid[i] = b->bssid[i]; c.channel = b->channel; c.ssid_len = (unsigned char)ssid_len; for (i = 0; i < (int)ssid_len; i++) c.ssid[i] = b->ssid[i]; c.beacon_int = b->beacon_int; c.dtim = b->dtim; if (b->security == SYS_WIFI_SEC_PSK) { int plen = slen(pass); if (plen == 64 && unhex(pass, pmk, 32) == 0) { /* raw 256-bit PSK */ } else if (plen >= 8 && plen <= 63) { u_puts("wifi: deriving key...\n"); wpa_pmk(pass, c.ssid, ssid_len, pmk); } else { u_puts("wifi: a WPA2 passphrase has 8..63 characters\n"); return 1; } c.ie_len = (unsigned char)wpa_rsn_ie(c.ie); } u_puts("wifi: joining "); u_put_mac(c.bssid); u_puts(" on channel "); u_putdec(c.channel); u_puts("\n"); if (wifi(SYS_WIFI_CONNECT, (int)&c, 0) < 0) { wifi(SYS_WIFI_STATUS, (int)&st, 0); u_puts("wifi: "); u_puts(st.detail); u_puts("\n"); return 1; } wifi(SYS_WIFI_STATUS, (int)&st, 0); if (b->security == SYS_WIFI_SEC_PSK) { wpa_init(&sm, pmk, c.bssid, st.mac, c.ie, c.ie_len, b->rsn, b->rsn_len); u_puts("wifi: 4-way handshake...\n"); if (handshake(&sm) < 0) { wifi(SYS_WIFI_DISCONNECT, 0, 0); return 1; } } r = wifi(SYS_WIFI_AUTHORIZE, 0, 0); if (r < 0) u_puts("wifi: connected, but the WiFi card could not become the " "active netdev (close TCP users, then `netdev wifi`)\n"); else u_puts("wifi: connected\n"); if (b->security == SYS_WIFI_SEC_PSK) spawn_keeper(&sm, st.conn_id); if (r == 0 && u_syscall1(SYS_DHCP_RUN, 6000) != 0) u_puts("wifi: DHCP failed; set an address with netip\n"); return r == 0 ? 0 : 1; } static int connect_bss(const char *ssid, const char *pass, const unsigned char *want_bssid) { struct sys_wifi_bss *b = 0; int n, i; unsigned int ssid_len; int have_bssid = want_bssid != 0; ssid_len = (unsigned int)slen(ssid); if (!ssid_len) { u_puts("usage: wifi connect [passphrase]\n"); return 1; } if (bring_up() < 0) return 1; wifi(SYS_WIFI_DISCONNECT, 0, 0); u_puts("wifi: scanning for \""); u_puts(ssid); u_puts("\"...\n"); n = do_scan(); if (n < 0) return 1; for (i = 0; i < n; i++) { unsigned int j; if (bss[i].ssid_len != ssid_len) continue; if (have_bssid) { for (j = 0; j < 6 && bss[i].bssid[j] == want_bssid[j]; j++) ; if (j != 6) continue; } for (j = 0; j < ssid_len && bss[i].ssid[j] == (unsigned char)ssid[j]; j++) ; if (j == ssid_len) { b = &bss[i]; /* sorted: first match is strongest */ break; } } if (!b) { u_puts("wifi: network not found\n"); return 1; } return join_bss(b, pass); } static int cmd_connect(const char *args) { char ssid[33], pass[80], bssid_s[13]; unsigned char want_bssid[6]; int have_bssid = 0; int r; args = word(args, ssid, sizeof(ssid)); args = word(args, pass, sizeof(pass)); if (*skip_ws(args)) { word(args, bssid_s, sizeof(bssid_s)); if (slen(bssid_s) != 12 || unhex(bssid_s, want_bssid, 6) < 0) { u_puts("wifi: BSSID must be 12 hex digits\n"); return 1; } have_bssid = 1; } r = connect_bss(ssid, pass, have_bssid ? want_bssid : 0); if (r == 0) { if (remember_wifi((const unsigned char *)ssid, (unsigned int)slen(ssid), pass, (unsigned int)slen(pass)) == 0) u_puts("wifi: saved for auto-connect\n"); else u_puts("wifi: note: could not save credentials to /data\n"); } return r; } /* `wifi connectfile `: the network menu stages an SSID + passphrase + * BSSID record in /share because SYS_SPAWN's argument buffer is only * VFS_PATH_MAX (64) bytes. The file is removed after it has been read. */ static int cmd_connect_file(const char *args) { struct wifi_cfg cfg; char path[80], ssid[33], pass[65]; unsigned int i; int r; args = word(args, path, sizeof(path)); for (i = 0; i < sizeof(cfg); i++) ((unsigned char *)&cfg)[i] = 0; r = u_syscall3(SYS_READ_FILE, (int)path, (int)&cfg, (int)sizeof(cfg)); u_syscall1(SYS_UNLINK, (int)path); if (r < 0 || (unsigned int)r < sizeof(cfg) || cfg.magic != WIFI_CFG_MAGIC) { u_puts("wifi: no valid staged connect request\n"); return 1; } if (cfg.ssid_len == 0 || cfg.ssid_len > 32 || cfg.pass_len > 64) { u_puts("wifi: staged connect request is malformed\n"); return 1; } for (i = 0; i < cfg.ssid_len; i++) ssid[i] = (char)cfg.ssid[i]; ssid[cfg.ssid_len] = '\0'; for (i = 0; i < cfg.pass_len; i++) pass[i] = cfg.pass[i]; pass[cfg.pass_len] = '\0'; r = connect_bss(ssid, pass, cfg.bssid); if (r == 0) { if (remember_wifi(cfg.ssid, cfg.ssid_len, cfg.pass, cfg.pass_len) == 0) u_puts("wifi: saved for auto-connect\n"); else u_puts("wifi: note: credentials not saved (no writable /data)\n"); } for (i = 0; i < sizeof(cfg); i++) ((unsigned char *)&cfg)[i] = 0; for (i = 0; i < sizeof(pass); i++) ((volatile char *)pass)[i] = 0; return r; } /* Boot-time helper: scan once, then join the strongest network present whose * SSID is in /data/WIFI.CFG. If none succeeds, scan again after three * seconds. A wired link that is physically up wins; an existing WiFi link * is left alone. */ static int cmd_autoconnect(void) { struct wifi_cfg nets[WIFI_CFG_MAX]; struct sys_wifi_status ws; struct sys_netinfo ni; char pass[65]; int count, n, i, round, r = 1; count = wifi_store_load(nets, WIFI_CFG_MAX); if (count <= 0) return 0; /* A wired link that is physically up wins: do not even probe the WiFi * card in that case. Only fall back to WiFi when no cable is * connected. */ if (u_net_info(&ni) == 1 && ni.present && ni.link && !name_eq(ni.name, "wifi")) goto out; if (u_wifi(SYS_WIFI_STATUS, (int)&ws, 0) != 0 || !ws.present) goto out; if (ws.state >= SYS_WIFI_ST_LINK) goto out; if (bring_up() < 0) goto out; for (round = 0; round < 2 && r; round++) { unsigned char tried[WIFI_CFG_MAX]; unsigned int j; if (round) u_sleep_ms(3000); for (j = 0; j < WIFI_CFG_MAX; j++) tried[j] = 0; wifi(SYS_WIFI_DISCONNECT, 0, 0); n = do_scan(); if (n < 0) continue; for (i = 0; i < n && r; i++) { struct sys_wifi_bss *b = &bss[i]; int ci; if (b->security == SYS_WIFI_SEC_OTHER) continue; ci = wifi_store_find(nets, count, b->ssid, b->ssid_len); if (ci < 0 || tried[ci]) continue; if (b->security == SYS_WIFI_SEC_PSK && nets[ci].pass_len == 0) continue; tried[ci] = 1; for (j = 0; j < nets[ci].pass_len; j++) pass[j] = nets[ci].pass[j]; pass[nets[ci].pass_len] = '\0'; u_puts("wifi: auto-connect \""); put_ssid(b->ssid, b->ssid_len); u_puts("\"\n"); r = join_bss(b, pass); for (j = 0; j < sizeof(pass); j++) ((volatile char *)pass)[j] = 0; if (r != 0) wifi(SYS_WIFI_DISCONNECT, 0, 0); } } out: for (i = 0; i < (int)sizeof(nets); i++) ((volatile unsigned char *)nets)[i] = 0; for (i = 0; i < (int)sizeof(pass); i++) ((volatile char *)pass)[i] = 0; return r; } static int cmd_saved(void) { struct wifi_cfg list[WIFI_CFG_MAX]; int n, i; unsigned int j; n = wifi_store_load(list, WIFI_CFG_MAX); if (n <= 0) { u_puts("wifi: no saved networks\n"); return 0; } u_puts("saved networks ("); u_putdec((unsigned int)n); u_puts("):\n"); for (i = 0; i < n; i++) { u_puts(" \""); put_ssid(list[i].ssid, list[i].ssid_len); u_puts("\" "); u_puts(list[i].pass_len ? "WPA2-PSK" : "open"); u_puts("\n"); } for (j = 0; j < sizeof(list); j++) ((volatile unsigned char *)list)[j] = 0; return 0; } static int cmd_forget(const char *args) { char ssid[33]; int r; args = word(args, ssid, sizeof(ssid)); if (!ssid[0]) { if (u_syscall1(SYS_UNLINK, (int)WIFI_CRED_PATH) == 0) u_puts("wifi: saved networks removed\n"); else u_puts("wifi: no saved networks\n"); return 0; } r = wifi_store_forget((const unsigned char *)ssid, (unsigned int)slen(ssid)); if (r > 0) u_puts("wifi: saved network removed\n"); else if (r == 0) u_puts("wifi: network is not saved\n"); else u_puts("wifi: could not update /data/WIFI.CFG\n"); return r < 0 ? 1 : 0; } /* Background: answer group-key rekeys until the connection changes. */ static int keeper(const char *args) { static struct wpa_sm sm; static unsigned char frame[1024], reply[256]; struct sys_wifi_status st; struct sys_wifi_ptk p; unsigned char id[4]; unsigned int conn_id, rlen, i; args = skip_ws(args); if (slen(args) < 8 || unhex(args, id, 4) < 0) { u_puts("wifi: keeper: bad state argument\n"); return 1; } conn_id = ((unsigned int)id[0] << 24) | (id[1] << 16) | (id[2] << 8) | id[3]; if (wifi(SYS_WIFI_GET_PTK, (int)&p, (int)conn_id) < 0 || p.conn_id != conn_id) { u_puts("wifi: keeper: no key state for this connection\n"); return 1; } for (i = 0; i < 48; i++) sm.ptk[i] = p.ptk[i]; for (i = 0; i < 8; i++) sm.replay[i] = p.replay[i]; sm.have_replay = 1; sm.ptk_ok = 1; u_puts("wifi: keeper running\n"); for (;;) { int n, r; if (wifi(SYS_WIFI_STATUS, (int)&st, 0) < 0 || st.conn_id != conn_id || st.state < SYS_WIFI_ST_ASSOC) return 0; n = wifi(SYS_WIFI_EAPOL_RX, (int)frame, sizeof(frame)); if (n > 0) { r = wpa_rx(&sm, frame, (unsigned int)n, reply, &rlen, tls_random); u_puts("wifi: keeper eapol "); u_putdec((unsigned int)n); u_puts(" -> "); u_putdec((unsigned int)r); u_puts("\n"); if (r == WPA_GTK) { wifi(SYS_WIFI_EAPOL_TX, (int)reply, (int)rlen); u_puts("wifi: keeper gtk "); u_putdec((unsigned int)sm.gtk_idx); u_puts(set_gtk(&sm) == 0 ? " installed\n" : " install failed\n"); } else if (r == WPA_ERR) { u_puts("wifi: keeper error: "); u_puts(sm.error ? sm.error : "?"); u_puts("\n"); } } u_sleep_ms(200); } } void _start(const char *arg) { const char *a = skip_ws(arg ? arg : ""); int r = 0; if (!*a) r = cmd_status(); else if (starts(a, "__keep ")) r = keeper(a + 7); else if (starts(a, "up")) { r = bring_up() < 0; if (!r) r = cmd_status(); } else if (starts(a, "scan")) r = cmd_scan(); else if (starts(a, "connect ")) r = cmd_connect(a + 8); else if (starts(a, "connectfile ")) r = cmd_connect_file(a + 12); else if (starts(a, "saved")) r = cmd_saved(); else if (starts(a, "autoconnect")) r = cmd_autoconnect(); else if (starts(a, "forget")) r = cmd_forget(a + 6); else if (starts(a, "disconnect")) { wifi(SYS_WIFI_DISCONNECT, 0, 0); u_puts("wifi: disconnected\n"); } else { u_puts("usage: wifi [up|scan|connect [pass] [bssid]|connectfile |saved|autoconnect|forget [ssid]|disconnect]\n"); r = 1; } u_exit(r); }