randomKey.c

Go to the documentation of this file.

// //
// // Created by Erick Grant on 10/26/24.
// //
//
 
#include "randomKey.h"
 
#include <ctype.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <assert.h>
//#include <_stdlib.h> // This may need to be disabled before ARM execution
//#include <_stdlib.h>
//#include <sys/_types/_size_t.h>
 
 
// Base32 Encoding Table as per RFC 3548
//static const char base32_encoding_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
// Function to generate a random string
// https://codereview.stackexchange.com/questions/29198/random-string-generator-in-c
static char *rand_string(char *str, size_t size)
{
    const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 
    // Taking current time as seed
    unsigned int seed = time(0);
    for (int i = 0; i < size ; i++) {
 
 
        int rd_num = rand_r(&seed) % (strlen(charset) - 1); // GPT replacement
   //   printf("%d ", rd_num);
 
        str[i] = charset[rd_num];
   // printf(" %d-%c ", rd_num, str[i]);
    }
 
 
  //  printf("\n%s\n", str);
    return str;
}
int get_base32_value(char letter) {
    // Define the Base32 alphabet according to RFC 4648
    const char base32_alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
    // Create a lookup table where each index maps to the Base32 value.
    int lookup[256] = {0};  // Initialize all values to 0.
 
    // Fill the lookup table with values for each character in the Base32 alphabet
    for (int i = 0; i < 32; i++) {
        lookup[(int)base32_alphabet[i]] = i;
    }
 
    // Return the value from the lookup table for the given letter
    return lookup[(int)letter];
}
 
 
 
void generateStringKey(char* keyString, int length) {
    // https://stackoverflow.com/questions/16348512/getting-the-first-10-characters-of-a-string
    char randomKeyLong[length + 2]; // Protection system, ensuring will always be at least 32 characters, just in case.
    char* ranKeyLPtr = randomKeyLong; // Make a pointer to the randomKeyLong string
 
    rand_string(ranKeyLPtr, length + 2); // generate 34 length key
    strncpy(keyString, randomKeyLong, length); // shorten to 32 characters
    keyString[length] = 0; // null terminate destination
 
    // Output the key, delete these lines in a production environment
  //  printf("Random %d-character string: %s\n", length, keyString); // Output the key
    printf("otpauth://totp/ErickGrant:Milestone?secret=%s\n",keyString); // Output the key as a URL for a totp QR code
 
 
}
 
// Base32 character set
static const char base32_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
// Function to get the Base32 value of a character
int get_base32_value2(char c) {
    const char *ptr = strchr(base32_chars, toupper(c));
    if (ptr) {
        return ptr - base32_chars;
    }
    return -1; // Invalid character
}
 
// Function to decode a Base32 string into a byte array
// Function to decode a Base32 string into a byte array
// Chatgpt cleaned up and added documentation for this. Nov 30, 2024, Query "Can you make this more documented? Use Doxygen too ..." + code
uint8_t* base32_decode2(const char* input, size_t* output_len) {
    size_t input_len = strlen(input);
    size_t buffer_size = (input_len * 5) / 8; // Each Base32 character encodes 5 bits
 
    uint8_t* output = (uint8_t*)malloc(buffer_size);
    if (output == NULL) {
        printf("Memory allocation failed\n");
        return NULL;
    }
 
    int bits = 0, value = 0, index = 0;
    for (size_t i = 0; i < input_len; i++) {
        int digit = get_base32_value2(input[i]);
        if (digit == -1) {
            printf("Invalid Base32 character: %c\n", input[i]);
            free(output);
            return NULL;
        }
 
        value = (value << 5) | digit; // Accumulate 5 bits
        bits += 5;
 
        // Extract a byte when we have at least 8 bits
        if (bits >= 8) {
            bits -= 8;
            output[index++] = (value >> bits) & 0xFF;
        }
    }
 
    *output_len = index; // Set the actual length of the output array
    return output;
}
 
 
// Function to clone a uint8_t array
uint8_t* cloneArray(const uint8_t* original, size_t length) {
    // Allocate memory for the new array
    uint8_t* clone = (uint8_t*)malloc(length * sizeof(uint8_t));
    if (clone == NULL) {
        printf("Memory allocation failed\n");
        return NULL; // Return NULL if memory allocation fails
    }
 
    // Copy the contents from the original array to the new array
    memcpy(clone, original, length * sizeof(uint8_t));
    return clone;
}
 
 
 
 
// ChatGPT Generated, Dec 1, 2024
void test_get_base32_value() {
    // Valid Base32 characters
    assert(get_base32_value('A') == 0);
    assert(get_base32_value('B') == 1);
    assert(get_base32_value('C') == 2);
    assert(get_base32_value('Z') == 25);
    assert(get_base32_value('2') == 26);
    assert(get_base32_value('7') == 31);
 
    // Invalid characters
    assert(get_base32_value('1') == NULL); // Not in Base32 alphabet
    assert(get_base32_value('*') == NULL); // Not in Base32 alphabet
    assert(get_base32_value('a') == NULL); // Lowercase not supported
    assert(get_base32_value(' ') == NULL); // Space is invalid
}
 
int testRandomKey() {
    test_get_base32_value();
//    test_base32_decode();
    return 1;
  }