sha3

Author: ethanmckean

decoder/src/cover.c

@@ -1,18 +1,20 @@
-#include "crypto.h"
+#include "cover.h"
+
+#include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdint.h>
-#include <limits.h>
-#include "cover.h"
+
+#include "crypto.h"
 
 #ifndef ASCON_KEY_SIZE
 #define ASCON_KEY_SIZE 16
 #endif
 
 /**
  * @brief Derive the correct child of this key and write it to dest.
- * 
+ *
  * @param current_key a pointer to the key we will derive from
  * @param start start timestamp of current key
  * @param height height of current key in the tree
@@ -22,34 +24,36 @@
  * @param dest_height where we will write the height of the derived key
  * @return int 0 on success, -1 on failure
  */
-int derive_child(uint8_t* current_key, uint64_t start, uint8_t height, uint64_t target_timestamp, uint8_t* dest, uint64_t* dest_start, uint8_t* dest_height){
+int derive_child(uint8_t* current_key, uint64_t start, uint8_t height,
+                 uint64_t target_timestamp, uint8_t* dest, uint64_t* dest_start,
+                 uint8_t* dest_height) {
     // ending timestamp of current key's tree/range
     uint64_t end = start + (1ULL << height) - 1;
     // midpoint of current key's tree/range
-    uint64_t mid = start + (end-start)/2;
+    uint64_t mid = start + (end - start) / 2;
 
-    //Traverse binary tree (one step)
-    if(target_timestamp <= mid){
+    // Traverse binary tree (one step)
+    if (target_timestamp <= mid) {
         end = mid;
     } else {
         start = mid + 1;
     }
 
-    //utilizing the timestamps, and other information derive the key 
-    int ret = wc_HKDF(WC_SHA, current_key, ASCON_KEY_SIZE, NULL, 0, (uint8_t*) &start, sizeof(start),dest, ASCON_KEY_SIZE);
+    // utilizing the timestamps, and other information derive the key
+    int ret = wc_HKDF(WC_SHA3_224, current_key, ASCON_KEY_SIZE, NULL, 0, (uint8_t*)&start,
+                      sizeof(start), dest, ASCON_KEY_SIZE);
 
-    if (ret != 0){
-        //Error deriving key
+    if (ret != 0) {
+        // Error deriving key
         return -1;
     }
 
-    //write the start and the updated height of the derived key
+    // write the start and the updated height of the derived key
     *dest_start = start;
-    *dest_height = height-1;
+    *dest_height = height - 1;
     return 0;
 }
 
-
 /**
  * @brief Get the correct key from the tree. Manage the stack of keys. Derive and Discard
  * keys as appropriate
@@ -58,7 +62,7 @@ int derive_child(uint8_t* current_key, uint64_t start, uint8_t height, uint64_t
  * @param timestamp target timestamp
  * @return address of key, NULL on failure
  */
- uint8_t *tree_get_key(keys_flash_entry_t *stack, uint64_t timestamp) {
+uint8_t* tree_get_key(keys_flash_entry_t* stack, uint64_t timestamp) {
     if (timestamp < stack->start[stack->n_keys - 1]) {
         return NULL;  // the timeframe is before our subscription period
     }
@@ -95,20 +99,22 @@ int derive_child(uint8_t* current_key, uint64_t start, uint8_t height, uint64_t
 }
 
 /** @brief A helper function to determine the correct key for a given start and end tim.
- *  
- *  @details Update_subscription calls this function and compute_h_bnd1(), and takes the minimum
- *  of both to get the accurate height. The height (distance from the start timestamp as a leaf node)
- *  gets the necessary key. Bound 2 ensures the height maximization doesn't overshoot the end timestamp 
- *  by calculating the largest n for 2^n that can be added to start that isn't greater than the end
- *  timestamp. The maximization is: h <= log_2(end + 1 - st), with bit shifting instead of log.
- *  
+ *
+ *  @details Update_subscription calls this function and compute_h_bnd1(), and takes the
+ * minimum of both to get the accurate height. The height (distance from the start
+ * timestamp as a leaf node) gets the necessary key. Bound 2 ensures the height
+ * maximization doesn't overshoot the end timestamp by calculating the largest n for 2^n
+ * that can be added to start that isn't greater than the end timestamp. The maximization
+ * is: h <= log_2(end + 1 - st), with bit shifting instead of log.
+ *
  *  @param uint64_t end: the end timestamp that cannot be exceeded.
  *  @param uint64_t cur: the start timestamp (not global start) that cannot be preceded.
  *  @return uint8_t h: the height of the key which covers the given timestamp range.
  */
-    
- uint8_t compute_h_bnd2(uint64_t end, uint64_t cur) {
-    // The distance between end and start timestamps -- inclusive of start, which is the "+1"
+
+uint8_t compute_h_bnd2(uint64_t end, uint64_t cur) {
+    // The distance between end and start timestamps -- inclusive of start, which is the
+    // "+1"
     uint64_t diff = end - cur + 1;
 
     // For the full range of timestamps (0, 2^64-1), diff = 2^64 and overflows to equal 0.
@@ -135,22 +141,25 @@ int derive_child(uint8_t* current_key, uint64_t start, uint8_t height, uint64_t
 
 /** @brief A helper function to determine the correct key for a given start timestamp.
  * Computes height (distance from leaf node layer) using a trailing zeros method.
- * This height is used to determine the location on the tree of the inputted keys based on the given range.
- * Location meaning - is a key a leaf node or a parent key node (and where is the parent key located).
+ * This height is used to determine the location on the tree of the inputted keys based on
+ * the given range. Location meaning - is a key a leaf node or a parent key node (and
+ * where is the parent key located).
  *
- * @details Update_subscription calls this function and compute_h_bnd2(), and takes the minimum of both to get the accurate height. 
- * Trailing zeros method: Assign each node on the tree a number represented in binary.
- * Imagine the leaf node layer where the first node is the first timestamp of 0 and the last node is the max timestamp 64bit.
- * The trailing zeros of each node represent the height 
- * (how many layers up the tree to go starting at the leaf node layer, specifically the leaf node at the start timestamp (cur)).
+ * @details Update_subscription calls this function and compute_h_bnd2(), and takes the
+ * minimum of both to get the accurate height. Trailing zeros method: Assign each node on
+ * the tree a number represented in binary. Imagine the leaf node layer where the first
+ * node is the first timestamp of 0 and the last node is the max timestamp 64bit. The
+ * trailing zeros of each node represent the height (how many layers up the tree to go
+ * starting at the leaf node layer, specifically the leaf node at the start timestamp
+ * (cur)).
  *
  *  @param uint64_t cur: the start timestamp
  *
  *  @return height (distance from leaf node layer)
  */
- uint8_t compute_h_bnd1(uint64_t cur) {
-    
-    // Case when start timestamp is first possible timestamp, so corresponding parent key is 64 layers from the leaf node
+uint8_t compute_h_bnd1(uint64_t cur) {
+    // Case when start timestamp is first possible timestamp, so corresponding parent key
+    // is 64 layers from the leaf node
     if (cur == 0) {
         return 64;
     }