ruby-libstorj 0.0.0 → 1.0.0

data/ext/libstorj/src/storj.h

@@ -284,6 +284,20 @@ typedef struct {
     void *handle;
 } get_bucket_request_t;
 
+/** @brief A structure for queueing get bucket id request work
+ */
+typedef struct {
+    storj_http_options_t *http_options;
+    storj_encrypt_options_t *encrypt_options;
+    storj_bridge_options_t *options;
+    const char *bucket_name;
+    struct json_object *response;
+    const char *bucket_id;
+    int error_code;
+    int status_code;
+    void *handle;
+} get_bucket_id_request_t;
+
 /** @brief A structure for that describes a bucket entry/file
  */
 typedef struct {
@@ -294,6 +308,7 @@ typedef struct {
     uint64_t size;
     const char *hmac;
     const char *id;
+    const char *bucket_id;
     bool decrypted;
     const char *index;
 } storj_file_meta_t;
@@ -317,6 +332,39 @@ typedef struct {
     void *handle;
 } list_files_request_t;
 
+/** @brief A structure for queueing get file info request work
+ */
+typedef struct {
+    storj_http_options_t *http_options;
+    storj_encrypt_options_t *encrypt_options;
+    storj_bridge_options_t *options;
+    const char *bucket_id;
+    char *method;
+    char *path;
+    bool auth;
+    struct json_object *body;
+    struct json_object *response;
+    storj_file_meta_t *file;
+    int error_code;
+    int status_code;
+    void *handle;
+} get_file_info_request_t;
+
+/** @brief A structure for queueing get file id request work
+ */
+typedef struct {
+    storj_http_options_t *http_options;
+    storj_encrypt_options_t *encrypt_options;
+    storj_bridge_options_t *options;
+    const char *bucket_id;
+    const char *file_name;
+    struct json_object *response;
+    const char *file_id;
+    int error_code;
+    int status_code;
+    void *handle;
+} get_file_id_request_t;
+
 typedef enum {
     BUCKET_PUSH,
     BUCKET_PULL
@@ -356,7 +404,7 @@ typedef void (*storj_finished_download_cb)(int status, FILE *fd, void *handle);
 
 /** @brief A function signature for an upload complete callback
  */
-typedef void (*storj_finished_upload_cb)(int error_status, char *file_id, void *handle);
+typedef void (*storj_finished_upload_cb)(int error_status, storj_file_meta_t *file, void *handle);
 
 /** @brief A structure that represents a pointer to a shard
  *
@@ -484,7 +532,7 @@ typedef struct {
     uint32_t shard_concurrency;
     const char *index;
     const char *file_name;
-    char *file_id;
+    storj_file_meta_t *info;
     const char *encrypted_file_name;
     FILE *original_file;
     uint64_t file_size;
@@ -758,7 +806,7 @@ STORJ_API int storj_bridge_delete_bucket(storj_env_t *env,
  * @brief Get a info of specific bucket.
  *
  * @param[in] env The storj environment struct
- * @param[in] bucket_id The bucket id
+ * @param[in] id The bucket id
  * @param[in] handle A pointer that will be available in the callback
  * @param[in] cb A function called with response when complete
  * @return A non-zero error value on failure and 0 on success.
@@ -775,6 +823,20 @@ STORJ_API int storj_bridge_get_bucket(storj_env_t *env,
  */
 STORJ_API void storj_free_get_bucket_request(get_bucket_request_t *req);
 
+/**
+ * @brief Get the bucket id by name.
+ *
+ * @param[in] env The storj environment struct
+ * @param[in] name The bucket name
+ * @param[in] handle A pointer that will be available in the callback
+ * @param[in] cb A function called with response when complete
+ * @return A non-zero error value on failure and 0 on success.
+ */
+STORJ_API int storj_bridge_get_bucket_id(storj_env_t *env,
+                                         const char *name,
+                                         void *handle,
+                                         uv_after_work_cb cb);
+
 /**
  * @brief Get a list of all files in a bucket.
  *
@@ -901,7 +963,7 @@ STORJ_API int storj_bridge_delete_frame(storj_env_t *env,
  *
  * @param[in] env The storj environment struct
  * @param[in] bucket_id The bucket id
- * @param[in] file_id The bucket id
+ * @param[in] file_id The file id
  * @param[in] handle A pointer that will be available in the callback
  * @param[in] cb A function called with response when complete
  * @return A non-zero error value on failure and 0 on success.
@@ -912,6 +974,29 @@ STORJ_API int storj_bridge_get_file_info(storj_env_t *env,
                                          void *handle,
                                          uv_after_work_cb cb);
 
+/**
+ * @brief Will free all structs for get file info request
+ *
+ * @param[in] req - The work request from storj_bridge_get_file_info callback
+ */
+STORJ_API void storj_free_get_file_info_request(get_file_info_request_t *req);
+
+/**
+ * @brief Get the file id by name.
+ *
+ * @param[in] env The storj environment struct
+ * @param[in] bucket_id The bucket id
+ * @param[in] file_name The file name
+ * @param[in] handle A pointer that will be available in the callback
+ * @param[in] cb A function called with response when complete
+ * @return A non-zero error value on failure and 0 on success.
+ */
+STORJ_API int storj_bridge_get_file_id(storj_env_t *env,
+                                       const char *bucket_id,
+                                       const char *file_name,
+                                       void *handle,
+                                       uv_after_work_cb cb);
+
 /**
  * @brief Get mirror data for a file
  *
@@ -953,6 +1038,13 @@ STORJ_API storj_upload_state_t *storj_bridge_store_file(storj_env_t *env,
                                                         storj_progress_cb progress_cb,
                                                         storj_finished_upload_cb finished_cb);
 
+/**
+ * @brief Will free the file info struct passed to the upload finished callback
+ *
+ * @param[in] file - The storj_file_meta_t struct from storj_finished_upload_cb callback
+ */
+STORJ_API void storj_free_uploaded_file_info(storj_file_meta_t *file);
+
 /**
  * @brief Will cancel a download
  *

data/ext/libstorj/src/uploader.c

@@ -248,10 +248,6 @@ static void cleanup_state(storj_upload_state_t *state)
         free(state->frame_id);
     }
 
-    if (state->hmac_id) {
-        free(state->hmac_id);
-    }
-
     if (state->encrypted_file_name) {
         free((char *)state->encrypted_file_name);
     }
@@ -260,6 +256,10 @@ static void cleanup_state(storj_upload_state_t *state)
         free(state->exclude);
     }
 
+    if (state->index) {
+        free((char *)state->index);
+    }
+
     if (state->encryption_ctr) {
         free(state->encryption_ctr);
     }
@@ -286,10 +286,6 @@ static void cleanup_state(storj_upload_state_t *state)
         free(state->encrypted_file_path);
     }
 
-    if (state->index) {
-        free((char *)state->index);
-    }
-
     if (state->shard) {
         for (int i = 0; i < state->total_shards; i++ ) {
 
@@ -309,7 +305,7 @@ static void cleanup_state(storj_upload_state_t *state)
         free(state->shard);
     }
 
-    state->finished_cb(state->error_status, state->file_id, state->handle);
+    state->finished_cb(state->error_status, state->info, state->handle);
 
     free(state);
 }
@@ -358,17 +354,36 @@ static void after_create_bucket_entry(uv_work_t *work, int status)
         req->log->info(state->env->log_options, state->handle,
                        "Successfully Added bucket entry");
 
+        req->log->debug(state->env->log_options, state->handle,
+                        "fn[after_create_bucket_entry] - JSON Response: %s", json_object_to_json_string(req->response));
+
         state->add_bucket_entry_count = 0;
         state->completed_upload = true;
 
+        state->info = malloc(sizeof(storj_file_meta_t));
+        state->info->created = NULL;
+        state->info->filename = state->file_name;
+        state->info->mimetype = NULL;
+        state->info->erasure = NULL;
+        state->info->size = state->file_size;
+        state->info->hmac = state->hmac_id;
+        state->info->id = NULL;
+        state->info->bucket_id = state->bucket_id;
+        state->info->decrypted = true;
+        state->info->index = strdup(state->index);
+
         struct json_object *file_id_value = NULL;
-        char *file_id = NULL;
+        struct json_object *created_value = NULL;
+        struct json_object *mimetype_value = NULL;
+        
         if (json_object_object_get_ex(req->response, "id", &file_id_value)) {
-            file_id = (char *)json_object_get_string(file_id_value);
+        	state->info->id = strdup((char *)json_object_get_string(file_id_value));
         }
-
-        if (file_id) {
-            state->file_id = strdup(file_id);
+        if (json_object_object_get_ex(req->response, "created", &created_value)) {
+        	state->info->created = strdup((char *)json_object_get_string(created_value));
+        }
+        if (json_object_object_get_ex(req->response, "mimetype", &mimetype_value)) {
+        	state->info->mimetype = strdup((char *)json_object_get_string(mimetype_value));
         }
 
     } else if (state->add_bucket_entry_count == 6) {
@@ -2133,7 +2148,6 @@ static void verify_bucket_id_callback(uv_work_t *work_req, int status)
 clean_variables:
     queue_next_work(state);
 
-    json_object_put(req->response);
     storj_free_get_bucket_request(req);
     free(work_req);
 }
@@ -2460,44 +2474,14 @@ static void prepare_upload_state(uv_work_t *work)
         state->shard[i].work = NULL;
     }
 
-    // Get the bucket key to encrypt the filename
-    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
-    generate_bucket_key(state->env->encrypt_options->mnemonic,
-                        state->bucket_id,
-                        &bucket_key_as_str);
-
-    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
-    if (!bucket_key) {
+    if (encrypt_file_name(state->env->encrypt_options->mnemonic,
+                          state->bucket_id,
+                          state->file_name,
+                          (char **)&state->encrypted_file_name)) {
         state->error_status = STORJ_MEMORY_ERROR;
         return;
     }
 
-    free(bucket_key_as_str);
-
-    // Get file name encryption key with first half of hmac w/ magic
-    struct hmac_sha512_ctx ctx1;
-    hmac_sha512_set_key(&ctx1, SHA256_DIGEST_SIZE, bucket_key);
-    hmac_sha512_update(&ctx1, SHA256_DIGEST_SIZE, BUCKET_META_MAGIC);
-    uint8_t key[SHA256_DIGEST_SIZE];
-    hmac_sha512_digest(&ctx1, SHA256_DIGEST_SIZE, key);
-
-    // Generate the synthetic iv with first half of hmac w/ bucket and filename
-    struct hmac_sha512_ctx ctx2;
-    hmac_sha512_set_key(&ctx2, SHA256_DIGEST_SIZE, bucket_key);
-    hmac_sha512_update(&ctx2, strlen(state->bucket_id),
-                       (uint8_t *)state->bucket_id);
-    hmac_sha512_update(&ctx2, strlen(state->file_name),
-                       (uint8_t *)state->file_name);
-    uint8_t filename_iv[SHA256_DIGEST_SIZE];
-    hmac_sha512_digest(&ctx2, SHA256_DIGEST_SIZE, filename_iv);
-
-    free(bucket_key);
-
-    char *encrypted_file_name;
-    encrypt_meta(state->file_name, key, filename_iv, &encrypted_file_name);
-
-    state->encrypted_file_name = encrypted_file_name;
-
     uint8_t *index = NULL;
     char *key_as_str = NULL;
 
@@ -2663,7 +2647,7 @@ STORJ_API storj_upload_state_t *storj_bridge_store_file(storj_env_t *env,
     } else {
         state->index = NULL;
     }
-    state->file_id = NULL;
+    state->info = NULL;
     state->file_name = opts->file_name;
     state->encrypted_file_name = NULL;
     state->original_file = opts->fd;
@@ -2734,3 +2718,15 @@ STORJ_API storj_upload_state_t *storj_bridge_store_file(storj_env_t *env,
     }
     return state;
 }
+
+STORJ_API void storj_free_uploaded_file_info(storj_file_meta_t *file)
+{
+    if (file) {
+        free((char *)file->id);
+        free((char *)file->created);
+        free((char *)file->mimetype);
+        free((char *)file->hmac);
+        free((char *)file->index);
+    }
+    free(file);
+}

data/ext/libstorj/src/utils.c

@@ -80,6 +80,54 @@ char *str_concat_many(int count, ...)
     return combined;
 }
 
+char *str_replace(char *search, char *replace, char *subject) {
+    char *result;       // the return string
+    char *ins;          // the next insert point
+    char *tmp;          // varies
+    size_t len_search;  // length of search (the string to remove)
+    size_t len_replace; // length of replace (the string to replace search with)
+    size_t len_front;   // distance between search and end of last replace
+    int count;          // number of replacements
+
+    // sanity checks and initialization
+    if (!subject || !search)
+        return NULL;
+    len_search = strlen(search);
+    if (len_search == 0)
+        return NULL; // empty search causes infinite loop during count
+    if (!replace)
+        replace = "";
+    len_replace = strlen(replace);
+
+    // count the number of replacements needed
+    ins = subject;
+    tmp = strstr(ins, search);
+    for (count = 0; tmp != NULL; ++count) {
+        ins = tmp + len_search;
+        tmp = strstr(ins, search);
+    }
+
+    tmp = result = malloc(strlen(subject) + (len_replace - len_search) * count + 1);
+
+    if (!result)
+        return NULL;
+
+    // first time through the loop, all the variable are set correctly
+    // from here on,
+    //    tmp points to the end of the result string
+    //    ins points to the next occurrence of search in subject
+    //    orig points to the remainder of subject after "end of search"
+    while (count--) {
+        ins = strstr(subject, search);
+        len_front = ins - subject;
+        tmp = strncpy(tmp, subject, len_front) + len_front;
+        tmp = strcpy(tmp, replace) + len_replace;
+        subject += len_front + len_search; // move to next "end of search"
+    }
+    strcpy(tmp, subject);
+    return result;
+}
+
 void random_buffer(uint8_t *buf, size_t len)
 {
     static FILE *frand = NULL;

data/ext/libstorj/src/utils.h

@@ -48,6 +48,18 @@ uint8_t *str2hex(size_t length, char *data);
 
 char *str_concat_many(int count, ...);
 
+/**
+ * @brief Replace all occurrences of the search string with the replacement string
+ *
+ * The result string from this function must be freed.
+ *
+ * @param[in] search The value being searched for, otherwise known as the needle
+ * @param[in] replace The replacement value that replaces found search values
+ * @param[in] subject The string being searched and replaced on, otherwise known as the haystack.
+ * @return A null value on error, otherwise a string with replaced values.
+ */
+char *str_replace(char *search, char *replace, char *subject);
+
 void random_buffer(uint8_t *buf, size_t len);
 
 uint64_t shard_size(int hops);

data/ext/libstorj/test/mockbridge.c

@@ -90,7 +90,12 @@ int mock_bridge_server(void *cls,
               page = get_response_string(responses, "getbucket");
               status_code = MHD_HTTP_OK;
           }
-        } else if (0 == strcmp(url, "/buckets/368be0816766b28fd5f43af5/files")) {
+        } else if (0 == strcmp(url, "/bucket-ids/g9qacwq2AE1+5nzL/HYyYdY9WoIr+1ueOuVEx6/IzzZKK9sULoKDDdYvhOpavHH2P3xQNw==")) {
+            if (check_auth(user, pass, &status_code, page)) {
+                page = get_response_string(responses, "getbucketid");
+                status_code = MHD_HTTP_OK;
+            }
+        }  else if (0 == strcmp(url, "/buckets/368be0816766b28fd5f43af5/files")) {
             if (check_auth(user, pass, &status_code, page)) {
                 page = get_response_string(responses, "listfiles");
                 status_code = MHD_HTTP_OK;
@@ -100,6 +105,11 @@ int mock_bridge_server(void *cls,
                 page = get_response_string(responses, "getfileinfo");
                 status_code = MHD_HTTP_OK;
             }
+        } else if (0 == strcmp(url, "/buckets/368be0816766b28fd5f43af5/file-ids/QR6/qHizNFm+t+4vSvr575xVp2R3/rC/qFlmOH10HsdGQtofpUUqwEdaZUJI0jPIImYMZFu6cZDrMIvJtcK3pHAb+kkPv0Y5")) {
+            if (check_auth(user, pass, &status_code, page)) {
+                page = get_response_string(responses, "getfileid");
+                status_code = MHD_HTTP_OK;
+            }
         } else if (0 == strcmp(url, "/buckets/368be0816766b28fd5f43af5/file-ids/hTY5wsqYyLJQppCMiFQI7v2n/IZZiKb0ES1RCrUqK7Fe5m0/+fYwh+E/vp8M3FCEECle63BhlWlHi/Hj/Yg5y/bIjy8SxQ==")) {
             if (check_auth(user, pass, &status_code, page)) {
                 status_code = MHD_HTTP_NOT_FOUND;

data/ext/libstorj/test/mockbridge.json

@@ -23,6 +23,9 @@
     "name": "g9qacwq2AE1+5nzL/HYyYdY9WoIr+1ueOuVEx6/IzzZKK9sULoKDDdYvhOpavHH2P3xQNw==",
     "id": "368be0816766b28fd5f43af5"
   },
+  "getbucketid": {
+    "id": "368be0816766b28fd5f43af5"
+  },
   "putbuckets": {
     "user": "user@sample.com",
     "encryptionKey": "",

data/ext/libstorj/test/tests.c

@@ -26,6 +26,10 @@ storj_encrypt_options_t encrypt_options = {
     .mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
 };
 
+storj_encrypt_options_t encrypt_options_null_mnemonic = {
+    .mnemonic = NULL
+};
+
 storj_http_options_t http_options = {
     .user_agent = "storj-test",
     .low_speed_limit = 0,
@@ -99,6 +103,20 @@ void check_get_bucket(uv_work_t *work_req, int status)
     free(work_req);
 }
 
+void check_get_bucket_id(uv_work_t *work_req, int status)
+{
+    assert(status == 0);
+    get_bucket_id_request_t *req = work_req->data;
+    assert(req->handle == NULL);
+    assert(strcmp(req->bucket_id, "368be0816766b28fd5f43af5") == 0);
+
+    pass("storj_bridge_get_bucket_id");
+
+    json_object_put(req->response);
+    free(req);
+    free(work_req);
+}
+
 void check_get_buckets_badauth(uv_work_t *work_req, int status)
 {
     assert(status == 0);
@@ -188,6 +206,20 @@ void check_list_files_badauth(uv_work_t *work_req, int status)
     free(work_req);
 }
 
+void check_get_file_id(uv_work_t *work_req, int status)
+{
+    assert(status == 0);
+    get_file_id_request_t *req = work_req->data;
+    assert(req->handle == NULL);
+    assert(strcmp(req->file_id, "998960317b6725a3f8080c2b") == 0);
+
+    pass("storj_bridge_get_file_id");
+
+    json_object_put(req->response);
+    free(req);
+    free(work_req);
+}
+
 void check_bucket_tokens(uv_work_t *work_req, int status)
 {
     assert(status == 0);
@@ -261,6 +293,18 @@ void check_resolve_file(int status, FILE *fd, void *handle)
     }
 }
 
+void check_resolve_file_null_mnemonic(int status, FILE *fd, void *handle)
+{
+    fclose(fd);
+    assert(handle == NULL);
+    if (status == STORJ_FILE_DECRYPTION_ERROR) {
+        pass("storj_bridge_resolve_file_null_mnemonic");
+    } else {
+        fail("storj_bridge_resolve_file_null_mnemonic");
+        printf("Status: %d\n", status);
+    }
+}
+
 void check_resolve_file_cancel(int status, FILE *fd, void *handle)
 {
     fclose(fd);
@@ -283,11 +327,11 @@ void check_store_file_progress(double progress,
     }
 }
 
-void check_store_file(int error_code, char *file_id, void *handle)
+void check_store_file(int error_code, storj_file_meta_t *file, void *handle)
 {
     assert(handle == NULL);
     if (error_code == 0) {
-        if (strcmp(file_id, "85fb0ed00de1196dc22e0f6d") == 0 ) {
+        if (file && strcmp(file->id, "85fb0ed00de1196dc22e0f6d") == 0 ) {
             pass("storj_bridge_store_file");
         } else {
             fail("storj_bridge_store_file(0)");
@@ -297,10 +341,10 @@ void check_store_file(int error_code, char *file_id, void *handle)
         printf("\t\tERROR:   %s\n", storj_strerror(error_code));
     }
 
-    free(file_id);
+    storj_free_uploaded_file_info(file);
 }
 
-void check_store_file_cancel(int error_code, char *file_id, void *handle)
+void check_store_file_cancel(int error_code, storj_file_meta_t *file, void *handle)
 {
     assert(handle == NULL);
     if (error_code == STORJ_TRANSFER_CANCELED) {
@@ -310,7 +354,7 @@ void check_store_file_cancel(int error_code, char *file_id, void *handle)
         printf("\t\tERROR:   %s\n", storj_strerror(error_code));
     }
 
-    free(file_id);
+    storj_free_uploaded_file_info(file);
 }
 
 void check_delete_file(uv_work_t *work_req, int status)
@@ -412,22 +456,15 @@ void check_delete_frame(uv_work_t *work_req, int status)
 void check_file_info(uv_work_t *work_req, int status)
 {
     assert(status == 0);
-    json_request_t *req = work_req->data;
+    get_file_info_request_t *req = work_req->data;
     assert(req->handle == NULL);
+    assert(req->file);
+    assert(strcmp(req->file->filename, "storj-test-download.data") == 0);
+    assert(strcmp(req->file->mimetype, "video/ogg") == 0);
 
-    struct json_object *value;
-    int success = json_object_object_get_ex(req->response, "mimetype", &value);
-    assert(success == 1);
-    assert(json_object_is_type(value, json_type_string) == 1);
-
-    const char* mimetype = json_object_get_string(value);
-
-    assert(strcmp(mimetype, "video/ogg") == 0);
     pass("storj_bridge_get_file_info");
 
-    json_object_put(req->response);
-    free(req->path);
-    free(req);
+    storj_free_get_file_info_request(req);
     free(work_req);
 }
 
@@ -614,12 +651,12 @@ int test_upload_cancel()
     return 0;
 }
 
-int test_download()
+int _test_download(storj_encrypt_options_t *encrypt_options, void *cb_finished)
 {
 
     // initialize event loop and environment
     storj_env_t *env = storj_init_env(&bridge_options,
-                                      &encrypt_options,
+                                      encrypt_options,
                                       &http_options,
                                       &log_options);
     assert(env != NULL);
@@ -639,7 +676,7 @@ int test_download()
                                                               download_fp,
                                                               NULL,
                                                               check_resolve_file_progress,
-                                                              check_resolve_file);
+                                                              cb_finished);
 
     if (!state || state->error_status != 0) {
         return 1;
@@ -656,6 +693,16 @@ int test_download()
     return 0;
 }
 
+int test_download()
+{
+    return _test_download(&encrypt_options, check_resolve_file);
+}
+
+int test_download_null_mnemonic()
+{
+    return _test_download(&encrypt_options_null_mnemonic, check_resolve_file_null_mnemonic);
+}
+
 int test_download_cancel()
 {
 
@@ -775,6 +822,10 @@ int test_api()
     status = storj_bridge_get_bucket(env, bucket_id, NULL, check_get_bucket);
     assert(status == 0);
 
+    // get bucket id
+    status = storj_bridge_get_bucket_id(env, "test", NULL, check_get_bucket_id);
+    assert(status == 0);
+
     // create a new bucket with a name
     status = storj_bridge_create_bucket(env, "backups", NULL,
                                         check_create_bucket);
@@ -791,6 +842,11 @@ int test_api()
                                      check_list_files);
     assert(status == 0);
 
+    // get file id
+    status = storj_bridge_get_file_id(env, bucket_id, "storj-test-download.data",
+                                      NULL, check_get_file_id);
+    assert(status == 0);
+
     // create bucket tokens
     status = storj_bridge_create_bucket_token(env,
                                               bucket_id,
@@ -1106,6 +1162,31 @@ int test_generate_seed_256_trezor()
     return 0;
 }
 
+int test_generate_seed_null_mnemonic()
+{
+    char *mnemonic = NULL;
+    char *seed = calloc(128 + 1, sizeof(char));
+    char *expected_seed = "4ed8d4b17698ddeaa1f1559f152f87b5d472f725ca86d341bd0276f1b61197e21dd5a391f9f5ed7340ff4d4513aab9cce44f9497a5e7ed85fd818876b6eb402e";
+
+    mnemonic_to_seed(mnemonic, "", &seed);
+    seed[128] = '\0';
+
+    int check = memcmp(seed, expected_seed, 128);
+    if (check != 0) {
+        fail("test_generate_seed");
+        printf("\t\texpected seed: %s\n", expected_seed);
+        printf("\t\tactual seed:   %s\n", seed);
+
+        free(seed);
+        return 1;
+    }
+
+    free(seed);
+    pass("test_generate_seed_null_mnemonic");
+
+    return 0;
+}
+
 int test_generate_bucket_key()
 {
     char *mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
@@ -1524,6 +1605,34 @@ int test_memory_mapping()
     return 0;
 }
 
+int test_str_replace()
+{
+    char *subject = "g9qacwq2AE1+5nzL/HYyYdY9WoIr+1ueOuVEx6/IzzZKK9sULoKDDdYvhOpavHH2P3xQNw==";
+
+    char *result = str_replace("/", "%2F", subject);
+    if (!result) {
+        fail("test_str_replace");
+        return 0;
+    }
+
+    char *expected = "g9qacwq2AE1+5nzL%2FHYyYdY9WoIr+1ueOuVEx6%2FIzzZKK9sULoKDDdYvhOpavHH2P3xQNw==";
+
+    int failed = 0;
+    if (strcmp(expected, result) != 0) {
+        failed = 1;
+    }
+
+    if (failed) {
+        fail("test_str_replace");
+    } else {
+        pass("test_str_replace");
+    }
+
+    free(result);
+
+    return 0;
+}
+
 // Test Bridge Server
 struct MHD_Daemon *start_test_server()
 {
@@ -1569,6 +1678,7 @@ int main(void)
 
     printf("Test Suite: Downloads\n");
     test_download();
+    test_download_null_mnemonic();
     test_download_cancel();
     printf("\n");
 
@@ -1580,6 +1690,7 @@ int main(void)
     test_generate_seed();
     test_generate_seed_256();
     test_generate_seed_256_trezor();
+    test_generate_seed_null_mnemonic();
     printf("\n");
 
     printf("Test Suite: Crypto\n");
@@ -1596,6 +1707,7 @@ int main(void)
     test_get_time_milliseconds();
     test_determine_shard_size();
     test_memory_mapping();
+    test_str_replace();
 
     int num_failed = tests_ran - test_status;
     printf(KGRN "\nPASSED: %i" RESET, test_status);