eculocate

wibble.rs (9282B)

---

 use embassy_time::{Duration,Timer};
 use trouble_host::prelude::*;
 use esp_radio::ble::controller::BleConnector;
 use esp_radio::Controller as RadioController;
 use log::{warn,info};
 use embassy_futures::join::join;
 use embassy_futures::select::select;
 
 use crypto_box::{
     aead::Aead,
     SalsaBox, PublicKey, SecretKey, Nonce
 };
 
 use alloc::vec::Vec;
 use alloc::string::String;
 
 use crate::ota::Flasher;
 
 /// Max number of connections
 const CONNECTIONS_MAX: usize = 1;
 
 /// Max number of L2CAP channels.
 // XXX why not 0?
 const L2CAP_CHANNELS_MAX: usize = 2; // Signal + att
 
 // GATT Server definition
 #[gatt_server]
 struct Server {
     wifi_provisioning_service: WifiProvisioningService,
 }
 
 
 #[gatt_service(uuid = "76be25c2-0000-44fc-a97c-bcb56c69c926")]
 struct WifiProvisioningService {
     #[characteristic(uuid = "76be25c2-0801-44fc-a97c-bcb56c69c926", read, notify, value = false)]
     connecting: bool,
 
     #[characteristic(uuid = "76be25c2-0802-44fc-a97c-bcb56c69c926", read, notify, value = 0)]
     max_network_index: u8,
 
     #[characteristic(uuid = "76be25c2-0803-44fc-a97c-bcb56c69c926", read, write, value = 0)]
     current_network_index: u8,
 
     // for arrays > 32 we must supply a default value : see
     // https://github.com/embassy-rs/trouble/issues/320
     #[characteristic(uuid = "76be25c2-0804-44fc-a97c-bcb56c69c926",
 		     value = [0; 40],
 		     read, notify)]
     current_network: [u8; 40],
 
     #[characteristic(uuid = "76be25c2-0805-44fc-a97c-bcb56c69c926",
 		     value = [0; (1 + 32 + 1 + 24 + 16 + 64)],
 		     write)]
     secret: [u8; 1+ 32 + 1 + 24 + 16 + 64]
 }
 
 
 pub async fn run_ble(radio_init: &RadioController<'static>,
 		     peripheral:  esp_hal::peripherals::BT<'_>,
 		     networks: Vec<[u8; 40]>,
 		     mut flasher: Flasher<'_>) {
     let connector = BleConnector::new(&radio_init, peripheral, Default::default()).expect("connector");
     let controller: ExternalController<_, 20> = ExternalController::new(connector);
 
     // Using a fixed "random" address can be useful for testing. In real scenarios, one would
     // use e.g. the MAC 6 byte array as the address (how to get that varies by the platform).
     let address: Address = Address::random([0xff, 0x8f, 0x1a, 0x05, 0xe4, 0xff]);
     info!("Our address = {:?}", address);
 
     let mut resources: HostResources<DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> = HostResources::new();
     let stack = trouble_host::new(controller, &mut resources).set_random_address(address);
     let Host {
         mut peripheral, runner, ..
     } = stack.build();
 
     info!("Starting advertising and GATT service");
     let server = Server::new_with_config(GapConfig::Peripheral(PeripheralConfig {
         name: "eculocate",
         appearance: &appearance::power_device::GENERIC_POWER_DEVICE,
     }))
     .unwrap();
 
     let _ = join(
 	ble_task(runner),
 	async {
             loop {
 		match advertise("Eculocate", &mut peripheral, &server).await {
                     Ok(conn) => {
 			// set up tasks when the connection is established to a central, so they don't run when no one is connected.
 			let a = gatt_events_task(&server, &conn, &networks, &mut flasher);
 			let b = custom_task(&server, &conn, &stack);
 			// run until any task ends (usually because the connection has been closed),
 			// then return to advertising state.
 			select(a, b).await;
                     }
                     Err(e) => {
 			panic!("[adv] error: {:?}", e);
                     }
 		}
             }
 	})
     .await;
 }
 
 /// This is a background task that is required to run forever alongside any other BLE tasks.
 ///
 async fn ble_task<C: Controller, P: PacketPool>(mut runner: Runner<'_, C, P>) {
     loop {
         if let Err(e) = runner.run().await {
             panic!("[ble_task] error: {:?}", e);
         }
     }
 }
 
 const CLIENT_PUBLIC_KEY_BYTES: &[u8; 32] = include_bytes!("../../keys/client.pub");
 const SECRET_KEY_BYTES : &[u8; 32] = include_bytes!("../../keys/device.key");
 
 #[derive(Debug)]
 enum DecryptError {
     Crypto(crypto_box::aead::Error),
     Encoding(alloc::str::Utf8Error)
 }
 impl From<crypto_box::aead::Error>  for DecryptError {
     fn from(e: crypto_box::aead::Error) -> Self {
 	Self::Crypto(e)
     }
 }
 impl From<alloc::str::Utf8Error>  for DecryptError {
     fn from(e: alloc::str::Utf8Error) -> Self { Self::Encoding(e) }
 }
 
 fn decrypt_secret(ciphertext : &[u8]) -> Result<Vec<u8>, DecryptError>  {
     let client_public_key = PublicKey::from(*CLIENT_PUBLIC_KEY_BYTES);
     let secret_key= SecretKey::from(*SECRET_KEY_BYTES);
 
     let len : usize = ciphertext[0].into();
     let ciphertext = &ciphertext[1..len+1];
 
     let (nonce, encrypted) = ciphertext.split_at(24);
     let nonce = Nonce::from_slice(nonce);
 
     let sbox = SalsaBox::new(&client_public_key, &secret_key);
     let plain_bytes = sbox.decrypt(nonce, encrypted)?;
 
     Ok(Vec::from(plain_bytes))
 }
 
 
 /// Stream Events until the connection closes.
 ///
 /// This function will handle the GATT events and process them.
 /// This is how we interact with read and write requests.
 async fn gatt_events_task<P: PacketPool>(server: &Server<'_>,
 					 conn: &GattConnection<'_, '_, P>,
 					 networks: &Vec<[u8; 40]>,
 					 flasher: &mut Flasher<'_>) -> Result<(), Error> {
     let wps = &server.wifi_provisioning_service;
     let max_index : u8 = (networks.len() & 0xff).try_into().unwrap();
 
     server.set(&wps.max_network_index, &max_index);
     let current_index = wps.current_network_index;
     let reason = loop {
         match conn.next().await {
             GattConnectionEvent::Disconnected { reason } => break reason,
             GattConnectionEvent::Gatt { event } => {
                 match &event {
                     GattEvent::Write(event) => {
 			info!("[gatt] write handle {:?} {:?}", event.handle(),
 			      event.data());
 			if event.handle() == current_index.handle {
 			    let i = (event.data()[0]) as usize;
 			    info!("[gatt] switch current index: {:?}", i);
 			    if i == 0 {
 				server.set(&wps.current_network, &[0u8;40]);
 			    } else if i <= networks.len() {
 				server.set(&wps.current_network,
 					   &(networks[i - 1]));
 			    } else {
 				warn!("index {:?} out of range", i);
 			    }
 			} else if event.handle() == wps.connecting.handle {
 			    let val = server.get(&wps.secret).unwrap();
 			    let name_len : usize = val[0].into();
 			    let name = &val[1..name_len+1];
 
 			    match decrypt_secret(&val[name_len+1..]) {
 				Ok(pw) => {
 				    write_wifi_config(flasher, name, &pw[..]).await;
 				},
 				Err(e) => {
 				    warn!("decrypt error: {:?}", e);
 				}
 			    }
                         }
                     },
                     _ => {}
                 };
                 // This step is also performed at drop(), but writing
                 // it explicitly is necessary in order to ensure reply
                 // is sent.
                 match event.accept() {
                     Ok(reply) => reply.send().await,
                     Err(e) => warn!("[gatt] error sending response: {:?}", e),
                 };
             }
             _ => {} // ignore other Gatt Connection Events
         }
     };
     info!("[gatt] disconnected: {:?}", reason);
     Ok(())
 }
 
 async fn write_wifi_config(flasher: &mut Flasher<'_>, ssid: &[u8], password: &[u8]) -> Result<(),esp_nvs::error::Error> {
     let ssid = core::str::from_utf8(ssid).unwrap();
     let password = core::str::from_utf8(password).unwrap();
     flasher.set_var("ssid", Some(ssid))?;
     flasher.set_var("secret", Some(password))?;
     info!("[gatt] deep breath then reboot");
     Timer::after(Duration::from_millis(2000)).await;
     esp_hal::system::software_reset();
 }
 
 /// Create an advertiser to use to connect to a BLE Central, and wait for it to connect.
 async fn advertise<'values, 'server, C: Controller>(
     name: &'values str,
     peripheral: &mut Peripheral<'values, C, DefaultPacketPool>,
     server: &'server Server<'values>,
 ) -> Result<GattConnection<'values, 'server, DefaultPacketPool>, BleHostError<C::Error>> {
     let mut advertiser_data = [0; 31];
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
             AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],
     )?;
     let advertiser = peripheral
         .advertise(
             &Default::default(),
             Advertisement::ConnectableScannableUndirected {
                 adv_data: &advertiser_data[..len],
                 scan_data: &[],
             },
         )
         .await?;
     info!("[adv] advertising");
     let conn = advertiser.accept().await?.with_attribute_server(server)?;
     info!("[adv] connection established");
     Ok(conn)
 }
 
 async fn custom_task<C: Controller, P: PacketPool>(
     _server: &Server<'_>,
     conn: &GattConnection<'_, '_, P>,
     stack: &Stack<'_, C, P>,
 ) {
     loop {
         // read RSSI (Received Signal Strength Indicator) of the connection.
         if let Ok(rssi) = conn.raw().rssi(stack).await {
             info!("[custom_task] RSSI: {:?}", rssi);
         } else {
             info!("[custom_task] error getting RSSI");
             break;
         };
 
         Timer::after_secs(2).await;
     }
 }