char -> unsigned char fix

Author: gioblu

src/Cape.h

@@ -27,23 +27,27 @@ class Cape {
   public:
     unsigned char salt; // Salt used for encryption (exchange encrypted)
     /* Instantiate Cape passing a key, its length (max 65535) and salt: */
-    Cape(char *key, uint16_t length, uint8_t s = 0) {
+    Cape(unsigned char *key, uint16_t length, uint8_t s = 0) {
       salt = s;
       _key = key;
       _key_length = length;
       compute_reduced_key(key, length);
     };
 
     /* Compute a 1 byte version of the encryption key */
-    void compute_reduced_key(char *key, uint16_t length) {
+    void compute_reduced_key(unsigned char *key, uint16_t length) {
       _reduced_key = 0;
       // Reduced key computation
       for(uint16_t i = 0; i < length; i++)
         _reduced_key ^= (key[i] << (i % 8));
     };
 
     /* Decrypt data: (max length 65535 characters) */
-    void decrypt(char *source, char *destination, uint16_t length) {
+    void decrypt(
+      unsigned char *source,
+      unsigned char *destination,
+      uint16_t length
+    ) {
       uint16_t index = length - 1;
       // 1 Compute salty reduced key or srk
       unsigned char srk = salt ^ _reduced_key;
@@ -57,8 +61,8 @@ class Cape {
     /* Stream cipher, private key, initialization vector based encryption
        algorithm (max length 65534 characters):  */
     void encrypt(
-      char *source,
-      char *destination,
+      unsigned char *source,
+      unsigned char *destination,
       uint16_t length,
       uint8_t iv
     ) {
@@ -73,7 +77,7 @@ class Cape {
 
     /* Symmetric cipher using private key and salty reduced key:
        (max 65535 characters) */
-    void hash(char *source, char *destination, uint16_t length) {
+    void hash(unsigned char *source, unsigned char *destination, uint16_t length) {
       // 1 Compute salty reduced key or srk
       unsigned char srk = salt ^ _reduced_key;
       // 2 Hash data
@@ -84,14 +88,14 @@ class Cape {
     };
 
     /* Set or Change encryption key (max 65534 characters): */
-    void set_key(char *key, uint16_t length) {
+    void set_key(unsigned char *key, uint16_t length) {
       _key = key;
       _key_length = length;
       compute_reduced_key(key, length);
     };
 
   private:
-    char *   _key;              // Keep private and safe
+    unsigned char *   _key;     // Keep private and safe
     uint16_t _key_length;       // Keep private and safe
     unsigned char _reduced_key; // Keep private and safe
 };

src/Cape_c.h

@@ -26,45 +26,55 @@ not be applied in production. */
 #pragma once
 
 typedef struct {
-  char salt;          // Salt used for encryption
-  char *key;          // Key
+  unsigned char salt;          // Salt used for encryption
+  unsigned char *key;          // Key
   uint16_t length;    // Keep these private and safe
-  char reduced_key;   // Computed reduced key
+  unsigned char reduced_key;   // Computed reduced key
 } cape_t;
 
-void cape_init(cape_t *cape, char *key, uint16_t length, uint8_t salt);
+void cape_init(
+  cape_t *cape,
+  unsigned char *key,
+  uint16_t length,
+  uint8_t salt
+);
 
 void cape_hash(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length
 );
 
 void cape_encrypt(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length,
   uint8_t iv
 );
 
 void cape_decrypt(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length
 );
 
 /* Compute a 1 byte version of the encryption key */
-char cape_compute_reduced_key(char *key, uint16_t length) {
-  char reduced_key = 0;
+char cape_compute_reduced_key(unsigned char *key, uint16_t length) {
+  unsigned char reduced_key = 0;
   for(uint16_t i = 0; i < length; i++) // Reduced key computation
     reduced_key ^= (key[i] << (i % 8));
   return reduced_key;
 };
 
-void cape_init(cape_t *cape, char *key, uint16_t length, uint8_t salt = 0) {
+void cape_init(
+  cape_t *cape,
+  unsigned char *key,
+  uint16_t length,
+  uint8_t salt = 0
+) {
   cape->salt = salt;
   cape->key = key;
   cape->length = length;
@@ -75,8 +85,8 @@ void cape_init(cape_t *cape, char *key, uint16_t length, uint8_t salt = 0) {
    (max 65534 characters) */
 void cape_decrypt(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length
 ) {
   uint16_t index = length - 1;
@@ -95,8 +105,8 @@ void cape_decrypt(
    algorithm (max 65534 characters):  */
 void cape_encrypt(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length,
   uint8_t iv
 ) {
@@ -115,8 +125,8 @@ void cape_encrypt(
    (max 65534 characters) */
 void cape_hash(
   cape_t *cape,
-  char *source,
-  char *destination,
+  unsigned char *source,
+  unsigned char *destination,
   uint16_t length
 ) {
   uint8_t srk = cape->salt ^ cape->reduced_key;