Sebastian Dehne decided to build a custom electric vehicle (EV) charging station for his Nissan Leaf from scratch, as what he calls “a real full stack project.” He notes that creating your own gives you total control over the system, and it’s both fun and cheaper than purchasing a ready-made device.
The aptly named DehneEVSE is based on an Arduino Nano 33 IoT for control and current/voltage sensing, and connects via WiFi to a server that handles charging logic. UI consists of a web app that uses WebSockets to listen for real-time updates and display power consumption for all three phases. Aside from the stats, the app enables Dehne to turn charging on/off or to a low-cost setting, which regulates charge depending on the price of energy at a particular time.
A short demo of the DehneEVSE can be seen in the video below, while more details on the station including links to the files and code are available in Dehne’s blog post.
Kaleb Clark, like many of us, works with others from all around the globe. While he could view any number of websites or commercial options to see what time it is for these other people, he decided to make a world clock to get this info at a glance.
What he came up with uses a 3.5″ SPI TFT screen to show eight time zones in the device’s main section, plus a pair of 7-segment displays for two more “slots.” The unit runs on an Arduino Nano 33 IoT, which checks the time over WiFi via the Network Time Protocol, or NTP.
In theory, Clark will never have to set this clock, but user interface is provided by an encoder to select the times on display, and whether they are shown in a 12 or 24-hour format.
Natasha (AKA TechnoChic) is a member of a bicycle club that goes for rides at night during the summer, and while off-the-shelf lights are fine, she wanted something a bit more interesting. To accomplish this, while learning more about the technologies involved, she decided to equip her bike with an array of addressable LEDs.
The bike frame’s NeoPixels run on an Arduino Nano 33 IoT, which is connected to a boombox via a 3.5mm jack that enables the LEDs to react to the music. Two other Nano 33 IoT boards are used to drive the lights on each of the wheels, with the eventual goal of linking them wirelessly for central control. The system is powered by a 10,000mAh battery pack along with a pair of 2000mAh LiPos for the wheels to keep things glowing for several hours.
Staacks’ setup consists of a half dozen Gardena valves, which are housed in underground boxes, while the brains and power supply are screwed to a wooden board on a wall in his garage. An Arduino Nano 33 IoT is employed to activate the sprinklers in six zones with an eight-channel relay bank. Relay channels 1 to 6 correspond to the valves controlling the sprinklers, the seventh is used to trigger the main valve, and the eighth is is not related to this project.
The device operates over WiFi using MQTT via an OpenHAB installation. It also features a pair of buttons and a small OLED screen for manual interface, especially useful when he’s on vacation and someone else is taking care of the house.
The open-source library ArduinoBearSSL for implementing TLS protocol on Arduino boards;
A hardware secure element (Microchip ATECCX08A) to guarantee authenticity and confidentiality during communication;
A device certificate provisioning process to allow client authentication during MQTT sessions.
In the past, it has been challenging to create a complete SSL/TLS library implementation on embedded (constrained) devices with very limited resources.
An Arduino MKR WiFi 1010, for instance, only has 32KB of RAM while the standard SSL/TLS protocol implementations were designed for more powerful devices with ~256MB of RAM.
As of today, a lot of embedded devices still do not properly implement the full SSL/TLS stack and fail to implement good security because they misuse or strip functionalities from the library, e.g. we found out that a lot of off-brand boards use code that does not actually validate the server’s certificate, making them an easy target for server impersonation and man-in-the-middle attacks.
Security is paramount to us, and we do not want to make compromises in this regard when it comes to our offering in both hardware and software. We are therefore always looking at “safe by default” settings and implementations.
Particularly in the IoT era, operating without specific security measures in place puts customers and their data at risk.
This is why we wanted to make sure the security standards adopted nowadays in high-performance settings are ported to microcontrollers (MCUs) and embedded devices.
Back in 2017, while looking at different SSL/TLS libraries supporting TLS 1.2 and modern cryptography (something that could work with very little RAM/ROM footprint, have no OS dependency, and be compatible with the embedded C world), we decided to give BearSSL a try.
BearSSL: What is it?
BearSSL provides an implementation of the SSL/TLS protocol (RFC 5246) written in C and developed by Thomas Pornin.
Optimized for constrained devices, BearSSL aims at small code footprint and low RAM usage. As per its guiding rules, it tries to find a reasonable trade-off between several partly conflicting goals:
Security: defaults should be robust and using patently insecure algorithms or protocols should be made difficult in the API, or simply not possible;
Interoperability with existing SSL/TLS servers;
Allowing lightweight algorithms for CPU-challenged platforms;
Be extensible with strong and efficient implementations on big systems where code footprint is less important.
BearSSL and Arduino
Our development team picked it as an excellent starting point for us to make BearSSL fit in our Arduino boards focusing on both security and performance.
The firmware developers team worked hard on porting BearSSL to Arduino bundling it together as a very nice and open-source library: ArduinoBearSSL.
Because the computational effort of performing a crypto algorithm is high, we decided to offload part of this task to hardware, using a secure element (we often call it a “cypto chip”). Its advantages are:
Making the computation of cryptography operations faster;
You are not forced to use all the available RAM of your device for these demanding tasks;
Allows storing private keys securely (more on this later);
It provides a true random number generator (TRNG).
How does the TLS protocol work?
TLS uses both asymmetric and symmetric encryption. Asymmetric encryption is used during the TLS handshake between the client and the server to exchange the shared session key for communication encryption. The algorithms commonly used in this phase are based on Rivest-Shamir-Adleman (RSA) or Diffie-Hellman algorithms.
TLS 1.2 Handshake flow
After the TLS handshake, the client and the server both have a session key for symmetric encryption (e.g. algorithms AES 128 or AES 256).
The TLS protocol is an important part of our IoT Cloud security model because it guarantees an encrypted communication between the IoT devices and our servers.
The secure element
In order to save memory and improve security, our development team has chosen to introduce a hardware secure element to offload part of the cryptography algorithms computational load, as well as to generate, store, and manage certificates. For this reason, on the Arduino MKR family, Arduino Nano 33 IoT and Arduino Uno WiFi Rev2, you will find the secure element ATECC508A or ATECC608A manufactured by Microchip.
How do we use the secure element?
A secure element is an advanced hardware component able to perform cryptographic functions, we have decided to implement it on our boards to guarantee two fundamental security properties in the IoT communication:
Authenticity: You can trust who you are communicating with;
Confidentiality: You can be sure the communication is private.
Moreover, the secure element is used during the provisioning process to configure the Arduino board for Arduino IoT Cloud. In order to connect to the Arduino IoT Cloud MQTT broker, our boards don’t use a standard credentials authentication (username/password pair). We rather opted for implementing a higher-level authentication, known as client certificate authentication.
How does the Arduino provisioning work?
The whole process is possible thanks to an API, which exposes an endpoint a client can interact with.
As you can see in the diagram below, first the Client requests to register a new device on Arduino IoT Cloud via the API, to which the server (API) returns a UUID (Universally Unique IDentifier). At this point, the user can upload the sketch Provisioning.ino to the target board.This code is responsible for multiple tasks:
Generating a private key using the ATECCX08A, and store it in a secure slot that can be only read by the secure element;
Generating a CSR (Certificate Signing Request) using the device UUID as Common Name (CN) and the generated private key to sign it;
Storing the certificate signed by Arduino acting as the authority.
After the CSR generation, the user sends it via the API to the server and the server returns a certificate signed by Arduino. This certificate is stored, in a compressed format, in a slot of the secure element (usually in slot 10) and it is used to authenticate the device to the Arduino IoT Cloud.