re structure

lib/totp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Weravech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/totp/README.md

@@ -0,0 +1,59 @@
+Sourced from https://github.com/Netthaw/TOTP-MCU
+
+TOTP Pure C Library for ALL MCU
+====================
+
+Library to generate Time-based One-Time Passwords.
+
+Implements the Time-based One-Time Password algorithm specified in [RFC 6238](https://tools.ietf.org/html/rfc6238). 
+Supports different time steps and is compatible with tokens that use the same standard (including software ones, like the Google Authenticator app).
+
+Tested on MCUs: MSP430, RP2040
+
+Installation & usage:
+--------------------
+First include header to your file
+```
+#include <totp.h>
+```
+After included, define key ex. Key is ```MyLegoDoor```
+- Note: The format of hmacKey is array of hexadecimal bytes.
+- Most websites provide the key encoded in base32 - RFC3548/RFC4648, either upper or lower case. You can use [this site](https://cryptii.com/pipes/base32-to-hex) to convert the base32 string to hex (make sure you upcase it first if it's lowercase and remove all whitespaces).
+```
+uint8_t hmacKey[] = {0x4d, 0x79, 0x4c, 0x65, 0x67, 0x6f, 0x44, 0x6f, 0x6f, 0x72};               // Secret key
+```
+Instantiate the TOTP class by providing the secret hmacKey, the length of the hmacKey and the Timestep between codes.
+```
+TOTP(hmacKey, 10, 30);                                     // Secret key, Secret key length, Timestep (30s)
+```
+Use the ```getCodeFromTimestamp()``` function to get a TOTP from a unix epoch timestamp
+```
+uint32_t newCode = getCodeFromTimestamp(1557414000);       // Current timestamp since Unix epoch in seconds
+```
+Or ```getCodeFromTimeStruct()``` if you want to get a TOTP from a tm struct (Time Struct in C), 
+```
+struct tm datetime;
+datetime.tm_hour = 9;
+datetime.tm_min = 0;
+datetime.tm_sec = 0;
+datetime.tm_mday = 13;
+datetime.tm_mon = 5;
+datetime.tm_year = 2019;
+uint32_t newCode = getCodeFromTimeStruct(datetime);
+```
+
+If the provided unix timestamp isn't in UTC±0, use ```setTimezone()``` before ```getCodeFromTimestamp()``` or ```getCodeFromTimeStruct()``` to offset the time.
+
+```
+setTimezone(9);                                            // Set timezone +9 Japan
+```
+
+You can see an example in blink.c
+
+Thanks to:
+----------
+
+* Jose Damico, https://github.com/damico/ARDUINO-OATH-TOKEN
+* Peter Knight, https://github.com/Cathedrow/Cryptosuite
+* Maniacbug, https://github.com/maniacbug/Cryptosuite
+* lucadentella, https://github.com/lucadentella/TOTP-Arduino

lib/totp/totp.cpp

@@ -0,0 +1,76 @@
+#include <sha1.hpp>
+#include "totp.hpp"
+
+uint8_t *_hmacKey;
+uint8_t _keyLength;
+uint8_t _timeZoneOffset = 0;
+uint32_t _timeStep;
+
+// Init the library with the private key, its length and the timeStep duration
+void TOTP(uint8_t *hmacKey, uint8_t keyLength, uint32_t timeStep)
+{
+    _hmacKey = hmacKey;
+    _keyLength = keyLength;
+    _timeStep = timeStep;
+}
+
+void setTimezone(uint8_t timezone)
+{
+    _timeZoneOffset = timezone;
+}
+
+uint32_t TimeStruct2Timestamp(struct tm time)
+{
+    // time.tm_mon -= 1;
+    // time.tm_year -= 1900;
+    return mktime(&(time)) - (_timeZoneOffset * 3600) - 2208988800;
+}
+
+// Generate a code, using the timestamp provided
+uint32_t getCodeFromTimestamp(uint32_t timeStamp)
+{
+    uint32_t steps = timeStamp / _timeStep;
+    return getCodeFromSteps(steps);
+}
+
+// Generate a code, using the timestamp provided
+uint32_t getCodeFromTimeStruct(struct tm time)
+{
+    return getCodeFromTimestamp(TimeStruct2Timestamp(time));
+}
+
+// Generate a code, using the number of steps provided
+uint32_t getCodeFromSteps(uint32_t steps)
+{
+    // STEP 0, map the number of steps in a 8-bytes array (counter value)
+    uint8_t _byteArray[8];
+    _byteArray[0] = 0x00;
+    _byteArray[1] = 0x00;
+    _byteArray[2] = 0x00;
+    _byteArray[3] = 0x00;
+    _byteArray[4] = (uint8_t)((steps >> 24) & 0xFF);
+    _byteArray[5] = (uint8_t)((steps >> 16) & 0xFF);
+    _byteArray[6] = (uint8_t)((steps >> 8) & 0XFF);
+    _byteArray[7] = (uint8_t)((steps & 0XFF));
+
+    // STEP 1, get the HMAC-SHA1 hash from counter and key
+    initHmac(_hmacKey, _keyLength);
+    writeArray(_byteArray, 8);
+    uint8_t *_hash = resultHmac();
+
+    // STEP 2, apply dynamic truncation to obtain a 4-bytes string
+    uint32_t _truncatedHash = 0;
+    uint8_t _offset = _hash[20 - 1] & 0xF;
+    uint8_t j;
+    for (j = 0; j < 4; ++j)
+    {
+        _truncatedHash <<= 8;
+        _truncatedHash |= _hash[_offset + j];
+    }
+
+    // STEP 3, compute the OTP value
+    _truncatedHash &= 0x7FFFFFFF; // Disabled
+    _truncatedHash %= 1000000;
+
+    return _truncatedHash;
+}

lib/totp/totp.hpp

@@ -0,0 +1,13 @@
+#ifndef __TOTP_H__
+#define __TOTP_H__
+
+#include <inttypes.h>
+#include <time.h>
+
+void TOTP(uint8_t *hmacKey, uint8_t keyLength, uint32_t timeStep);
+void setTimezone(uint8_t timezone);
+uint32_t getCodeFromTimestamp(uint32_t timeStamp);
+uint32_t getCodeFromTimeStruct(struct tm time);
+uint32_t getCodeFromSteps(uint32_t steps);
+
+#endif