ucmd_wifi.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813
  1. /* wifi: ring-3 WiFi command for the Intel 7265D/3165 and 6200/6300 (see wifi.c).
  2. *
  3. * wifi status
  4. * wifi up load the firmware, show the MAC address
  5. * wifi scan list networks (strongest first)
  6. * wifi connect <ssid> [pass] [bssid]
  7. * join an open or WPA2-PSK (CCMP) network,
  8. * run DHCP; quote an SSID with spaces; a
  9. * BSSID picks one of several APs
  10. * wifi connectfile <path> join using an SSID/passphrase/BSSID record
  11. * staged by the network menu (SYS_SPAWN's
  12. * argument buffer is only 64 bytes)
  13. * wifi saved list the networks saved in /data/WIFI.CFG
  14. * wifi autoconnect join any saved network found (boot helper)
  15. * wifi forget [ssid] remove one saved network, or all without an
  16. * argument
  17. * wifi disconnect
  18. *
  19. * A successful connect adds the SSID/passphrase to a most-recently-used list
  20. * (up to WIFI_CFG_MAX networks) in /data/WIFI.CFG. The WPA2 handshake (wpa.c)
  21. * runs here; a small background copy of this command (`wifi __keep <state>`)
  22. * stays alive after `connect` to answer group-key rekeys, and exits when the
  23. * connection changes. */
  24. #include "ucmd_lib.h"
  25. #include "tls_rng.h"
  26. #include "wifi_store.h"
  27. #include "wpa.h"
  28. #define MAX_BSS 32
  29. static struct sys_wifi_bss bss[MAX_BSS];
  30. static int wifi(int op, int a2, int a3)
  31. {
  32. return u_syscall3(SYS_WIFI, op, a2, a3);
  33. }
  34. static int name_eq(const char *a, const char *b)
  35. {
  36. while (*a && *b) {
  37. if (*a != *b)
  38. return 0;
  39. a++;
  40. b++;
  41. }
  42. return *a == *b;
  43. }
  44. /* Add the network to /data/WIFI.CFG, replacing an older record for the same
  45. * SSID and moving it to the front (most recently used). The BSSID is
  46. * deliberately left zero so a mesh/repeater AP with the same SSID still
  47. * works; /data is a plain FAT partition, so the file is 8.3 and the
  48. * passphrase is stored in clear. */
  49. static int remember_wifi(const unsigned char *ssid, unsigned int ssid_len,
  50. const char *pass, unsigned int pass_len)
  51. {
  52. struct wifi_cfg rec;
  53. unsigned int i;
  54. int r;
  55. if (ssid_len > 32)
  56. ssid_len = 32;
  57. if (pass_len > 64)
  58. pass_len = 64;
  59. for (i = 0; i < sizeof(rec); i++)
  60. ((unsigned char *)&rec)[i] = 0;
  61. rec.magic = WIFI_CFG_MAGIC;
  62. rec.ssid_len = (unsigned char)ssid_len;
  63. rec.pass_len = (unsigned char)pass_len;
  64. for (i = 0; i < ssid_len; i++)
  65. rec.ssid[i] = ssid[i];
  66. for (i = 0; i < pass_len; i++)
  67. rec.pass[i] = pass[i];
  68. r = wifi_store_remember(&rec);
  69. for (i = 0; i < sizeof(rec); i++)
  70. ((volatile unsigned char *)&rec)[i] = 0;
  71. return r;
  72. }
  73. static void put_ssid(const unsigned char *s, unsigned int n)
  74. {
  75. unsigned int i;
  76. for (i = 0; i < n; i++)
  77. u_putc(s[i] >= 32 && s[i] < 127 ? (char)s[i] : '?');
  78. }
  79. static int slen(const char *s)
  80. {
  81. int n = 0;
  82. while (s[n])
  83. n++;
  84. return n;
  85. }
  86. static int starts(const char *s, const char *p)
  87. {
  88. while (*p)
  89. if (*s++ != *p++)
  90. return 0;
  91. return 1;
  92. }
  93. static const char *skip_ws(const char *s)
  94. {
  95. while (*s == ' ')
  96. s++;
  97. return s;
  98. }
  99. /* Next word or "quoted string" into out; returns the rest. */
  100. static const char *word(const char *s, char *out, unsigned int max)
  101. {
  102. unsigned int n = 0;
  103. char end = ' ';
  104. s = skip_ws(s);
  105. if (*s == '"') {
  106. end = '"';
  107. s++;
  108. }
  109. while (*s && *s != end) {
  110. if (end == '"' && *s == '\\' && s[1])
  111. s++;
  112. if (n + 1 < max)
  113. out[n++] = *s;
  114. s++;
  115. }
  116. if (*s == end)
  117. s++;
  118. out[n] = 0;
  119. return s;
  120. }
  121. static void put_dbm(int v)
  122. {
  123. if (v < 0) {
  124. u_putc('-');
  125. v = -v;
  126. }
  127. u_putdec((unsigned int)v);
  128. u_puts(" dBm");
  129. }
  130. static const char *sec_name(unsigned int s)
  131. {
  132. return s == SYS_WIFI_SEC_OPEN ? "open" :
  133. s == SYS_WIFI_SEC_PSK ? "WPA2" : "other";
  134. }
  135. static int cmd_status(void)
  136. {
  137. struct sys_wifi_status st;
  138. static const char *const names[] = { "down", "idle", "associated",
  139. "connected" };
  140. unsigned char ip[4];
  141. if (wifi(SYS_WIFI_STATUS, (int)&st, 0) < 0) {
  142. u_puts("wifi: status failed\n");
  143. return 1;
  144. }
  145. if (!st.present) {
  146. u_puts("wifi: no Intel 7265/3165/6200/6300 card found\n");
  147. return 1;
  148. }
  149. u_puts("chip: "); u_puts(st.chip);
  150. u_puts("\nstate: "); u_puts(names[st.state & 3]);
  151. u_puts(" ("); u_puts(st.detail); u_puts(")\n");
  152. if (st.fw[0]) {
  153. u_puts("firmware: "); u_puts(st.fw); u_puts("\n");
  154. }
  155. if (st.state != SYS_WIFI_ST_DOWN) {
  156. u_puts("mac: "); u_put_mac(st.mac); u_puts("\n");
  157. }
  158. if (st.state >= SYS_WIFI_ST_ASSOC) {
  159. u_puts("network: \""); put_ssid(st.ssid, st.ssid_len);
  160. u_puts("\" "); u_put_mac(st.bssid);
  161. u_puts(" ch "); u_putdec(st.channel);
  162. u_puts(" "); put_dbm(st.rssi); u_puts("\n");
  163. u_syscall1(SYS_NET_GET_IP, (int)ip);
  164. u_puts("ip: "); u_put_ip(ip); u_puts("\n");
  165. u_puts("frames: rx "); u_putdec(st.rx_frames);
  166. u_puts(" tx "); u_putdec(st.tx_frames);
  167. u_puts(" dropped "); u_putdec(st.rx_dropped); u_puts("\n");
  168. }
  169. return 0;
  170. }
  171. static int bring_up(void)
  172. {
  173. struct sys_wifi_status st;
  174. u_puts("wifi: loading firmware...\n");
  175. if (wifi(SYS_WIFI_UP, 0, 0) < 0) {
  176. wifi(SYS_WIFI_STATUS, (int)&st, 0);
  177. u_puts("wifi: bring-up failed: ");
  178. u_puts(st.detail);
  179. u_puts(" (details on the serial/netmon log)\n");
  180. return -1;
  181. }
  182. return 0;
  183. }
  184. /* Scan and return the number of entries, sorted by RSSI. */
  185. static int do_scan(void)
  186. {
  187. int n, i, j;
  188. unsigned int t0;
  189. if (wifi(SYS_WIFI_SCAN, 0, 0) < 0) {
  190. u_puts("wifi: scan failed (disconnect first?)\n");
  191. return -1;
  192. }
  193. t0 = u_ticks_ms();
  194. while ((n = wifi(SYS_WIFI_RESULTS, (int)bss, MAX_BSS)) == -2) {
  195. if (u_ticks_ms() - t0 > 15000) {
  196. u_puts("wifi: scan timed out\n");
  197. return -1;
  198. }
  199. u_sleep_ms(100);
  200. }
  201. if (n < 0)
  202. return -1;
  203. for (i = 1; i < n; i++)
  204. for (j = i; j > 0 && bss[j].rssi > bss[j - 1].rssi; j--) {
  205. struct sys_wifi_bss t = bss[j];
  206. bss[j] = bss[j - 1];
  207. bss[j - 1] = t;
  208. }
  209. return n;
  210. }
  211. static int cmd_scan(void)
  212. {
  213. int n, i;
  214. if (bring_up() < 0)
  215. return 1;
  216. u_puts("wifi: scanning...\n");
  217. n = do_scan();
  218. if (n < 0)
  219. return 1;
  220. if (n == 0)
  221. u_puts("no networks found\n");
  222. for (i = 0; i < n; i++) {
  223. u_put_mac(bss[i].bssid);
  224. u_puts(" ");
  225. put_dbm(bss[i].rssi);
  226. u_puts(bss[i].channel < 10 ? " ch " :
  227. bss[i].channel < 100 ? " ch " : " ch ");
  228. u_putdec(bss[i].channel);
  229. u_puts(" ");
  230. u_puts(sec_name(bss[i].security));
  231. u_puts(bss[i].security == SYS_WIFI_SEC_PSK ? " " : " ");
  232. if (bss[i].ssid_len)
  233. put_ssid(bss[i].ssid, bss[i].ssid_len);
  234. else
  235. u_puts("(hidden)");
  236. u_puts("\n");
  237. }
  238. return 0;
  239. }
  240. static int hexval(char c)
  241. {
  242. if (c >= '0' && c <= '9')
  243. return c - '0';
  244. if (c >= 'a' && c <= 'f')
  245. return c - 'a' + 10;
  246. if (c >= 'A' && c <= 'F')
  247. return c - 'A' + 10;
  248. return -1;
  249. }
  250. static int unhex(const char *s, unsigned char *out, unsigned int n)
  251. {
  252. unsigned int i;
  253. for (i = 0; i < n; i++) {
  254. int a = hexval(s[2 * i]), b = hexval(s[2 * i + 1]);
  255. if (a < 0 || b < 0)
  256. return -1;
  257. out[i] = (unsigned char)(a * 16 + b);
  258. }
  259. return 0;
  260. }
  261. static void tohex(const unsigned char *in, unsigned int n, char *out)
  262. {
  263. static const char hx[] = "0123456789abcdef";
  264. unsigned int i;
  265. for (i = 0; i < n; i++) {
  266. out[2 * i] = hx[in[i] >> 4];
  267. out[2 * i + 1] = hx[in[i] & 15];
  268. }
  269. out[2 * n] = 0;
  270. }
  271. static int set_gtk(struct wpa_sm *sm)
  272. {
  273. struct sys_wifi_key k;
  274. unsigned int i;
  275. k.pairwise = 0;
  276. k.keyidx = sm->gtk_idx;
  277. for (i = 0; i < 16; i++)
  278. k.key[i] = sm->gtk[i];
  279. for (i = 0; i < 8; i++)
  280. k.rsc[i] = sm->gtk_rsc[i];
  281. return wifi(SYS_WIFI_SET_KEY, (int)&k, 0);
  282. }
  283. /* Run the 4-way handshake: msg1 -> msg2, msg3 -> msg4 + keys. */
  284. static int handshake(struct wpa_sm *sm)
  285. {
  286. static unsigned char frame[1024], reply[256];
  287. unsigned int t0 = u_ticks_ms(), rlen;
  288. int n, r;
  289. while (u_ticks_ms() - t0 < 8000) {
  290. n = wifi(SYS_WIFI_EAPOL_RX, (int)frame, sizeof(frame));
  291. if (n < 0)
  292. return -1;
  293. if (n == 0) {
  294. u_sleep_ms(20);
  295. continue;
  296. }
  297. r = wpa_rx(sm, frame, (unsigned int)n, reply, &rlen, tls_random);
  298. if (r == WPA_ERR) {
  299. u_puts("wifi: handshake: ");
  300. u_puts(sm->error ? sm->error : "error");
  301. u_puts("\n");
  302. return -1;
  303. }
  304. if (r == WPA_NONE)
  305. continue;
  306. if (wifi(SYS_WIFI_EAPOL_TX, (int)reply, (int)rlen) < 0)
  307. return -1;
  308. if (r == WPA_PTK) {
  309. struct sys_wifi_key k;
  310. unsigned int i;
  311. k.pairwise = 1;
  312. k.keyidx = 0;
  313. for (i = 0; i < 16; i++)
  314. k.key[i] = WPA_TK(sm)[i];
  315. for (i = 0; i < 8; i++)
  316. k.rsc[i] = 0;
  317. u_sleep_ms(20); /* let message 4 leave in the clear */
  318. if (wifi(SYS_WIFI_SET_KEY, (int)&k, 0) < 0 ||
  319. set_gtk(sm) < 0) {
  320. u_puts("wifi: key install failed\n");
  321. return -1;
  322. }
  323. return 0;
  324. }
  325. }
  326. u_puts("wifi: handshake timed out (no EAPOL from the AP)\n");
  327. return -1;
  328. }
  329. static void spawn_keeper(struct wpa_sm *sm, unsigned int conn_id)
  330. {
  331. static char arg[16];
  332. struct sys_wifi_ptk p;
  333. unsigned char id[4];
  334. char *q = arg;
  335. unsigned int i;
  336. p.conn_id = conn_id;
  337. for (i = 0; i < 48; i++)
  338. p.ptk[i] = sm->ptk[i];
  339. for (i = 0; i < 8; i++)
  340. p.replay[i] = sm->replay[i];
  341. if (wifi(SYS_WIFI_SET_PTK, (int)&p, 0) < 0) {
  342. u_puts("wifi: note: could not store rekey state; the link will "
  343. "drop at the next group rekey\n");
  344. return;
  345. }
  346. for (i = 0; "__keep "[i]; i++)
  347. *q++ = "__keep "[i];
  348. id[0] = conn_id >> 24;
  349. id[1] = conn_id >> 16;
  350. id[2] = conn_id >> 8;
  351. id[3] = conn_id;
  352. tohex(id, 4, q);
  353. q += 8;
  354. *q = 0;
  355. if (u_spawn("/ramfs/bin/wifi", arg, 0, "/") < 0)
  356. u_puts("wifi: note: rekey helper did not start; the link will "
  357. "drop at the next group rekey\n");
  358. }
  359. /* Join one BSS from a completed scan. `pass` is empty for an open network.
  360. * Returns 0 when the data port is open, 1 on failure. */
  361. static int join_bss(const struct sys_wifi_bss *b, const char *pass)
  362. {
  363. struct sys_wifi_connect c;
  364. struct sys_wifi_status st;
  365. static struct wpa_sm sm;
  366. unsigned char pmk[32];
  367. unsigned int ssid_len = b->ssid_len;
  368. int i, r;
  369. if (ssid_len == 0 || ssid_len > 32) {
  370. u_puts("wifi: malformed SSID in scan result\n");
  371. return 1;
  372. }
  373. if (b->security == SYS_WIFI_SEC_OTHER) {
  374. u_puts("wifi: unsupported security (only open and WPA2-PSK/CCMP)\n");
  375. return 1;
  376. }
  377. if (b->security == SYS_WIFI_SEC_PSK && !pass[0]) {
  378. u_puts("wifi: this network needs a passphrase\n");
  379. return 1;
  380. }
  381. for (i = 0; i < (int)sizeof(c); i++)
  382. ((unsigned char *)&c)[i] = 0;
  383. for (i = 0; i < 6; i++)
  384. c.bssid[i] = b->bssid[i];
  385. c.channel = b->channel;
  386. c.ssid_len = (unsigned char)ssid_len;
  387. for (i = 0; i < (int)ssid_len; i++)
  388. c.ssid[i] = b->ssid[i];
  389. c.beacon_int = b->beacon_int;
  390. c.dtim = b->dtim;
  391. if (b->security == SYS_WIFI_SEC_PSK) {
  392. int plen = slen(pass);
  393. if (plen == 64 && unhex(pass, pmk, 32) == 0) {
  394. /* raw 256-bit PSK */
  395. } else if (plen >= 8 && plen <= 63) {
  396. u_puts("wifi: deriving key...\n");
  397. wpa_pmk(pass, c.ssid, ssid_len, pmk);
  398. } else {
  399. u_puts("wifi: a WPA2 passphrase has 8..63 characters\n");
  400. return 1;
  401. }
  402. c.ie_len = (unsigned char)wpa_rsn_ie(c.ie);
  403. }
  404. u_puts("wifi: joining "); u_put_mac(c.bssid);
  405. u_puts(" on channel "); u_putdec(c.channel); u_puts("\n");
  406. if (wifi(SYS_WIFI_CONNECT, (int)&c, 0) < 0) {
  407. wifi(SYS_WIFI_STATUS, (int)&st, 0);
  408. u_puts("wifi: "); u_puts(st.detail); u_puts("\n");
  409. return 1;
  410. }
  411. wifi(SYS_WIFI_STATUS, (int)&st, 0);
  412. if (b->security == SYS_WIFI_SEC_PSK) {
  413. wpa_init(&sm, pmk, c.bssid, st.mac, c.ie, c.ie_len,
  414. b->rsn, b->rsn_len);
  415. u_puts("wifi: 4-way handshake...\n");
  416. if (handshake(&sm) < 0) {
  417. wifi(SYS_WIFI_DISCONNECT, 0, 0);
  418. return 1;
  419. }
  420. }
  421. r = wifi(SYS_WIFI_AUTHORIZE, 0, 0);
  422. if (r < 0)
  423. u_puts("wifi: connected, but the WiFi card could not become the "
  424. "active netdev (close TCP users, then `netdev wifi`)\n");
  425. else
  426. u_puts("wifi: connected\n");
  427. if (b->security == SYS_WIFI_SEC_PSK)
  428. spawn_keeper(&sm, st.conn_id);
  429. if (r == 0 && u_syscall1(SYS_DHCP_RUN, 6000) != 0)
  430. u_puts("wifi: DHCP failed; set an address with netip\n");
  431. return r == 0 ? 0 : 1;
  432. }
  433. static int connect_bss(const char *ssid, const char *pass,
  434. const unsigned char *want_bssid)
  435. {
  436. struct sys_wifi_bss *b = 0;
  437. int n, i;
  438. unsigned int ssid_len;
  439. int have_bssid = want_bssid != 0;
  440. ssid_len = (unsigned int)slen(ssid);
  441. if (!ssid_len) {
  442. u_puts("usage: wifi connect <ssid> [passphrase]\n");
  443. return 1;
  444. }
  445. if (bring_up() < 0)
  446. return 1;
  447. wifi(SYS_WIFI_DISCONNECT, 0, 0);
  448. u_puts("wifi: scanning for \""); u_puts(ssid); u_puts("\"...\n");
  449. n = do_scan();
  450. if (n < 0)
  451. return 1;
  452. for (i = 0; i < n; i++) {
  453. unsigned int j;
  454. if (bss[i].ssid_len != ssid_len)
  455. continue;
  456. if (have_bssid) {
  457. for (j = 0; j < 6 && bss[i].bssid[j] == want_bssid[j]; j++)
  458. ;
  459. if (j != 6)
  460. continue;
  461. }
  462. for (j = 0; j < ssid_len && bss[i].ssid[j] == (unsigned char)ssid[j]; j++)
  463. ;
  464. if (j == ssid_len) {
  465. b = &bss[i]; /* sorted: first match is strongest */
  466. break;
  467. }
  468. }
  469. if (!b) {
  470. u_puts("wifi: network not found\n");
  471. return 1;
  472. }
  473. return join_bss(b, pass);
  474. }
  475. static int cmd_connect(const char *args)
  476. {
  477. char ssid[33], pass[80], bssid_s[13];
  478. unsigned char want_bssid[6];
  479. int have_bssid = 0;
  480. int r;
  481. args = word(args, ssid, sizeof(ssid));
  482. args = word(args, pass, sizeof(pass));
  483. if (*skip_ws(args)) {
  484. word(args, bssid_s, sizeof(bssid_s));
  485. if (slen(bssid_s) != 12 ||
  486. unhex(bssid_s, want_bssid, 6) < 0) {
  487. u_puts("wifi: BSSID must be 12 hex digits\n");
  488. return 1;
  489. }
  490. have_bssid = 1;
  491. }
  492. r = connect_bss(ssid, pass, have_bssid ? want_bssid : 0);
  493. if (r == 0) {
  494. if (remember_wifi((const unsigned char *)ssid,
  495. (unsigned int)slen(ssid), pass,
  496. (unsigned int)slen(pass)) == 0)
  497. u_puts("wifi: saved for auto-connect\n");
  498. else
  499. u_puts("wifi: note: could not save credentials to /data\n");
  500. }
  501. return r;
  502. }
  503. /* `wifi connectfile <path>`: the network menu stages an SSID + passphrase +
  504. * BSSID record in /share because SYS_SPAWN's argument buffer is only
  505. * VFS_PATH_MAX (64) bytes. The file is removed after it has been read. */
  506. static int cmd_connect_file(const char *args)
  507. {
  508. struct wifi_cfg cfg;
  509. char path[80], ssid[33], pass[65];
  510. unsigned int i;
  511. int r;
  512. args = word(args, path, sizeof(path));
  513. for (i = 0; i < sizeof(cfg); i++)
  514. ((unsigned char *)&cfg)[i] = 0;
  515. r = u_syscall3(SYS_READ_FILE, (int)path, (int)&cfg, (int)sizeof(cfg));
  516. u_syscall1(SYS_UNLINK, (int)path);
  517. if (r < 0 || (unsigned int)r < sizeof(cfg) ||
  518. cfg.magic != WIFI_CFG_MAGIC) {
  519. u_puts("wifi: no valid staged connect request\n");
  520. return 1;
  521. }
  522. if (cfg.ssid_len == 0 || cfg.ssid_len > 32 || cfg.pass_len > 64) {
  523. u_puts("wifi: staged connect request is malformed\n");
  524. return 1;
  525. }
  526. for (i = 0; i < cfg.ssid_len; i++)
  527. ssid[i] = (char)cfg.ssid[i];
  528. ssid[cfg.ssid_len] = '\0';
  529. for (i = 0; i < cfg.pass_len; i++)
  530. pass[i] = cfg.pass[i];
  531. pass[cfg.pass_len] = '\0';
  532. r = connect_bss(ssid, pass, cfg.bssid);
  533. if (r == 0) {
  534. if (remember_wifi(cfg.ssid, cfg.ssid_len, cfg.pass,
  535. cfg.pass_len) == 0)
  536. u_puts("wifi: saved for auto-connect\n");
  537. else
  538. u_puts("wifi: note: credentials not saved (no writable /data)\n");
  539. }
  540. for (i = 0; i < sizeof(cfg); i++)
  541. ((unsigned char *)&cfg)[i] = 0;
  542. for (i = 0; i < sizeof(pass); i++)
  543. ((volatile char *)pass)[i] = 0;
  544. return r;
  545. }
  546. /* Boot-time helper: scan once, then join the strongest network present whose
  547. * SSID is in /data/WIFI.CFG. If none succeeds, scan again after three
  548. * seconds. A wired link that is physically up wins; an existing WiFi link
  549. * is left alone. */
  550. static int cmd_autoconnect(void)
  551. {
  552. struct wifi_cfg nets[WIFI_CFG_MAX];
  553. struct sys_wifi_status ws;
  554. struct sys_netinfo ni;
  555. char pass[65];
  556. int count, n, i, round, r = 1;
  557. count = wifi_store_load(nets, WIFI_CFG_MAX);
  558. if (count <= 0)
  559. return 0;
  560. /* A wired link that is physically up wins: do not even probe the WiFi
  561. * card in that case. Only fall back to WiFi when no cable is
  562. * connected. */
  563. if (u_net_info(&ni) == 1 && ni.present && ni.link &&
  564. !name_eq(ni.name, "wifi"))
  565. goto out;
  566. if (u_wifi(SYS_WIFI_STATUS, (int)&ws, 0) != 0 || !ws.present)
  567. goto out;
  568. if (ws.state >= SYS_WIFI_ST_LINK)
  569. goto out;
  570. if (bring_up() < 0)
  571. goto out;
  572. for (round = 0; round < 2 && r; round++) {
  573. unsigned char tried[WIFI_CFG_MAX];
  574. unsigned int j;
  575. if (round)
  576. u_sleep_ms(3000);
  577. for (j = 0; j < WIFI_CFG_MAX; j++)
  578. tried[j] = 0;
  579. wifi(SYS_WIFI_DISCONNECT, 0, 0);
  580. n = do_scan();
  581. if (n < 0)
  582. continue;
  583. for (i = 0; i < n && r; i++) {
  584. struct sys_wifi_bss *b = &bss[i];
  585. int ci;
  586. if (b->security == SYS_WIFI_SEC_OTHER)
  587. continue;
  588. ci = wifi_store_find(nets, count, b->ssid,
  589. b->ssid_len);
  590. if (ci < 0 || tried[ci])
  591. continue;
  592. if (b->security == SYS_WIFI_SEC_PSK &&
  593. nets[ci].pass_len == 0)
  594. continue;
  595. tried[ci] = 1;
  596. for (j = 0; j < nets[ci].pass_len; j++)
  597. pass[j] = nets[ci].pass[j];
  598. pass[nets[ci].pass_len] = '\0';
  599. u_puts("wifi: auto-connect \"");
  600. put_ssid(b->ssid, b->ssid_len);
  601. u_puts("\"\n");
  602. r = join_bss(b, pass);
  603. for (j = 0; j < sizeof(pass); j++)
  604. ((volatile char *)pass)[j] = 0;
  605. if (r != 0)
  606. wifi(SYS_WIFI_DISCONNECT, 0, 0);
  607. }
  608. }
  609. out:
  610. for (i = 0; i < (int)sizeof(nets); i++)
  611. ((volatile unsigned char *)nets)[i] = 0;
  612. for (i = 0; i < (int)sizeof(pass); i++)
  613. ((volatile char *)pass)[i] = 0;
  614. return r;
  615. }
  616. static int cmd_saved(void)
  617. {
  618. struct wifi_cfg list[WIFI_CFG_MAX];
  619. int n, i;
  620. unsigned int j;
  621. n = wifi_store_load(list, WIFI_CFG_MAX);
  622. if (n <= 0) {
  623. u_puts("wifi: no saved networks\n");
  624. return 0;
  625. }
  626. u_puts("saved networks (");
  627. u_putdec((unsigned int)n);
  628. u_puts("):\n");
  629. for (i = 0; i < n; i++) {
  630. u_puts(" \"");
  631. put_ssid(list[i].ssid, list[i].ssid_len);
  632. u_puts("\" ");
  633. u_puts(list[i].pass_len ? "WPA2-PSK" : "open");
  634. u_puts("\n");
  635. }
  636. for (j = 0; j < sizeof(list); j++)
  637. ((volatile unsigned char *)list)[j] = 0;
  638. return 0;
  639. }
  640. static int cmd_forget(const char *args)
  641. {
  642. char ssid[33];
  643. int r;
  644. args = word(args, ssid, sizeof(ssid));
  645. if (!ssid[0]) {
  646. if (u_syscall1(SYS_UNLINK, (int)WIFI_CRED_PATH) == 0)
  647. u_puts("wifi: saved networks removed\n");
  648. else
  649. u_puts("wifi: no saved networks\n");
  650. return 0;
  651. }
  652. r = wifi_store_forget((const unsigned char *)ssid,
  653. (unsigned int)slen(ssid));
  654. if (r > 0)
  655. u_puts("wifi: saved network removed\n");
  656. else if (r == 0)
  657. u_puts("wifi: network is not saved\n");
  658. else
  659. u_puts("wifi: could not update /data/WIFI.CFG\n");
  660. return r < 0 ? 1 : 0;
  661. }
  662. /* Background: answer group-key rekeys until the connection changes. */
  663. static int keeper(const char *args)
  664. {
  665. static struct wpa_sm sm;
  666. static unsigned char frame[1024], reply[256];
  667. struct sys_wifi_status st;
  668. struct sys_wifi_ptk p;
  669. unsigned char id[4];
  670. unsigned int conn_id, rlen, i;
  671. args = skip_ws(args);
  672. if (slen(args) < 8 || unhex(args, id, 4) < 0) {
  673. u_puts("wifi: keeper: bad state argument\n");
  674. return 1;
  675. }
  676. conn_id = ((unsigned int)id[0] << 24) | (id[1] << 16) |
  677. (id[2] << 8) | id[3];
  678. if (wifi(SYS_WIFI_GET_PTK, (int)&p, (int)conn_id) < 0 ||
  679. p.conn_id != conn_id) {
  680. u_puts("wifi: keeper: no key state for this connection\n");
  681. return 1;
  682. }
  683. for (i = 0; i < 48; i++)
  684. sm.ptk[i] = p.ptk[i];
  685. for (i = 0; i < 8; i++)
  686. sm.replay[i] = p.replay[i];
  687. sm.have_replay = 1;
  688. sm.ptk_ok = 1;
  689. u_puts("wifi: keeper running\n");
  690. for (;;) {
  691. int n, r;
  692. if (wifi(SYS_WIFI_STATUS, (int)&st, 0) < 0 ||
  693. st.conn_id != conn_id || st.state < SYS_WIFI_ST_ASSOC)
  694. return 0;
  695. n = wifi(SYS_WIFI_EAPOL_RX, (int)frame, sizeof(frame));
  696. if (n > 0) {
  697. r = wpa_rx(&sm, frame, (unsigned int)n, reply, &rlen,
  698. tls_random);
  699. u_puts("wifi: keeper eapol ");
  700. u_putdec((unsigned int)n);
  701. u_puts(" -> ");
  702. u_putdec((unsigned int)r);
  703. u_puts("\n");
  704. if (r == WPA_GTK) {
  705. wifi(SYS_WIFI_EAPOL_TX, (int)reply, (int)rlen);
  706. u_puts("wifi: keeper gtk ");
  707. u_putdec((unsigned int)sm.gtk_idx);
  708. u_puts(set_gtk(&sm) == 0 ? " installed\n"
  709. : " install failed\n");
  710. } else if (r == WPA_ERR) {
  711. u_puts("wifi: keeper error: ");
  712. u_puts(sm.error ? sm.error : "?");
  713. u_puts("\n");
  714. }
  715. }
  716. u_sleep_ms(200);
  717. }
  718. }
  719. void _start(const char *arg)
  720. {
  721. const char *a = skip_ws(arg ? arg : "");
  722. int r = 0;
  723. if (!*a)
  724. r = cmd_status();
  725. else if (starts(a, "__keep "))
  726. r = keeper(a + 7);
  727. else if (starts(a, "up")) {
  728. r = bring_up() < 0;
  729. if (!r)
  730. r = cmd_status();
  731. } else if (starts(a, "scan"))
  732. r = cmd_scan();
  733. else if (starts(a, "connect "))
  734. r = cmd_connect(a + 8);
  735. else if (starts(a, "connectfile "))
  736. r = cmd_connect_file(a + 12);
  737. else if (starts(a, "saved"))
  738. r = cmd_saved();
  739. else if (starts(a, "autoconnect"))
  740. r = cmd_autoconnect();
  741. else if (starts(a, "forget"))
  742. r = cmd_forget(a + 6);
  743. else if (starts(a, "disconnect")) {
  744. wifi(SYS_WIFI_DISCONNECT, 0, 0);
  745. u_puts("wifi: disconnected\n");
  746. } else {
  747. u_puts("usage: wifi [up|scan|connect <ssid> [pass] [bssid]|connectfile <path>|saved|autoconnect|forget [ssid]|disconnect]\n");
  748. r = 1;
  749. }
  750. u_exit(r);
  751. }