IoT Security with SSL/TLS in MicroPython

I’m on vacation in San Francisco this week with my family and looking out over the bay at Alcatraz Island. For those who aren’t familiar with this island, it housed a maximum high-security prison 1.25 miles off the San Francisco coast for 54 years. While thinking about the high security that Alcatraz offered in the past, it makes me think about the digital security of today.

Alcatraz Island

Specifically, as it relates to the Internet of Things(IoT) and considerations that must be taken with connected devices. If you have been reading my previous IoT related blog posts, you’ll recall that I’ve been using a NodeMCU ESP8266 device with MicroPython for much of my work.

I enjoy my family and want to enjoy my vacation. Therefore I opted to not bring my IoT devices with me. In this post then, I’d like to cover some of the aspects of security that IoT connected devices face. So sit back and put your breadboards away as we take a look at some concepts.

Networking Overview

When we talk about networking we are discussing ways in which devices communicate with each other. The devices can certainly be IoT devices. But it goes beyond the physical device as the how is often as important as the device itself. In today’s world, for example, the popular how is via Ethernet or WiFi and TCP/IP. Let’s have a brief look at some networking models and see how security is implemented in them.

Network Protocol models

At one point I was very involved with networking. In the process of studying for various networking certifications from Cisco and Microsoft, there is a lot of discussion on the Open Systems Interconnection, or OSI, model of networks. There is also a more streamlined TCP/IP model that is popular as well.

OSI Networking Model

These models divide networking into various layers, starting at an Application and working down to the physical cables for a network to function. Conceptually, the OSI Model can be represented like this:

OSI Network Model
OSI Network Model
TCP/IP Networking Model

There are several “layers” there, so to simplify things, let’s take a look at the TCP/IP representation of the network model.

TCP/IP Network Model
TCP/IP Network Model

There are many different ways in which to secure a network. Some are more flexible than others. If you want a very secure network, you don’t connect it to the outside world and build it a hardened physical location with limited access. Secure, yes. Extremely user-friendly, no. Therefore, methods have been developed to provide security at higher layers of the network model which allows for privacy and data integrity between two communicating applications.

TLS/SSL Protocol Model

The software industry has used cryptographic protocols to provide network communication security for a long time. For IoT devices, it is common to utilize TLS When we start talking about network security protocols such as Transport Layer Security (TLS) and its predecessor Secure Sockets Layer (SSL), where do those fit in though to our Networking Models?

TLS Protocol in Network Model
Networking Model with TLS Protocol

We see that there is quite a bit going on there with TLS and that it is occurring at high levels of the network model. This is, typically, great as it allows us, as developers, to have useful access to the protocol. Further, since it is a commonly used protocol, our access to it is, generally speaking, pretty straight forward.


Websites use TLS, and previously SSL, to provide secure communication between browsers and web servers. IoT devices can take advantage of TLS as well. Some of the benefits of using TLS include:

  • private connection is established through symmetric cryptography.
  • Identities can be authenticated using public-key cryptography.
  • Communication integrity via a message authentication code.

TLS builds upon the SSL standards and, as the above image indicates, there are two layers. Within TLS there are two embedded protocols, a handshake protocol, and a record protocol. The handshake is used to establish the format of the exchange of information. The record is what encapsulates the data itself.

This is an oversimplification of the process. There are many steps to the handshake, and a TLS record includes multiple types of information, beyond what is passed from an application itself. Both internal protocols handle, to differing degrees, the cipher security features.

With all of this going on internally in TLS, there are obviously a lot of “moving parts” to this whole thing. I stated that having these security features on a high level in the networking stack can make a developer’s life easier. Fortunately, in a MicroPython based IoT world, it is fairly simple to utilize and implement TLS.


MicroPython includes a standard SSL/TLS module. This provides access to TLS on both the client and server sides of our applications. MicroPython includes the ssl.wrap_socket() function, which wraps a stream in an SSL context. Depending on the particular IoT device and the way the module is implemented, some functionality of wrap_socket() may not be entirely supported.

Wrap up

In this brief discussion, I’ve shown how TLS/SSL security fits into the networking model. I would highly encourage the use of the SSL/TLS module when building your MicroPython projects. In this day and age of cyber attacks, it is important to secure all communications between devices big and small.

Follow me on Twitter @kenwalger to get the latest updates on my postings on MicroPython and IoT and let me know what you are building with MicroPython.