From b7ed9adb6c41089da75d258d7148fa87d2f76d20 Mon Sep 17 00:00:00 2001 From: Wesley Ellis Date: Mon, 22 Nov 2021 21:20:57 -0500 Subject: [PATCH 1/9] Add initial TOTP watch face impl Vendor code from https://github.com/Netthaw/TOTP-MCU to do the heavy lifting of computing SHA-1 and HMAC and the rest of TOTP Also implement a date_time to unix timestamp method --- movement/lib/TOTP-MCU | 1 + movement/make/Makefile | 4 + movement/movement_config.h | 1 + .../watch_faces/complications/totp_face.c | 137 ++++++++++++++++++ .../watch_faces/complications/totp_face.h | 19 +++ 5 files changed, 162 insertions(+) create mode 160000 movement/lib/TOTP-MCU create mode 100644 movement/watch_faces/complications/totp_face.c create mode 100644 movement/watch_faces/complications/totp_face.h diff --git a/movement/lib/TOTP-MCU b/movement/lib/TOTP-MCU new file mode 160000 index 00000000..646474a8 --- /dev/null +++ b/movement/lib/TOTP-MCU @@ -0,0 +1 @@ +Subproject commit 646474a8757e1fca490792e81082b2ad89b966a3 diff --git a/movement/make/Makefile b/movement/make/Makefile index b595d2dd..4c895322 100755 --- a/movement/make/Makefile +++ b/movement/make/Makefile @@ -16,6 +16,7 @@ INCLUDES += \ -I../watch_faces/complications/ \ -I../watch_faces/thermistor/ \ -I../watch_faces/demos/ \ + -I../lib/TOTP-MCU/ \ # If you add any other source files you wish to compile, add them after ../app.c # Note that you will need to add a backslash at the end of any line you wish to continue, i.e. @@ -24,6 +25,8 @@ INCLUDES += \ # ../drivers/lis2dh.c \ # ../watch_faces/fitness/step_count_face.c SRCS += \ + ../lib/TOTP-MCU/sha1.c \ + ../lib/TOTP-MCU/TOTP.c \ ../movement.c \ ../watch_faces/clock/simple_clock_face.c \ ../watch_faces/settings/preferences_face.c \ @@ -37,6 +40,7 @@ SRCS += \ ../watch_faces/complications/beats_face.c \ ../watch_faces/complications/day_one_face.c \ ../watch_faces/complications/stopwatch_face.c \ + ../watch_faces/complications/totp_face.c \ # Leave this line at the bottom of the file; it has all the targets for making your project. include $(TOP)/rules.mk diff --git a/movement/movement_config.h b/movement/movement_config.h index fa5ddf18..8802883d 100644 --- a/movement/movement_config.h +++ b/movement/movement_config.h @@ -12,6 +12,7 @@ #include "day_one_face.h" #include "voltage_face.h" #include "stopwatch_face.h" +#include "totp_face.h" const watch_face_t watch_faces[] = { simple_clock_face, diff --git a/movement/watch_faces/complications/totp_face.c b/movement/watch_faces/complications/totp_face.c new file mode 100644 index 00000000..2e8b5f66 --- /dev/null +++ b/movement/watch_faces/complications/totp_face.c @@ -0,0 +1,137 @@ +/** + * + * TODO: + * - this ONLY works if watch is set to UTC, probably worth including a TZ offset setting since it can be used by beats as well + * - show how long code is valid for in upper right corner of LCD + * - optimize code so that we don't calculating a new unix timestamp every second AND a new TOTP code + * - Support for multiple codes + */ +#include +#include +#include "totp_face.h" +#include "watch.h" +#include "TOTP.h" + +// test key: JBSWY3DPEHPK3PXP +// Use https://cryptii.com/pipes/base32-to-hex to convert base32 to hex +// Use https://totp.danhersam.com/ to generate test codes for verification +uint8_t hmacKey[] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0xde, 0xad, 0xbe, 0xef}; // Secret key + +void totp_face_setup(movement_settings_t *settings, void ** context_ptr) { + (void) settings; + (void) context_ptr; + TOTP(hmacKey, sizeof(hmacKey), 30); +} + +void totp_face_activate(movement_settings_t *settings, void *context) { + (void) settings; + (void) context; +} + +/** + * @brief Get unix timestamp from component parts + * + * @param year + * @param month + * @param day + * @param hour + * @param minute + * @param second + * @return uint32_t + * + * Based on code by Josh Haberman for upb + * from https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html + * + * Essentially we need to calculate how many days have occured since year 0 + * including leap years! The following code does some clever calculations + * of the number of february's then offsets based on how many leap years + * there have been + * + * Once we have the number of days in the year, it's easy enough to add how + * many days have happened in the current year, then convert that to seconds + */ +uint32_t current_unix_time(uint32_t year, uint32_t month, uint32_t day, + uint32_t hour, uint32_t minute, uint32_t second) { + uint16_t DAYS_SO_FAR[] = { + 0, // Jan + 31, // Feb + 59, // March + 90, // April + 120, // May + 151, // June + 181, // July + 212, // August + 243, // September + 273, // October + 304, // November + 334 // December + }; + + + uint32_t year_adj = year + 4800; + uint32_t febs = year_adj - (month <= 2 ? 1 : 0); /* Februaries since base. */ + uint32_t leap_days = 1 + (febs / 4) - (febs / 100) + (febs / 400); + uint32_t days = 365 * year_adj + leap_days + DAYS_SO_FAR[month - 1] + day - 1; + days -= 2472692; /* Adjust to Unix epoch. */ + + uint32_t timestamp = days * 86400; + timestamp += hour * 3600; + timestamp += minute * 60; + timestamp += second; + + return timestamp; +} + +uint32_t current_unix_time_from_rtc() { + watch_date_time date_time = watch_rtc_get_date_time(); + return current_unix_time( + date_time.unit.year + 2020, // year is stored starting in 2020 + date_time.unit.month, + date_time.unit.day, + date_time.unit.hour, + date_time.unit.minute, + date_time.unit.second + ); +} + +bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void *context) { + (void) settings; + (void) context; + + char buf[14]; + watch_date_time date_time = watch_rtc_get_date_time(); + + uint32_t ts; + uint32_t code; + switch (event.event_type) { + case EVENT_ACTIVATE: + case EVENT_TICK: + ts = current_unix_time_from_rtc(); + code = getCodeFromTimestamp(ts); + sprintf(buf, "2f %lu", code); + + watch_display_string(buf, 0); + break; + case EVENT_MODE_BUTTON_UP: + movement_move_to_next_face(); + break; + case EVENT_LIGHT_BUTTON_DOWN: + movement_illuminate_led(); + break; + case EVENT_TIMEOUT: + // go home + break; + case EVENT_ALARM_BUTTON_DOWN: + case EVENT_ALARM_BUTTON_UP: + case EVENT_ALARM_LONG_PRESS: + default: + break; + } + + return true; +} + +void totp_face_resign(movement_settings_t *settings, void *context) { + (void) settings; + (void) context; +} \ No newline at end of file diff --git a/movement/watch_faces/complications/totp_face.h b/movement/watch_faces/complications/totp_face.h new file mode 100644 index 00000000..1fecb82a --- /dev/null +++ b/movement/watch_faces/complications/totp_face.h @@ -0,0 +1,19 @@ +#ifndef TOTP_FACE_H_ +#define TOTP_FACE_H_ + +#include "movement.h" + +void totp_face_setup(movement_settings_t *settings, void ** context_ptr); +void totp_face_activate(movement_settings_t *settings, void *context); +bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void *context); +void totp_face_resign(movement_settings_t *settings, void *context); + +static const watch_face_t totp_face = { + totp_face_setup, + totp_face_activate, + totp_face_loop, + totp_face_resign, + NULL +}; + +#endif // TOTP_FACE_H_ \ No newline at end of file From ad558da328e0094a69410618b0e915083604d436 Mon Sep 17 00:00:00 2001 From: joeycastillo Date: Tue, 23 Nov 2021 15:54:12 -0500 Subject: [PATCH 2/9] add stubs for UNIX timestamp conversion --- watch-library/watch/watch_utility.h | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/watch-library/watch/watch_utility.h b/watch-library/watch/watch_utility.h index aada783f..a6035dc3 100644 --- a/watch-library/watch/watch_utility.h +++ b/watch-library/watch/watch_utility.h @@ -38,6 +38,27 @@ */ const char * watch_utility_get_weekday(watch_date_time date_time); +/** @brief Returns the UNIX time (seconds since 1970) for a given date/time in UTC. + * @param date_time The watch_date_time that you wish to convert. + * @param year The year of the date you wish to convert. + * @param month The month of the date you wish to convert. + * @param day The day of the date you wish to convert. + * @param hour The hour of the date you wish to convert. + * @param minute The minute of the date you wish to convert. + * @param second The second of the date you wish to convert. + * @return A UNIX timestamp for the given date/time and UTC offset. + * @note Implemented by Wesley Ellis (tahnok) and based on BSD-licensed code by Josh Haberman: + * https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html + */ +uint32_t watch_utility_convert_to_unix_time(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint32_t utc_offset); + +/** @brief Returns the UNIX time (seconds since 1970) for a given watch_date_time struct. + * @param date_time The watch_date_time that you wish to convert. + * @param utc_offset The number of seconds that date_time is offset from UTC, or 0 if the time is UTC. + * @return A UNIX timestamp for the given watch_date_time and UTC offset. + */ +uint32_t watch_utility_date_time_to_unix_time(watch_date_time date_time, uint32_t utc_offset); + /** @brief Returns a temperature in degrees Celsius for a given thermistor voltage divider circuit. * @param value The raw analog reading from the thermistor pin (0-65535) * @param highside True if the thermistor is connected to VCC and the series resistor is connected From f9e3dc865dc8d31bebe8158bbcd3fa2a47dc95a0 Mon Sep 17 00:00:00 2001 From: joeycastillo Date: Tue, 23 Nov 2021 15:57:18 -0500 Subject: [PATCH 3/9] add stubs for UNIX timestamp conversion --- watch-library/watch/watch_utility.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/watch-library/watch/watch_utility.c b/watch-library/watch/watch_utility.c index bfa3073a..0e95d4dc 100644 --- a/watch-library/watch/watch_utility.c +++ b/watch-library/watch/watch_utility.c @@ -35,6 +35,15 @@ const char * watch_utility_get_weekday(watch_date_time date_time) { return weekdays[(date_time.unit.day + 13 * (date_time.unit.month + 1) / 5 + date_time.unit.year + date_time.unit.year / 4 + 525) % 7]; } +uint32_t watch_utility_convert_to_unix_time(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint32_t utc_offset) { + // TODO + return 0; +} + +uint32_t watch_utility_date_time_to_unix_time(watch_date_time date_time, uint32_t utc_offset) { + return watch_utility_convert_to_unix_time(date_time.unit.year + WATCH_RTC_REFERENCE_YEAR, date_time.unit.month, date_time.unit.day, date_time.unit.hour, date_time.unit.minute, date_time.unit.second, utc_offset); +} + float watch_utility_thermistor_temperature(uint16_t value, bool highside, float b_coefficient, float nominal_temperature, float nominal_resistance, float series_resistance) { float reading = (float)value; From 653dd862b8bb6f40a55295e6fc9325b052d30b3d Mon Sep 17 00:00:00 2001 From: Wesley Ellis Date: Tue, 23 Nov 2021 21:32:25 -0500 Subject: [PATCH 4/9] Fill out watch_utility_convert_to_unix_time --- watch-library/watch/watch_utility.c | 30 +++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/watch-library/watch/watch_utility.c b/watch-library/watch/watch_utility.c index 0e95d4dc..df808404 100644 --- a/watch-library/watch/watch_utility.c +++ b/watch-library/watch/watch_utility.c @@ -36,8 +36,34 @@ const char * watch_utility_get_weekday(watch_date_time date_time) { } uint32_t watch_utility_convert_to_unix_time(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint32_t utc_offset) { - // TODO - return 0; + uint16_t DAYS_SO_FAR[] = { + 0, // Jan + 31, // Feb + 59, // March + 90, // April + 120, // May + 151, // June + 181, // July + 212, // August + 243, // September + 273, // October + 304, // November + 334 // December + }; + + + uint32_t year_adj = year + 4800; + uint32_t febs = year_adj - (month <= 2 ? 1 : 0); /* Februaries since base. */ + uint32_t leap_days = 1 + (febs / 4) - (febs / 100) + (febs / 400); + uint32_t days = 365 * year_adj + leap_days + DAYS_SO_FAR[month - 1] + day - 1; + days -= 2472692; /* Adjust to Unix epoch. */ + + uint32_t timestamp = days * 86400; + timestamp += (hour + utc_offset) * 3600; + timestamp += minute * 60; + timestamp += second; + + return timestamp; } uint32_t watch_utility_date_time_to_unix_time(watch_date_time date_time, uint32_t utc_offset) { From 121e6fd165a03f9249100e73bdf658e545e10d25 Mon Sep 17 00:00:00 2001 From: Wesley Ellis Date: Tue, 23 Nov 2021 21:32:43 -0500 Subject: [PATCH 5/9] optimize totp face and add countdown --- .../watch_faces/complications/totp_face.c | 110 +++++------------- .../watch_faces/complications/totp_face.h | 9 +- 2 files changed, 35 insertions(+), 84 deletions(-) diff --git a/movement/watch_faces/complications/totp_face.c b/movement/watch_faces/complications/totp_face.c index 2e8b5f66..017a774b 100644 --- a/movement/watch_faces/complications/totp_face.c +++ b/movement/watch_faces/complications/totp_face.c @@ -1,114 +1,58 @@ /** - * * TODO: - * - this ONLY works if watch is set to UTC, probably worth including a TZ offset setting since it can be used by beats as well - * - show how long code is valid for in upper right corner of LCD - * - optimize code so that we don't calculating a new unix timestamp every second AND a new TOTP code + * - Add support for UTC offset in settings? * - Support for multiple codes */ #include #include #include "totp_face.h" #include "watch.h" +#include "watch_utility.h" #include "TOTP.h" // test key: JBSWY3DPEHPK3PXP // Use https://cryptii.com/pipes/base32-to-hex to convert base32 to hex // Use https://totp.danhersam.com/ to generate test codes for verification -uint8_t hmacKey[] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0xde, 0xad, 0xbe, 0xef}; // Secret key +static uint8_t hmacKey[] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0xde, 0xad, 0xbe, 0xef}; // Secret key + + +static const uint8_t UTC_OFFSET = 5; // set to your current UTC offset +static const uint32_t TIMESTEP = 30; void totp_face_setup(movement_settings_t *settings, void ** context_ptr) { (void) settings; - (void) context_ptr; - TOTP(hmacKey, sizeof(hmacKey), 30); + if (*context_ptr == NULL) *context_ptr = malloc(sizeof(totp_state_t)); + TOTP(hmacKey, sizeof(hmacKey), TIMESTEP); } void totp_face_activate(movement_settings_t *settings, void *context) { (void) settings; - (void) context; -} - -/** - * @brief Get unix timestamp from component parts - * - * @param year - * @param month - * @param day - * @param hour - * @param minute - * @param second - * @return uint32_t - * - * Based on code by Josh Haberman for upb - * from https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html - * - * Essentially we need to calculate how many days have occured since year 0 - * including leap years! The following code does some clever calculations - * of the number of february's then offsets based on how many leap years - * there have been - * - * Once we have the number of days in the year, it's easy enough to add how - * many days have happened in the current year, then convert that to seconds - */ -uint32_t current_unix_time(uint32_t year, uint32_t month, uint32_t day, - uint32_t hour, uint32_t minute, uint32_t second) { - uint16_t DAYS_SO_FAR[] = { - 0, // Jan - 31, // Feb - 59, // March - 90, // April - 120, // May - 151, // June - 181, // July - 212, // August - 243, // September - 273, // October - 304, // November - 334 // December - }; - - - uint32_t year_adj = year + 4800; - uint32_t febs = year_adj - (month <= 2 ? 1 : 0); /* Februaries since base. */ - uint32_t leap_days = 1 + (febs / 4) - (febs / 100) + (febs / 400); - uint32_t days = 365 * year_adj + leap_days + DAYS_SO_FAR[month - 1] + day - 1; - days -= 2472692; /* Adjust to Unix epoch. */ - - uint32_t timestamp = days * 86400; - timestamp += hour * 3600; - timestamp += minute * 60; - timestamp += second; - - return timestamp; -} - -uint32_t current_unix_time_from_rtc() { - watch_date_time date_time = watch_rtc_get_date_time(); - return current_unix_time( - date_time.unit.year + 2020, // year is stored starting in 2020 - date_time.unit.month, - date_time.unit.day, - date_time.unit.hour, - date_time.unit.minute, - date_time.unit.second - ); + memset(context, 0, sizeof(totp_state_t)); + totp_state_t *totp_state = (totp_state_t *)context; + totp_state->timestamp = watch_utility_date_time_to_unix_time(watch_rtc_get_date_time(), UTC_OFFSET); + totp_state->current_code = getCodeFromTimestamp(totp_state->timestamp); } bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void *context) { (void) settings; - (void) context; + totp_state_t *totp_state = (totp_state_t *)context; char buf[14]; - watch_date_time date_time = watch_rtc_get_date_time(); + uint8_t valid_for; + div_t result; - uint32_t ts; - uint32_t code; switch (event.event_type) { - case EVENT_ACTIVATE: case EVENT_TICK: - ts = current_unix_time_from_rtc(); - code = getCodeFromTimestamp(ts); - sprintf(buf, "2f %lu", code); + totp_state->timestamp++; + // fall through + case EVENT_ACTIVATE: + result = div(totp_state->timestamp, TIMESTEP); + if (result.quot != totp_state->steps) { + totp_state->current_code = getCodeFromTimestamp(totp_state->timestamp); + totp_state->steps = result.quot; + } + valid_for = TIMESTEP - result.rem; + sprintf(buf, "2f%2d%lu", valid_for, totp_state->current_code); watch_display_string(buf, 0); break; @@ -134,4 +78,4 @@ bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void void totp_face_resign(movement_settings_t *settings, void *context) { (void) settings; (void) context; -} \ No newline at end of file +} diff --git a/movement/watch_faces/complications/totp_face.h b/movement/watch_faces/complications/totp_face.h index 1fecb82a..0527627a 100644 --- a/movement/watch_faces/complications/totp_face.h +++ b/movement/watch_faces/complications/totp_face.h @@ -3,6 +3,13 @@ #include "movement.h" +typedef struct { + uint32_t timestamp; + uint8_t steps; + uint32_t current_code; + +} totp_state_t; + void totp_face_setup(movement_settings_t *settings, void ** context_ptr); void totp_face_activate(movement_settings_t *settings, void *context); bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void *context); @@ -16,4 +23,4 @@ static const watch_face_t totp_face = { NULL }; -#endif // TOTP_FACE_H_ \ No newline at end of file +#endif // TOTP_FACE_H_ From 4a0ff5577363a1bd315693b41f448e3774de9e34 Mon Sep 17 00:00:00 2001 From: Wesley Ellis Date: Tue, 23 Nov 2021 21:37:54 -0500 Subject: [PATCH 6/9] Properly vendor TOTP-MCU temporarily --- movement/lib/TOTP-MCU | 1 - movement/lib/TOTP-MCU/LICENSE | 21 +++++ movement/lib/TOTP-MCU/README.md | 57 ++++++++++++ movement/lib/TOTP-MCU/TOTP.c | 69 ++++++++++++++ movement/lib/TOTP-MCU/TOTP.h | 8 ++ movement/lib/TOTP-MCU/blink.c | 39 ++++++++ movement/lib/TOTP-MCU/sha1.c | 155 ++++++++++++++++++++++++++++++++ movement/lib/TOTP-MCU/sha1.h | 25 ++++++ 8 files changed, 374 insertions(+), 1 deletion(-) delete mode 160000 movement/lib/TOTP-MCU create mode 100644 movement/lib/TOTP-MCU/LICENSE create mode 100644 movement/lib/TOTP-MCU/README.md create mode 100644 movement/lib/TOTP-MCU/TOTP.c create mode 100644 movement/lib/TOTP-MCU/TOTP.h create mode 100644 movement/lib/TOTP-MCU/blink.c create mode 100644 movement/lib/TOTP-MCU/sha1.c create mode 100644 movement/lib/TOTP-MCU/sha1.h diff --git a/movement/lib/TOTP-MCU b/movement/lib/TOTP-MCU deleted file mode 160000 index 646474a8..00000000 --- a/movement/lib/TOTP-MCU +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 646474a8757e1fca490792e81082b2ad89b966a3 diff --git a/movement/lib/TOTP-MCU/LICENSE b/movement/lib/TOTP-MCU/LICENSE new file mode 100644 index 00000000..6de4c0f0 --- /dev/null +++ b/movement/lib/TOTP-MCU/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. diff --git a/movement/lib/TOTP-MCU/README.md b/movement/lib/TOTP-MCU/README.md new file mode 100644 index 00000000..df5ab96e --- /dev/null +++ b/movement/lib/TOTP-MCU/README.md @@ -0,0 +1,57 @@ +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 +``` +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 diff --git a/movement/lib/TOTP-MCU/TOTP.c b/movement/lib/TOTP-MCU/TOTP.c new file mode 100644 index 00000000..d977d06e --- /dev/null +++ b/movement/lib/TOTP-MCU/TOTP.c @@ -0,0 +1,69 @@ +#include "TOTP.h" +#include "sha1.h" + +uint8_t* _hmacKey; +uint8_t _keyLength; +uint8_t _timeZoneOffset; +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; +} diff --git a/movement/lib/TOTP-MCU/TOTP.h b/movement/lib/TOTP-MCU/TOTP.h new file mode 100644 index 00000000..13715f4d --- /dev/null +++ b/movement/lib/TOTP-MCU/TOTP.h @@ -0,0 +1,8 @@ +#include +#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); diff --git a/movement/lib/TOTP-MCU/blink.c b/movement/lib/TOTP-MCU/blink.c new file mode 100644 index 00000000..9ec14ec6 --- /dev/null +++ b/movement/lib/TOTP-MCU/blink.c @@ -0,0 +1,39 @@ +#include +#include +#include + +/** + * blink.c + */ +void main(void) +{ + WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer + P1DIR |= 0x01; // configure P1.0 as output + + uint8_t hmacKey[] = {0x4d, 0x79, 0x4c, 0x65, 0x67, 0x6f, 0x44, 0x6f, 0x6f, 0x72}; // Secret key + TOTP(hmacKey, 10, 7200); // Secret key, Key length, Timestep (7200s - 2hours) + + setTimezone(9); // Set timezone + uint32_t newCode = getCodeFromTimestamp(1557414000); // Timestamp Now + + ///////////////// For struct tm ////////////////// + // 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); + /////////////////////////////////////////////////// + + volatile unsigned int i; // volatile to prevent optimization + + while(1) + { + if (newCode == 0){ // 0 = INPUT HERE + P1OUT ^= 0x01; // toggle P1.0 + } + for(i=10000; i>0; i--); // delay + } +} diff --git a/movement/lib/TOTP-MCU/sha1.c b/movement/lib/TOTP-MCU/sha1.c new file mode 100644 index 00000000..07ad697b --- /dev/null +++ b/movement/lib/TOTP-MCU/sha1.c @@ -0,0 +1,155 @@ +#include +#include "sha1.h" + +#define SHA1_K0 0x5a827999 +#define SHA1_K20 0x6ed9eba1 +#define SHA1_K40 0x8f1bbcdc +#define SHA1_K60 0xca62c1d6 + +uint8_t sha1InitState[] = { + 0x01,0x23,0x45,0x67, // H0 + 0x89,0xab,0xcd,0xef, // H1 + 0xfe,0xdc,0xba,0x98, // H2 + 0x76,0x54,0x32,0x10, // H3 + 0xf0,0xe1,0xd2,0xc3 // H4 +}; + +void init(void) { + memcpy(state.b,sha1InitState,HASH_LENGTH); + byteCount = 0; + bufferOffset = 0; +} + +uint32_t rol32(uint32_t number, uint8_t bits) { + return ((number << bits) | (uint32_t)(number >> (32-bits))); +} + +void hashBlock() { + uint8_t i; + uint32_t a,b,c,d,e,t; + + a=state.w[0]; + b=state.w[1]; + c=state.w[2]; + d=state.w[3]; + e=state.w[4]; + for (i=0; i<80; i++) { + if (i>=16) { + t = buffer.w[(i+13)&15] ^ buffer.w[(i+8)&15] ^ buffer.w[(i+2)&15] ^ buffer.w[i&15]; + buffer.w[i&15] = rol32(t,1); + } + if (i<20) { + t = (d ^ (b & (c ^ d))) + SHA1_K0; + } else if (i<40) { + t = (b ^ c ^ d) + SHA1_K20; + } else if (i<60) { + t = ((b & c) | (d & (b | c))) + SHA1_K40; + } else { + t = (b ^ c ^ d) + SHA1_K60; + } + t+=rol32(a,5) + e + buffer.w[i&15]; + e=d; + d=c; + c=rol32(b,30); + b=a; + a=t; + } + state.w[0] += a; + state.w[1] += b; + state.w[2] += c; + state.w[3] += d; + state.w[4] += e; +} + +void addUncounted(uint8_t data) { + buffer.b[bufferOffset ^ 3] = data; + bufferOffset++; + if (bufferOffset == BLOCK_LENGTH) { + hashBlock(); + bufferOffset = 0; + } +} + +void write(uint8_t data) { + ++byteCount; + addUncounted(data); + + return; +} + +void writeArray(uint8_t *buffer, uint8_t size){ + while (size--) { + write(*buffer++); + } +} + +void pad() { + // Implement SHA-1 padding (fips180-2 5.1.1) + + // Pad with 0x80 followed by 0x00 until the end of the block + addUncounted(0x80); + while (bufferOffset != 56) addUncounted(0x00); + + // Append length in the last 8 bytes + addUncounted(0); // We're only using 32 bit lengths + addUncounted(0); // But SHA-1 supports 64 bit lengths + addUncounted(0); // So zero pad the top bits + addUncounted(byteCount >> 29); // Shifting to multiply by 8 + addUncounted(byteCount >> 21); // as SHA-1 supports bitstreams as well as + addUncounted(byteCount >> 13); // byte. + addUncounted(byteCount >> 5); + addUncounted(byteCount << 3); +} + +uint8_t* result(void) { + // Pad to complete the last block + pad(); + + // Swap byte order back + uint8_t i; + for (i=0; i<5; i++) { + uint32_t a,b; + a=state.w[i]; + b=a<<24; + b|=(a<<8) & 0x00ff0000; + b|=(a>>8) & 0x0000ff00; + b|=a>>24; + state.w[i]=b; + } + + // Return pointer to hash (20 characters) + return state.b; +} + +#define HMAC_IPAD 0x36 +#define HMAC_OPAD 0x5c + +void initHmac(const uint8_t* key, uint8_t keyLength) { + uint8_t i; + memset(keyBuffer,0,BLOCK_LENGTH); + if (keyLength > BLOCK_LENGTH) { + // Hash long keys + init(); + for (;keyLength--;) write(*key++); + memcpy(keyBuffer,result(),HASH_LENGTH); + } else { + // Block length keys are used as is + memcpy(keyBuffer,key,keyLength); + } + // Start inner hash + init(); + for (i=0; i + +#define HASH_LENGTH 20 +#define BLOCK_LENGTH 64 + +union _buffer { + uint8_t b[BLOCK_LENGTH]; + uint32_t w[BLOCK_LENGTH/4]; +} buffer; +union _state { + uint8_t b[HASH_LENGTH]; + uint32_t w[HASH_LENGTH/4]; +} state; + +uint8_t bufferOffset; +uint32_t byteCount; +uint8_t keyBuffer[BLOCK_LENGTH]; +uint8_t innerHash[HASH_LENGTH]; + +void init(void); +void initHmac(const uint8_t* secret, uint8_t secretLength); +uint8_t* result(void); +uint8_t* resultHmac(void); +void write(uint8_t); +void writeArray(uint8_t *buffer, uint8_t size); From 3a420d5c6cfded6a04f4c78aa98c5d4ae7de8ca1 Mon Sep 17 00:00:00 2001 From: Joey Castillo Date: Wed, 24 Nov 2021 12:14:17 -0500 Subject: [PATCH 7/9] add header guards, move declarations to source file --- movement/lib/TOTP-MCU/TOTP.h | 5 +++++ movement/lib/TOTP-MCU/sha1.c | 16 +++++++++++++++- movement/lib/TOTP-MCU/sha1.h | 19 +++++-------------- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/movement/lib/TOTP-MCU/TOTP.h b/movement/lib/TOTP-MCU/TOTP.h index 13715f4d..cfef38b1 100644 --- a/movement/lib/TOTP-MCU/TOTP.h +++ b/movement/lib/TOTP-MCU/TOTP.h @@ -1,3 +1,6 @@ +#ifndef TOTP_H_ +#define TOTP_H_ + #include #include "time.h" @@ -6,3 +9,5 @@ void setTimezone(uint8_t timezone); uint32_t getCodeFromTimestamp(uint32_t timeStamp); uint32_t getCodeFromTimeStruct(struct tm time); uint32_t getCodeFromSteps(uint32_t steps); + +#endif // TOTP_H_ diff --git a/movement/lib/TOTP-MCU/sha1.c b/movement/lib/TOTP-MCU/sha1.c index 07ad697b..8e918e64 100644 --- a/movement/lib/TOTP-MCU/sha1.c +++ b/movement/lib/TOTP-MCU/sha1.c @@ -14,6 +14,20 @@ uint8_t sha1InitState[] = { 0xf0,0xe1,0xd2,0xc3 // H4 }; +union _buffer { + uint8_t b[BLOCK_LENGTH]; + uint32_t w[BLOCK_LENGTH/4]; +} buffer; +union _state { + uint8_t b[HASH_LENGTH]; + uint32_t w[HASH_LENGTH/4]; +} state; + +uint8_t bufferOffset; +uint32_t byteCount; +uint8_t keyBuffer[BLOCK_LENGTH]; +uint8_t innerHash[HASH_LENGTH]; + void init(void) { memcpy(state.b,sha1InitState,HASH_LENGTH); byteCount = 0; @@ -84,7 +98,7 @@ void writeArray(uint8_t *buffer, uint8_t size){ } void pad() { - // Implement SHA-1 padding (fips180-2 5.1.1) + // Implement SHA-1 padding (fips180-2 ��5.1.1) // Pad with 0x80 followed by 0x00 until the end of the block addUncounted(0x80); diff --git a/movement/lib/TOTP-MCU/sha1.h b/movement/lib/TOTP-MCU/sha1.h index 2257e367..2db8fdf8 100644 --- a/movement/lib/TOTP-MCU/sha1.h +++ b/movement/lib/TOTP-MCU/sha1.h @@ -1,25 +1,16 @@ +#ifndef SHA1_H_ +#define SHA1_H_ + #include #define HASH_LENGTH 20 #define BLOCK_LENGTH 64 -union _buffer { - uint8_t b[BLOCK_LENGTH]; - uint32_t w[BLOCK_LENGTH/4]; -} buffer; -union _state { - uint8_t b[HASH_LENGTH]; - uint32_t w[HASH_LENGTH/4]; -} state; - -uint8_t bufferOffset; -uint32_t byteCount; -uint8_t keyBuffer[BLOCK_LENGTH]; -uint8_t innerHash[HASH_LENGTH]; - void init(void); void initHmac(const uint8_t* secret, uint8_t secretLength); uint8_t* result(void); uint8_t* resultHmac(void); void write(uint8_t); void writeArray(uint8_t *buffer, uint8_t size); + +#endif // SHA1_H From 169d4486f9f0f135565558094bbbd2f6495a3318 Mon Sep 17 00:00:00 2001 From: Joey Castillo Date: Wed, 24 Nov 2021 12:18:28 -0500 Subject: [PATCH 8/9] movement: make TOTP face go home on timeout --- movement/watch_faces/complications/totp_face.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/movement/watch_faces/complications/totp_face.c b/movement/watch_faces/complications/totp_face.c index 017a774b..e58fb47d 100644 --- a/movement/watch_faces/complications/totp_face.c +++ b/movement/watch_faces/complications/totp_face.c @@ -63,7 +63,7 @@ bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void movement_illuminate_led(); break; case EVENT_TIMEOUT: - // go home + movement_move_to_face(0); break; case EVENT_ALARM_BUTTON_DOWN: case EVENT_ALARM_BUTTON_UP: From 1a1a862d7941f720df79fb62fa03211cf083e127 Mon Sep 17 00:00:00 2001 From: Joey Castillo Date: Wed, 24 Nov 2021 12:20:32 -0500 Subject: [PATCH 9/9] movement: TOTP face, pad code with leading zeroes --- movement/watch_faces/complications/totp_face.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/movement/watch_faces/complications/totp_face.c b/movement/watch_faces/complications/totp_face.c index e58fb47d..4aa1382a 100644 --- a/movement/watch_faces/complications/totp_face.c +++ b/movement/watch_faces/complications/totp_face.c @@ -52,7 +52,7 @@ bool totp_face_loop(movement_event_t event, movement_settings_t *settings, void totp_state->steps = result.quot; } valid_for = TIMESTEP - result.rem; - sprintf(buf, "2f%2d%lu", valid_for, totp_state->current_code); + sprintf(buf, "2f%2d%06lu", valid_for, totp_state->current_code); watch_display_string(buf, 0); break;