Edwin Smash

TOTP (time-based One-Time-Passwords) as super neat and widely supported. I will not go into the background or theory, but it is possible to use an Arduino and a RTC module as a TOTP token for your email provider.

DISCLAIMER: STORING YOUR KEY ON AN ARDUINO IS ONLY AS SECURE AS THE PHYSICAL ACCESS TO THE ARDUINO.

The Arduino TOTP library is pretty simple but there are a couple pitfalls:

Your RTC module needs to be set to UTC and fairly close to real time.

If you used the method that I previously posted, you will need to set the timezone on your workstation to UTC. You might also need to set an offset because this method sets the RTC behind your computer because there is a gap between when your computer complies it and when it’s pushed to the RTC.

You could also just add or subtract the appropriate amount of seconds to bring your local time zone to UTC.

You also need to know what format your seed phrase is in.

The string of characters you get from your provider is likely in “Base32”. This Arduino library needs the hex version of a Unicode string. So, if the Base32 string from your provider is this:

JBSWY3DPEHPK3PXP

You need to convert it to Unicode:

Hello!Þ­¾ï

And then convert it to hex in this format:

0x48,0x65,0x6c,0x6c,0x6f,0x21,0xde,0xad,0xbe,0xef

(Ha get it “DEADBEEF”.)

This is all doable using a tool called CyberChef.

This is the bare minimum code needed to return a valid token:

#include <Wire.h>
#include "RTClib.h"
#include <TOTP.h>

RTC_DS3231 rtc;

//Passcode in Base32: JBSWY3DPEHPK3PXP
uint8_t hmacKey[] = {0x48,0x65,0x6c,0x6c,0x6f,0x21,0xde,0xad,0xbe,0xef};

TOTP totp = TOTP(hmacKey, 10);

//Difference in seconds between actual Unix time and what your RTC is saying
int drift = 6;

void setup() {

  Wire.begin();
  Serial.begin(115200);
  delay(1000); // wait for console opening
}

void loop() {
  
    DateTime now = rtc.now();

    char* token = totp.getCode(now.unixtime()+drift);
    Serial.print("TOKEN: ");
    Serial.println(token);

    delay(1000);
}

To verify you can use this website.

From here you can do cool things like give it a battery and OLED display or destroy it because it’s not safe to keep your key lying around.

Real-Time Clock module running over I2C. You will need to give it a CR2032 battery so it retains the time when the power is removed from the Arduino.

You will need to install the “RTClib” library in the Arduino IDE.

How to Set Time

Before use you need to set the time on the RTC. This script will pull the time from your computer and use it to configure the RTC.

#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

void setup() {
  Wire.begin();
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

void loop() {

}

This has a couple problems: it uses whatever timezone your computer is using, and it creates a delay of however long it took your computer to compile and upload the sketch (in my case about six seconds.)

How to Read Time

#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

void setup() {
  Wire.begin();
  Serial.begin(115200);
}

void loop() {
  
    DateTime now = rtc.now();
    
    Serial.println("Current Date & Time: ");
    Serial.print(now.year(), DEC);
    Serial.print('-');
    Serial.print(now.month(), DEC);
    Serial.print('-');
    Serial.print(now.day(), DEC);
    Serial.print(" ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
    Serial.print("Unix Time: ");
    Serial.println(now.unixtime());
    Serial.println();
    delay(1000);
}

Chip which will reach current in a circuit and report it to Arduino via I2C.

The default I2C address is 0x40. This can be changed by shorting a couple pads, so you could use up to four devices if you wanted.

Install the Adafruit INA219 library.

#include <Wire.h>
#include <Adafruit_INA219.h>

#define ina219_addr 0x40;
 
Adafruit_INA219 ina219(ina219_addr);
 
void setup(void) 
{
  ina219.begin();  // Initialize first board (default address 0x40)
}

void loop(void) 
{
  float shuntvoltage = 0;
  float busvoltage = 0;
  float current_mA = 0;
  float loadvoltage = 0;
  float power_mW = 0;

  shuntvoltage = ina219.getShuntVoltage_mV();
  busvoltage = ina219.getBusVoltage_V();
  current_mA = ina219.getCurrent_mA();
  power_mW = ina219.getPower_mW();
  loadvoltage = busvoltage + (shuntvoltage / 1000);
  
  Serial.print("Bus Voltage: "); Serial.print(busvoltage); Serial.println(" V");
  Serial.print("Shunt Vo: "); Serial.print(shuntvoltage); Serial.println(" mV");
  Serial.print("Load Volt: "); Serial.print(loadvoltage); Serial.println(" V");
  Serial.print("Current: "); Serial.print(current_mA); Serial.println(" mA");
  Serial.print("Power: "); Serial.print(power_mW); Serial.println(" mW");
  Serial.println("");

  delay(2000);
}

From Adafruit’s documentation:

float getBusVoltage_V(void);  
Reads the voltage between GND and V-.  This is the total voltage seen by the circuit under test.  (Supply voltage – shunt voltage).  

The return value is in Volts.

float getShuntVoltage_mV(void);  
Reads the voltage between V- and V+.  This is the measured voltage drop across the shunt resistor.  

The return value is in Milivolts.

float getCurrent_mA(void);
Reads the current, derived via Ohms Law from the measured shunt voltage.

The return value is in Milliamps.

The ones I got were 126×64 displays powered by SSD1306 chips. They run over I2C so they are pretty easy to wire up:

You do have to make sure you have the right I2C address in your code. For some reason mine were labeled as using “0x78” but were actually “0x3C”. (Thanks, anonymous Amazon reviewer!)

As far as code, it’s pretty easy to use the Adafruit SSD1306 and Adafruit GFX libraries. But for my purposes it was too resource intensive so I found an ASCII only library.

// Demo of ASCII only OLED library
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"

//Configure Screen
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire oled;

void setup() {
    Wire.begin();
    oled.begin(&Adafruit128x64, I2C_ADDRESS);
    oled.setFont(System5x7);
    oled.clear();    
}

void loop() {
      oled.setCursor(0, 0);
      oled.print("TEXT GOES HERE");
      delay(1000);      
}

To move text to different parts of the screen use “oled.setCursor(column,row);” My displays have 8 rows (0-7) with the default text size. Each character is approximately 5 pixels wide.

If you want to make the text bigger you can use “oled.set2X();” before your “oled.print” statement.

UPDATE:

If you want to use a 128×32 display use the following portions of code:

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels

oled.begin(&Adafruit128x32, I2C_ADDRESS);