ruby-libstorj 0.0.0 → 1.0.0

data/ext/libstorj/src/cli_callback.h

@@ -0,0 +1,175 @@
+/**
+ * @file storjapi_callback.h
+ * @brief Storj callback library.
+ *
+ * Implements callback functionality that can be customised for 
+ * end user's application
+ */
+
+#ifndef CLI_CALLBACK_H
+#define CLI_CALLBACK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "storj.h"
+
+#define CLI_NO_SUCH_FILE_OR_DIR   0x00
+#define CLI_VALID_REGULAR_FILE    0x01
+#define CLI_VALID_DIR             0x02
+#define CLI_UNKNOWN_FILE_ATTR     0x03
+#define CLI_UPLOAD_FILE_LOG_ERR   0x04
+
+/**
+ * @brief A Structure for passing the User's Application info to
+ *        Storj API.
+ */
+typedef struct cli_api {
+    storj_env_t *env;
+    char *bucket_name;
+    char bucket_id[256];
+    char *file_name;
+    char file_id[256];
+    char *file_path;     /**< local upload files directory path */
+    FILE *src_fd;
+    char src_list[256];      /**< file list ready to upload */
+    char *src_file;      /**< next file ready to upload */
+    FILE *dst_fd;
+    char *dst_file;      /**< next file ready to upload */
+    int  xfer_count;     /**< # of files xferred (up/down) */
+    int  total_files;    /**< total files to upload */
+    char *last_cmd_req;  /**< last command requested */
+    char *curr_cmd_req;  /**< cli curr command requested */
+    char *next_cmd_req;  /**< cli curr command requested */
+    char *final_cmd_req; /**< final command in the seq */
+    char *excp_cmd_resp; /**< expected cmd response */
+    char *rcvd_cmd_resp; /**< received cmd response */
+    int  error_status;   /**< command response/error status */
+    storj_log_levels_t *log;
+    void *handle;
+} cli_api_t;
+
+/**
+ * @brief Callback function listing bucket names & IDs 
+ */
+void get_buckets_callback(uv_work_t *work_req, int status);
+
+/**
+ * @brief Callback function returning the bucket id for a given
+ *        bucket name
+ */
+void get_bucket_id_callback(uv_work_t *work_req, int status);
+
+/**
+ * @brief Callback function returning the file id for a given
+ *        file name
+ */
+void get_file_id_callback(uv_work_t *work_req, int status);
+
+/**
+ * @brief Storj api state machine function 
+ */
+void queue_next_cmd_req(cli_api_t *cli_api);
+
+/**
+ * @brief Function lists the bucket names & IDs 
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_list_buckets(cli_api_t *cli_api);
+
+/**
+ * @brief Function returns the corresponding bucket's id for a 
+ *        given bucket name
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_get_bucket_id(cli_api_t *cli_api);
+
+/**
+ * @brief Function to list files in a given bucket name
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_list_files(cli_api_t *cli_api);
+
+/**
+ * @brief Function to remove a given bucket name 
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_remove_bucket(cli_api_t *cli_api);
+
+/**
+ * @brief Function to remove a file from a given bucket name 
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_remove_file(cli_api_t *cli_api);
+
+/**
+ * @brief Function to return the node IDs for a given file for a
+ *        given bucket name
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_list_mirrors(cli_api_t *cli_api);
+
+/**
+ * @brief Function to upload a local file into a given bucket 
+ *        name
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_upload_file(cli_api_t *cli_api);
+
+/**
+ * @brief Function to upload local files into a given bucket 
+ *        name
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_upload_files(cli_api_t *cli_api);
+
+/**
+ * @brief Function to download a file from a given bucket to a 
+ *        local folder
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_download_file(cli_api_t *cli_api);
+
+/**
+ * @brief Function to download files from a given bucket to a 
+ *        local folder
+ * 
+ * @param[in] cli_api_t structure that passes user's input
+ *       info
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int cli_download_files(cli_api_t *cli_api);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CLI_CALLBACK_H */

data/ext/libstorj/src/crypto.c

@@ -141,6 +141,98 @@ cleanup:
     return status;
 }
 
+int decrypt_bucket_name(const char *mnemonic, const char *encrypted_name, char **decrypted_name) {
+    return decrypt_file_name(mnemonic, BUCKET_NAME_MAGIC, encrypted_name, decrypted_name);
+}
+
+int decrypt_file_name(const char *mnemonic, const char* bucket_id,
+                      const char *encrypted_name, char **decrypted_name) {
+    int status = 0;
+
+    // Derive a key based on the bucket id
+    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
+    generate_bucket_key(mnemonic, bucket_id, &bucket_key_as_str);
+
+    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
+    if (!bucket_key) {
+        status = 1;
+        goto cleanup;
+    }
+
+    // Get 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);
+
+    status = decrypt_meta(encrypted_name, key, decrypted_name);
+
+cleanup:
+
+    if (bucket_key) {
+        memset_zero(bucket_key, BASE16_DECODE_LENGTH(strlen(bucket_key_as_str)) + 1);
+        free(bucket_key);
+    }
+    if (bucket_key_as_str) {
+        memset_zero(bucket_key_as_str, DETERMINISTIC_KEY_SIZE + 1);
+        free(bucket_key_as_str);
+    }
+
+    return status;
+}
+
+int encrypt_bucket_name(const char *mnemonic, const char *bucket_name, char **encrypted_name) {
+    return encrypt_file_name(mnemonic, BUCKET_NAME_MAGIC, bucket_name, encrypted_name);
+}
+
+int encrypt_file_name(const char *mnemonic, const char* bucket_id,
+                      const char *file_name, char **encrypted_name) {
+    int status = 0;
+
+    // Derive a key based on the bucket id
+    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
+    generate_bucket_key(mnemonic, bucket_id, &bucket_key_as_str);
+
+    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
+    if (!bucket_key) {
+        status = 1;
+        goto cleanup;
+    }
+
+    // Get 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);
+    if (strcmp(bucket_id, BUCKET_NAME_MAGIC)) {
+        hmac_sha512_update(&ctx2, strlen(bucket_id), (uint8_t *) bucket_id);
+    }
+    hmac_sha512_update(&ctx2, strlen(file_name), (uint8_t *)file_name);
+    uint8_t iv[SHA256_DIGEST_SIZE];
+    hmac_sha512_digest(&ctx2, SHA256_DIGEST_SIZE, iv);
+
+    status = encrypt_meta(file_name, key, iv, encrypted_name);
+
+cleanup:
+
+    if (bucket_key) {
+        memset_zero(bucket_key, BASE16_DECODE_LENGTH(strlen(bucket_key_as_str)) + 1);
+        free(bucket_key);
+    }
+    if (bucket_key_as_str) {
+        memset_zero(bucket_key_as_str, DETERMINISTIC_KEY_SIZE + 1);
+        free(bucket_key_as_str);
+    }
+
+    return status;
+}
+
 int get_deterministic_key(const char *key, int key_len,
                           const char *id, char **buffer)
 {
@@ -462,18 +554,20 @@ int decrypt_meta(const char *buffer_base64,
     if (!base64_decode_update(&ctx3, &decode_len, buffer,
                               strlen(buffer_base64), (uint8_t *)buffer_base64)) {
         free(buffer);
-        return 1;
+        //STORJ_META_DECRYPTION_ERROR
+        return 6001;
     }
 
     if (!base64_decode_final(&ctx3)) {
         free(buffer);
-        return 1;
+        //STORJ_META_DECRYPTION_ERROR
+        return 6001;
     }
 
     if (GCM_DIGEST_SIZE + SHA256_DIGEST_SIZE + 1 > decode_len) {
         free(buffer);
         //STORJ_META_DECRYPTION_ERROR
-        return 1;
+        return 6001;
     }
 
     size_t length = decode_len - GCM_DIGEST_SIZE - SHA256_DIGEST_SIZE;
@@ -511,7 +605,7 @@ int decrypt_meta(const char *buffer_base64,
     int digest_match = memcmp(actual_digest, digest, GCM_DIGEST_SIZE);
     if (digest_match != 0) {
         //STORJ_META_DECRYPTION_ERROR
-        return 1;
+        return 6001;
     }
 
     *filemeta = calloc(length + 1, sizeof(char));

data/ext/libstorj/src/crypto.h

@@ -71,6 +71,57 @@ int generate_file_key(const char *mnemonic,
                       const char *index,
                       char **file_key);
 
+/**
+ * @brief Decrypt a bucket name
+ *
+ * @param[in] mnemonic Character array of the mnemonic
+ * @param[in] encrypted_name Character array of the encrypted name
+ * @param[out] decrypted_name Character array of the decrypted name
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int decrypt_bucket_name(const char *mnemonic,
+                        const char *encrypted_name,
+                        char **decrypted_name);
+
+/**
+ * @brief Decrypt a file name
+ *
+ * @param[in] mnemonic Character array of the mnemonic
+ * @param[in] bucket_id Character array of bucket id
+ * @param[in] encrypted_name Character array of the encrypted name
+ * @param[out] decrypted_name Character array of the decrypted name
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int decrypt_file_name(const char *mnemonic,
+                      const char *bucket_id,
+                      const char *encrypted_name,
+                      char **decrypted_name);
+/**
+ * @brief Encrypt a bucket name
+ *
+ * @param[in] mnemonic Character array of the mnemonic
+ * @param[in] bucket_name Character array of the bucket name
+ * @param[out] encrypted_name Character array of the encrypted name
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int encrypt_bucket_name(const char *mnemonic,
+                        const char *bucket_name,
+                        char **encrypted_name);
+
+/**
+ * @brief Encrypt a file name
+ *
+ * @param[in] mnemonic Character array of the mnemonic
+ * @param[in] bucket_id Character array of bucket id
+ * @param[in] file_name Character array of the file name
+ * @param[out] encrypted_name Character array of the encrypted name
+ * @return A non-zero error value on failure and 0 on success.
+ */
+int encrypt_file_name(const char *mnemonic,
+                      const char *bucket_id,
+                      const char *file_name,
+                      char **encrypted_name);
+
 /**
  * @brief Calculate deterministic key by getting sha512 of key + id
  *

data/ext/libstorj/src/downloader.c

@@ -1125,9 +1125,7 @@ static void determine_decryption_key_v0(storj_download_state_t *state)
 
 static void determine_decryption_key(storj_download_state_t *state)
 {
-    if (!state->env->encrypt_options ||
-        !state->env->encrypt_options->mnemonic) {
-
+    if (!state->env->encrypt_options) {
         state->decrypt_key = NULL;
         state->decrypt_ctr = NULL;
     } else {
@@ -1240,6 +1238,7 @@ static void request_info(uv_work_t *work)
         req->info->size = 0;
         req->info->hmac = NULL;
         req->info->id = NULL;
+        req->info->bucket_id = NULL;
         req->info->decrypted = false;
         req->info->index = NULL;
 

data/ext/libstorj/src/storj.c

@@ -22,42 +22,14 @@ static void create_bucket_request_worker(uv_work_t *work)
     create_bucket_request_t *req = work->data;
     int status_code = 0;
 
-    // Derive a key based on the master seed and bucket name magic number
-    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
-    generate_bucket_key(req->encrypt_options->mnemonic,
-                        BUCKET_NAME_MAGIC,
-                        &bucket_key_as_str);
-
-    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
-    if (!bucket_key) {
+    // Encrypt the bucket name
+    if (encrypt_bucket_name(req->encrypt_options->mnemonic,
+                            req->bucket_name,
+                            (char **)&req->encrypted_bucket_name)) {
         req->error_code = STORJ_MEMORY_ERROR;
         return;
     }
 
-    free(bucket_key_as_str);
-
-    // Get bucket 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/ name
-    struct hmac_sha512_ctx ctx2;
-    hmac_sha512_set_key(&ctx2, SHA256_DIGEST_SIZE, bucket_key);
-    hmac_sha512_update(&ctx2, strlen(req->bucket_name),
-                       (uint8_t *)req->bucket_name);
-    uint8_t bucketname_iv[SHA256_DIGEST_SIZE];
-    hmac_sha512_digest(&ctx2, SHA256_DIGEST_SIZE, bucketname_iv);
-
-    free(bucket_key);
-
-    // Encrypt the bucket name
-    char *encrypted_bucket_name;
-    encrypt_meta(req->bucket_name, key, bucketname_iv, &encrypted_bucket_name);
-    req->encrypted_bucket_name = encrypted_bucket_name;
-
     struct json_object *body = json_object_new_object();
     json_object *name = json_object_new_string(req->encrypted_bucket_name);
     json_object_object_add(body, "name", name);
@@ -72,10 +44,14 @@ static void create_bucket_request_worker(uv_work_t *work)
         req->bucket = malloc(sizeof(storj_bucket_meta_t));
 
         struct json_object *id;
+        struct json_object *created;
+
         json_object_object_get_ex(req->response, "id", &id);
+        json_object_object_get_ex(req->response, "created", &created);
 
         req->bucket->id = json_object_get_string(id);
         req->bucket->name = req->bucket_name;
+        req->bucket->created = json_object_get_string(created);
         req->bucket->decrypted = true;
     }
 
@@ -104,29 +80,6 @@ static void get_buckets_request_worker(uv_work_t *work)
         req->total_buckets = num_buckets;
     }
 
-    // Derive a key based on the master seed
-    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
-    generate_bucket_key(req->encrypt_options->mnemonic,
-                        BUCKET_NAME_MAGIC,
-                        &bucket_key_as_str);
-
-    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
-    if (!bucket_key) {
-        req->error_code = STORJ_MEMORY_ERROR;
-        return;
-    }
-
-    free(bucket_key_as_str);
-
-    // Get bucket 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);
-
-    free(bucket_key);
-
     struct json_object *bucket_item;
     struct json_object *name;
     struct json_object *created;
@@ -154,14 +107,17 @@ static void get_buckets_request_worker(uv_work_t *work)
             continue;
         }
         char *decrypted_name;
-        int error_status = decrypt_meta(encrypted_name, key,
-                                        &decrypted_name);
+        int error_status = decrypt_bucket_name(req->encrypt_options->mnemonic,
+                                               encrypted_name,
+                                               &decrypted_name);
         if (!error_status) {
             bucket->decrypted = true;
             bucket->name = decrypted_name;
-        } else {
+        } else if (error_status == STORJ_META_DECRYPTION_ERROR){
             bucket->decrypted = false;
             bucket->name = strdup(encrypted_name);
+        } else {
+            req->error_code = STORJ_MEMORY_ERROR;
         }
     }
 }
@@ -182,29 +138,6 @@ static void get_bucket_request_worker(uv_work_t *work)
         return;
     }
 
-    // Derive a key based on the master seed
-    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
-    generate_bucket_key(req->encrypt_options->mnemonic,
-                        BUCKET_NAME_MAGIC,
-                        &bucket_key_as_str);
-
-    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
-    if (!bucket_key) {
-        req->error_code = STORJ_MEMORY_ERROR;
-        return;
-    }
-
-    free(bucket_key_as_str);
-
-    // Get bucket 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);
-
-    free(bucket_key);
-
     struct json_object *name;
     struct json_object *created;
     struct json_object *id;
@@ -226,18 +159,66 @@ static void get_bucket_request_worker(uv_work_t *work)
     const char *encrypted_name = json_object_get_string(name);
     if (encrypted_name) {
         char *decrypted_name;
-        int error_status = decrypt_meta(encrypted_name, key,
-                                        &decrypted_name);
+        int error_status = decrypt_bucket_name(req->encrypt_options->mnemonic,
+                                               encrypted_name,
+                                               &decrypted_name);
         if (!error_status) {
             req->bucket->decrypted = true;
             req->bucket->name = decrypted_name;
-        } else {
+        } else if (error_status == STORJ_META_DECRYPTION_ERROR){
             req->bucket->decrypted = false;
             req->bucket->name = strdup(encrypted_name);
+        } else {
+            req->error_code = STORJ_MEMORY_ERROR;
         }
     }
 }
 
+static void get_bucket_id_request_worker(uv_work_t *work)
+{
+    get_bucket_id_request_t *req = work->data;
+    int status_code = 0;
+
+    // Encrypt the bucket name
+    char *encrypted_bucket_name;
+    if (encrypt_bucket_name(req->encrypt_options->mnemonic,
+                            req->bucket_name,
+                            &encrypted_bucket_name)) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    char *escaped_encrypted_bucket_name = str_replace("/", "%2F", encrypted_bucket_name);
+    if (!escaped_encrypted_bucket_name) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    char *path = str_concat_many(2, "/bucket-ids/", escaped_encrypted_bucket_name);
+    if (!path) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    req->error_code = fetch_json(req->http_options,
+                                 req->options, "GET", path, NULL,
+                                 true, &req->response, &status_code);
+
+    if (req->response != NULL) {
+        struct json_object *id;
+        json_object_object_get_ex(req->response, "id", &id);
+        req->bucket_id = json_object_get_string(id);
+    }
+
+    req->status_code = status_code;
+
+cleanup:
+
+    free(encrypted_bucket_name);
+    free(escaped_encrypted_bucket_name);
+    free(path);
+}
+
 static void list_files_request_worker(uv_work_t *work)
 {
     list_files_request_t *req = work->data;
@@ -260,35 +241,18 @@ static void list_files_request_worker(uv_work_t *work)
         req->total_files = num_files;
     }
 
-    // Get the bucket key to encrypt the filename from bucket id
-    char *bucket_key_as_str = calloc(DETERMINISTIC_KEY_SIZE + 1, sizeof(char));
-    generate_bucket_key(req->encrypt_options->mnemonic,
-                        req->bucket_id,
-                        &bucket_key_as_str);
-
-    uint8_t *bucket_key = str2hex(strlen(bucket_key_as_str), bucket_key_as_str);
-    if (!bucket_key) {
-        req->error_code = 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);
-
-    free(bucket_key);
-
     struct json_object *file;
     struct json_object *filename;
     struct json_object *mimetype;
     struct json_object *size;
     struct json_object *id;
+    struct json_object *bucket_id;
     struct json_object *created;
+    struct json_object *hmac;
+    struct json_object *hmac_value;
+    struct json_object *erasure;
+    struct json_object *erasure_type;
+    struct json_object *index;
 
     for (int i = 0; i < num_files; i++) {
         file = json_object_array_get_idx(req->response, i);
@@ -297,17 +261,24 @@ static void list_files_request_worker(uv_work_t *work)
         json_object_object_get_ex(file, "mimetype", &mimetype);
         json_object_object_get_ex(file, "size", &size);
         json_object_object_get_ex(file, "id", &id);
+        json_object_object_get_ex(file, "bucket", &bucket_id);
         json_object_object_get_ex(file, "created", &created);
+        json_object_object_get_ex(file, "hmac", &hmac);
+        json_object_object_get_ex(hmac, "value", &hmac_value);
+        json_object_object_get_ex(file, "erasure", &erasure);
+        json_object_object_get_ex(erasure, "type", &erasure_type);
+        json_object_object_get_ex(file, "index", &index);
 
         storj_file_meta_t *file = &req->files[i];
 
         file->created = json_object_get_string(created);
         file->mimetype = json_object_get_string(mimetype);
         file->size = json_object_get_int64(size);
-        file->erasure = NULL;
-        file->index = NULL;
-        file->hmac = NULL; // TODO though this value is not needed here
+        file->erasure = json_object_get_string(erasure_type);
+        file->index = json_object_get_string(index);
+        file->hmac = json_object_get_string(hmac_value);
         file->id = json_object_get_string(id);
+        file->bucket_id = json_object_get_string(bucket_id);
         file->decrypted = false;
         file->filename = NULL;
 
@@ -320,18 +291,138 @@ static void list_files_request_worker(uv_work_t *work)
             continue;
         }
         char *decrypted_file_name;
-        int error_status = decrypt_meta(encrypted_file_name, key,
-                                        &decrypted_file_name);
+        int error_status = decrypt_file_name(req->encrypt_options->mnemonic,
+                                             req->bucket_id,
+                                             encrypted_file_name,
+                                             &decrypted_file_name);
         if (!error_status) {
             file->decrypted = true;
             file->filename = decrypted_file_name;
-        } else {
+        } else if (error_status == STORJ_META_DECRYPTION_ERROR) {
             file->decrypted = false;
             file->filename = strdup(encrypted_file_name);
+        } else {
+            req->error_code = STORJ_MEMORY_ERROR;
+        }
+    }
+}
+
+static void get_file_info_request_worker(uv_work_t *work)
+{
+    get_file_info_request_t *req = work->data;
+    int status_code = 0;
+
+    req->error_code = fetch_json(req->http_options,
+                                 req->options, req->method, req->path, req->body,
+                                 req->auth, &req->response, &status_code);
+
+    req->status_code = status_code;
+
+    struct json_object *filename;
+    struct json_object *mimetype;
+    struct json_object *size;
+    struct json_object *id;
+    struct json_object *bucket_id;
+    struct json_object *created;
+    struct json_object *hmac;
+    struct json_object *hmac_value;
+    struct json_object *erasure;
+    struct json_object *erasure_type;
+    struct json_object *index;
+
+    json_object_object_get_ex(req->response, "filename", &filename);
+    json_object_object_get_ex(req->response, "mimetype", &mimetype);
+    json_object_object_get_ex(req->response, "size", &size);
+    json_object_object_get_ex(req->response, "id", &id);
+    json_object_object_get_ex(req->response, "bucket", &bucket_id);
+    json_object_object_get_ex(req->response, "created", &created);
+    json_object_object_get_ex(req->response, "hmac", &hmac);
+    json_object_object_get_ex(hmac, "value", &hmac_value);
+    json_object_object_get_ex(req->response, "erasure", &erasure);
+    json_object_object_get_ex(erasure, "type", &erasure_type);
+    json_object_object_get_ex(req->response, "index", &index);
+
+    req->file = malloc(sizeof(storj_file_meta_t));
+    req->file->created = json_object_get_string(created);
+    req->file->mimetype = json_object_get_string(mimetype);
+    req->file->size = json_object_get_int64(size);
+    req->file->erasure = json_object_get_string(erasure_type);
+    req->file->index = json_object_get_string(index);
+    req->file->hmac = json_object_get_string(hmac_value);
+    req->file->id = json_object_get_string(id);
+    req->file->bucket_id = json_object_get_string(bucket_id);
+    req->file->decrypted = false;
+    req->file->filename = NULL;
+
+    // Attempt to decrypt the filename, otherwise
+    // we will default the filename to the encrypted text.
+    // The decrypted flag will be set to indicate the status
+    // of decryption for alternative display.
+    const char *encrypted_file_name = json_object_get_string(filename);
+    if (encrypted_file_name) {
+        char *decrypted_file_name;
+        int error_status = decrypt_file_name(req->encrypt_options->mnemonic,
+                                             req->bucket_id,
+                                             encrypted_file_name,
+                                             &decrypted_file_name);
+        if (!error_status) {
+            req->file->decrypted = true;
+            req->file->filename = decrypted_file_name;
+        } else if (error_status == STORJ_META_DECRYPTION_ERROR) {
+        	req->file->decrypted = false;
+        	req->file->filename = strdup(encrypted_file_name);
+        } else {
+            req->error_code = STORJ_MEMORY_ERROR;
         }
     }
 }
 
+static void get_file_id_request_worker(uv_work_t *work)
+{
+    get_file_id_request_t *req = work->data;
+    int status_code = 0;
+
+    char *encrypted_file_name;
+    if (encrypt_file_name(req->encrypt_options->mnemonic,
+                          req->bucket_id,
+                          req->file_name,
+                          &encrypted_file_name)) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    char *escaped_encrypted_file_name = str_replace("/", "%2F", encrypted_file_name);
+    if (!escaped_encrypted_file_name) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    char *path = str_concat_many(4, "/buckets/", req->bucket_id,
+                                    "/file-ids/", escaped_encrypted_file_name);
+    if (!path) {
+        req->error_code = STORJ_MEMORY_ERROR;
+        goto cleanup;
+    }
+
+    req->error_code = fetch_json(req->http_options,
+                                 req->options, "GET", path, NULL,
+                                 true, &req->response, &status_code);
+
+    if (req->response != NULL) {
+        struct json_object *id;
+        json_object_object_get_ex(req->response, "id", &id);
+        req->file_id = json_object_get_string(id);
+    }
+
+    req->status_code = status_code;
+
+cleanup:
+
+    free(encrypted_file_name);
+    free(escaped_encrypted_file_name);
+    free(path);
+}
+
 static uv_work_t *uv_work_new()
 {
     uv_work_t *work = malloc(sizeof(uv_work_t));
@@ -401,6 +492,39 @@ static list_files_request_t *list_files_request_new(
     return req;
 }
 
+static get_file_info_request_t *get_file_info_request_new(
+    storj_http_options_t *http_options,
+    storj_bridge_options_t *options,
+    storj_encrypt_options_t *encrypt_options,
+    const char *bucket_id,
+    char *method,
+    char *path,
+    struct json_object *request_body,
+    bool auth,
+    void *handle)
+{
+    get_file_info_request_t *req = malloc(sizeof(get_file_info_request_t));
+    if (!req) {
+        return NULL;
+    }
+
+    req->http_options = http_options;
+    req->options = options;
+    req->encrypt_options = encrypt_options;
+    req->bucket_id = bucket_id;
+    req->method = method;
+    req->path = path;
+    req->auth = auth;
+    req->body = request_body;
+    req->response = NULL;
+    req->file = NULL;
+    req->error_code = 0;
+    req->status_code = 0;
+    req->handle = handle;
+
+    return req;
+}
+
 static create_bucket_request_t *create_bucket_request_new(
     storj_http_options_t *http_options,
     storj_bridge_options_t *bridge_options,
@@ -490,6 +614,58 @@ static get_bucket_request_t *get_bucket_request_new(
     return req;
 }
 
+static get_bucket_id_request_t *get_bucket_id_request_new(
+        storj_http_options_t *http_options,
+        storj_bridge_options_t *options,
+        storj_encrypt_options_t *encrypt_options,
+        const char *bucket_name,
+        void *handle)
+{
+    get_bucket_id_request_t *req = malloc(sizeof(get_bucket_id_request_t));
+    if (!req) {
+        return NULL;
+    }
+
+    req->http_options = http_options;
+    req->options = options;
+    req->encrypt_options = encrypt_options;
+    req->bucket_name = bucket_name;
+    req->response = NULL;
+    req->bucket_id = NULL;
+    req->error_code = 0;
+    req->status_code = 0;
+    req->handle = handle;
+
+    return req;
+}
+
+static get_file_id_request_t *get_file_id_request_new(
+        storj_http_options_t *http_options,
+        storj_bridge_options_t *options,
+        storj_encrypt_options_t *encrypt_options,
+        const char *bucket_id,
+        const char *file_name,
+        void *handle)
+{
+    get_file_id_request_t *req = malloc(sizeof(get_file_id_request_t));
+    if (!req) {
+        return NULL;
+    }
+
+    req->http_options = http_options;
+    req->options = options;
+    req->encrypt_options = encrypt_options;
+    req->bucket_id = bucket_id;
+    req->file_name = file_name;
+    req->response = NULL;
+    req->file_id = NULL;
+    req->error_code = 0;
+    req->status_code = 0;
+    req->handle = handle;
+
+    return req;
+}
+
 static uv_work_t *json_request_work_new(
     storj_env_t *env,
     char *method,
@@ -1190,7 +1366,9 @@ STORJ_API int storj_bridge_get_buckets(storj_env_t *env, void *handle, uv_after_
 
 STORJ_API void storj_free_get_buckets_request(get_buckets_request_t *req)
 {
-    json_object_put(req->response);
+    if (req->response) {
+        json_object_put(req->response);
+    }
     if (req->buckets && req->total_buckets > 0) {
         for (int i = 0; i < req->total_buckets; i++) {
             free((char *)req->buckets[i].name);
@@ -1271,7 +1449,9 @@ STORJ_API int storj_bridge_get_bucket(storj_env_t *env,
 
 STORJ_API void storj_free_get_bucket_request(get_bucket_request_t *req)
 {
-    json_object_put(req->response);
+    if (req->response) {
+        json_object_put(req->response);
+    }
     free(req->path);
     if (req->bucket) {
         free((char *)req->bucket->name);
@@ -1280,6 +1460,27 @@ STORJ_API void storj_free_get_bucket_request(get_bucket_request_t *req)
     free(req);
 }
 
+STORJ_API int storj_bridge_get_bucket_id(storj_env_t *env,
+                                         const char *name,
+                                         void *handle,
+                                         uv_after_work_cb cb)
+{
+    uv_work_t *work = uv_work_new();
+    if (!work) {
+        return STORJ_MEMORY_ERROR;
+    }
+
+    work->data = get_bucket_id_request_new(env->http_options,
+                                           env->bridge_options,
+                                           env->encrypt_options,
+                                           name, handle);
+    if (!work->data) {
+        return STORJ_MEMORY_ERROR;
+    }
+
+    return uv_queue_work(env->loop, (uv_work_t*) work, get_bucket_id_request_worker, cb);
+}
+
 STORJ_API int storj_bridge_list_files(storj_env_t *env,
                             const char *id,
                             void *handle,
@@ -1310,7 +1511,9 @@ STORJ_API int storj_bridge_list_files(storj_env_t *env,
 
 STORJ_API void storj_free_list_files_request(list_files_request_t *req)
 {
-    json_object_put(req->response);
+    if (req->response) {
+        json_object_put(req->response);
+    }
     free(req->path);
     if (req->files && req->total_files > 0) {
         for (int i = 0; i < req->total_files; i++) {
@@ -1452,10 +1655,10 @@ STORJ_API int storj_bridge_delete_frame(storj_env_t *env,
 }
 
 STORJ_API int storj_bridge_get_file_info(storj_env_t *env,
-                               const char *bucket_id,
-                               const char *file_id,
-                               void *handle,
-                               uv_after_work_cb cb)
+                                         const char *bucket_id,
+                                         const char *file_id,
+                                         void *handle,
+                                         uv_after_work_cb cb)
 {
     char *path = str_concat_many(5, "/buckets/", bucket_id, "/files/",
                                  file_id, "/info");
@@ -1463,13 +1666,58 @@ STORJ_API int storj_bridge_get_file_info(storj_env_t *env,
         return STORJ_MEMORY_ERROR;
     }
 
-    uv_work_t *work = json_request_work_new(env, "GET", path, NULL,
-                                            true, handle);
+    uv_work_t *work = uv_work_new();
     if (!work) {
         return STORJ_MEMORY_ERROR;
     }
 
-    return uv_queue_work(env->loop, (uv_work_t*) work, json_request_worker, cb);
+    work->data = get_file_info_request_new(env->http_options,
+                                           env->bridge_options,
+                                           env->encrypt_options,
+                                           bucket_id, "GET", path,
+                                           NULL, true, handle);
+
+    if (!work->data) {
+        return STORJ_MEMORY_ERROR;
+    }
+
+    return uv_queue_work(env->loop, (uv_work_t*) work,
+                         get_file_info_request_worker, cb);
+}
+
+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)
+{
+    uv_work_t *work = uv_work_new();
+    if (!work) {
+        return STORJ_MEMORY_ERROR;
+    }
+
+    work->data = get_file_id_request_new(env->http_options,
+                                         env->bridge_options,
+                                         env->encrypt_options,
+                                         bucket_id, file_name, handle);
+    if (!work->data) {
+        return STORJ_MEMORY_ERROR;
+    }
+
+    return uv_queue_work(env->loop, (uv_work_t*) work, get_file_id_request_worker, cb);
+}
+
+STORJ_API void storj_free_get_file_info_request(get_file_info_request_t *req)
+{
+    if (req->response) {
+        json_object_put(req->response);
+    }
+    free(req->path);
+    if (req->file) {
+        free((char *)req->file->filename);
+    }
+    free(req->file);
+    free(req);
 }
 
 STORJ_API int storj_bridge_list_mirrors(storj_env_t *env,