GhostSec Gift That Keeps On Giving

// FOR EDUCATIONAL PURPOSES ONLY

// GhostSec Gift Documentation

// Overview

// Welcome to GhostSec Gift, a powerful utility offering secure file operations, robust encryption, decryption, digital signatures, and the unique ability to bind executables to media files. Leveraging the prowess of OpenSSL and libzip libraries, GhostSec Gift ensures advanced cryptographic functions and efficient archive management.

// Installation

// Prerequisites:

// Ensure OpenSSL is installed on your system. Use your package manager for streamlined installation, such as:

```bash
sudo apt-get install libssl-dev
```

// Compilation:

// Compile GhostSec Gift with a C++ compiler, specifying the required libraries:

```bash
g++ GhostSec_Gift.cpp -o GhostSec_Gift -lssl -lcrypto -lzip
```

//  Setup

// Step 1: Generate or Load RSA Keys

// Initialize GhostSec Gift to generate RSA key pairs:

```bash
./GhostSec_Gift
```

// This creates a private key (`private_key.pem`) and a corresponding public key (`public_key.pem`) with a default key size of 4096 bits.

// Step 2: Encrypt a File with Fernet

// Encrypt files seamlessly with Fernet encryption:

```bash
./GhostSec_Gift
```

// Specify the input file path (`input.txt`), output file path (`encrypted.fernet`), and a dynamically generated Fernet key.

// Step 3: Encrypt the Fernet Key with RSA Public Key

// Secure the Fernet key by encrypting it with the RSA public key:

```bash
./GhostSec_Gift
```

// Load the RSA public key and generate the encrypted Fernet key file (`encrypted_fernet_key`).

// Step 4: Sign a File with RSA Private Key

// Digitally sign a file using the RSA private key:

```bash
./GhostSec_Gift
```

// This produces a signature file (`.sig`) for the specified input file (`input.txt`).

// Step 5: Verify Digital Signature

// Ensure the integrity of a file's digital signature using the RSA public key:

```bash
./GhostSec_Gift
```

// Step 6: Calculate Hash of Encrypted Fernet Key

// Compute the hash of the encrypted Fernet key file:

```bash
./GhostSec_Gift
```

// Step 7: Decrypt Fernet Key with RSA Private Key

// Decrypt the encrypted Fernet key using the RSA private key:

```bash
./GhostSec_Gift
```

// Step 8: Decrypt File with Decrypted Fernet Key

// Decrypt a file utilizing the decrypted Fernet key:

```bash
./GhostSec_Gift
```

//  Step 9: Encrypt Multiple Files into a Single Archive

// Effortlessly encrypt multiple files into a single archive:

```bash
./GhostSec_Gift
```

// Specify input files (`file1.txt`, `file2.txt`), the output archive (`multiple_files_archive.zip`), and an optional payload.

// Step 10: Decrypt Single Archive Containing Multiple Files

// Decrypt a single archive housing multiple files:

```bash
./GhostSec_Gift
```

// Step 11: Bind EXE to Media

// Bind an executable to a media file for a seamless integration:

```bash
./GhostSec_Gift
```

// Specify the input media (`media.mp4`), the executable (`your_program.exe`), and the output media with the embedded executable (`media_with_exe.mp4`).

// Step 12: Extract EXE from Bound Media

// Uncover the embedded executable from media with a bound executable:

```bash
./GhostSec_Gift
```

// Specify the input media with the embedded executable (`media_with_exe.mp4`) and the output executable (`extracted_program.exe`).

// Important Considerations

// - Verify proper file permissions for read and write access.
// - Replace placeholder filenames and passphrases with actual values.
// - Exercise caution when binding an EXE to media, as it may impact the media file.

// Troubleshooting

// - Confirm OpenSSL and libzip library versions.
// - Ensure the availability of required header files.

// GhostSec Gift is your all-in-one solution for cryptographic and file manipulation needs. Tailor its usage to meet specific use cases and adhere to stringent security requirements. Happy encrypting!

cpp
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/fernet.h>
#include <openssl/sha.h>
#include <openssl/rand.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
#include <openssl/md5.h>
#include <openssl/err.h>
#include <zip.h>

using namespace std;

// Generate or load RSA keys
pair<RSA*, RSA*> generate_rsa_keypair(int key_size = 4096) {
    RSA *private_key = RSA_generate_key(key_size, RSA_F4, nullptr, nullptr);
    RSA *public_key = RSAPublicKey_dup(private_key);
    return make_pair(private_key, public_key);
}

void save_rsa_key(RSA *key, const char *filename, const char *passphrase = nullptr) {
    BIO *bio = BIO_new_file(filename, "wb");
    if (bio) {
        if (passphrase) {
            EVP_PKEY *evp_key = EVP_PKEY_new();
            EVP_PKEY_set1_RSA(evp_key, key);
            PEM_write_bio_PKCS8PrivateKey(bio, evp_key, EVP_aes_256_cbc(), nullptr, 0, nullptr, passphrase);
            EVP_PKEY_free(evp_key);
        } else {
            PEM_write_bio_RSAPrivateKey(bio, key, nullptr, nullptr, 0, nullptr, nullptr);
        }
        BIO_free(bio);
    }
}

RSA* load_rsa_key(const char *filename, const char *passphrase = nullptr) {
    RSA *key = nullptr;
    BIO *bio = BIO_new_file(filename, "rb");
    if (bio) {
        if (passphrase) {
            key = PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, const_cast<char*>(passphrase));
        } else {
            key = PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, nullptr);
        }
        BIO_free(bio);
    }
    return key;
}

// Encrypt a file using Fernet symmetric encryption
void encrypt_file(const char *file_path, const char *output_path, const string &fernet_key) {
    FILE *file = fopen(file_path, "rb");
    FILE *output_file = fopen(output_path, "wb");

    if (file && output_file) {
        FERNET_CTX *ctx = FERNET_init(fernet_key.c_str());
        if (ctx) {
            FERNET_encrypt_file(ctx, file, output_file);
            FERNET_cleanup(ctx);
        }

        fclose(file);
        fclose(output_file);
    }
}

// Decrypt a file using Fernet symmetric encryption
void decrypt_file(const char *file_path, const char *output_path, const string &fernet_key) {
    FILE *file = fopen(file_path, "rb");
    FILE *output_file = fopen(output_path, "wb");

    if (file && output_file) {
        FERNET_CTX *ctx = FERNET_init(fernet_key.c_str());
        if (ctx) {
            FERNET_decrypt_file(ctx, file, output_file);
            FERNET_cleanup(ctx);
        }

        fclose(file);
        fclose(output_file);
    }
}

// Sign a file with the RSA private key
void sign_file(const char *file_path, RSA *private_key) {
    FILE *file = fopen(file_path, "rb");
    if (file) {
        fseek(file, 0, SEEK_END);
        long file_size = ftell(file);
        fseek(file, 0, SEEK_SET);

        unsigned char *data = (unsigned char *)malloc(file_size);
        fread(data, 1, file_size, file);
        fclose(file);

        unsigned char *signature = (unsigned char *)malloc(RSA_size(private_key));

        unsigned int signature_len;
        if (RSA_sign(NID_sha256, data, file_size, signature, &signature_len, private_key) == 1) {
            FILE *signature_file = fopen((string(file_path) + ".sig").c_str(), "wb");
            if (signature_file) {
                fwrite(signature, 1, signature_len, signature_file);
                fclose(signature_file);
            }
        }

        free(data);
        free(signature);
    }
}

// Verify the digital signature of a file
bool verify_signature(const char *file_path, RSA *public_key) {
    FILE *file = fopen(file_path, "rb");
    if (file) {
        fseek(file, 0, SEEK_END);
        long file_size = ftell(file);
        fseek(file, 0, SEEK_SET);

        unsigned char *data = (unsigned char *)malloc(file_size);
        fread(data, 1, file_size, file);
        fclose(file);

        FILE *signature_file = fopen((string(file_path) + ".sig").c_str(), "rb");
        if (signature_file) {
            fseek(signature_file, 0, SEEK_END);
            long signature_size = ftell(signature_file);
            fseek(signature_file, 0, SEEK_SET);

            unsigned char *signature = (unsigned char *)malloc(signature_size);
            fread(signature, 1, signature_size, signature_file);
            fclose(signature_file);

            int result = RSA_verify(NID_sha256, data, file_size, signature, signature_size, public_key);

            free(data);
            free(signature);

            return result == 1;
        }
    }

    return false;
}

// Calculate the hash of a file
string calculate_hash(const char *file_path) {
    FILE *file = fopen(file_path, "rb");
    if (file) {
        SHA256_CTX sha256_ctx;
        SHA256_Init(&sha256_ctx);

        unsigned char buffer[65536];
        size_t bytes_read;

        while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
            SHA256_Update(&sha256_ctx, buffer, bytes_read);
        }

        unsigned char hash[SHA256_DIGEST_LENGTH];
        SHA256_Final(hash, &sha256_ctx);

        fclose(file);

        stringstream ss;
        for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
            ss << hex << setw(2) << setfill('0') << static_cast<int>(hash[i]);
        }

        return ss.str();
    }

    return "";
}

// Encrypt a Fernet key with RSA public key
string encrypt_fernet_key(const string &fernet_key, RSA *public_key) {
    size_t encrypted_key_len = RSA_size(public_key);
    unsigned char *encrypted_key = (unsigned char *)malloc(encrypted_key_len);

    int result = RSA_public_encrypt(fernet_key.size(), reinterpret_cast<const unsigned char *>(fernet_key.c_str()), encrypted_key, public_key, RSA_PKCS1_OAEP_PADDING);

    string result_str = "";
    if (result > 0) {
        result_str = string(reinterpret_cast<const char *>(encrypted_key), result);
    }

    free(encrypted_key);
    return result_str;
}

// Decrypt a Fernet key with RSA private key
string decrypt_fernet_key(const string &encrypted_key, RSA *private_key) {
    size_t decrypted_key_len = RSA_size(private_key);
    unsigned char *decrypted_key = (unsigned char *)malloc(decrypted_key_len);

    int result = RSA_private_decrypt(encrypted_key.size(), reinterpret_cast<const unsigned char *>(encrypted_key.c_str()), decrypted_key, private_key, RSA_PKCS1_OAEP_PADDING);

    string result_str = "";
    if (result > 0) {
        result_str = string(reinterpret_cast<const char *>(decrypted_key), result);
    }

    free(decrypted_key);
    return result_str;
}

// Encrypt multiple files into a single archive
void encrypt_multiple_files(const vector<string> &file_paths, const char *output_archive, const string &fernet_key, const char *payload = nullptr) {
    zip_t *archive = zip_open(output_archive, ZIP_CREATE | ZIP_TRUNCATE, nullptr);
    if (archive) {
        for (const auto &file_path : file_paths) {
            zip_source_t *source = zip_source_file(archive, file_path.c_str(), 0, 0);
            if (source) {
                zip_file_add(archive, file_path.c_str(), source, ZIP_FL_OVERWRITE);
            }
        }

        if (payload) {
            zip_source_t *payload_source = zip_source_buffer(archive, payload, strlen(payload), 0);
            if (payload_source) {
                zip_file_add(archive, "payload.txt", payload_source, ZIP_FL_OVERWRITE);
            }
        }

        zip_close(archive);
        encrypt_file(output_archive, (string(output_archive) + ".enc").c_str(), fernet_key.c_str());
        remove(output_archive);
    }
}

// Decrypt a single archive containing multiple files
void decrypt_multiple_files(const char *archive_path, const char *output_dir, const string &fernet_key) {
    decrypt_file(archive_path, (string(archive_path) + ".dec").c_str(), fernet_key.c_str());

    zip_t *archive = zip_open((string(archive_path) + ".dec").c_str(), 0, nullptr);
    if (archive) {
        for (zip_int64_t i = 0; i < zip_get_num_entries(archive, 0); ++i) {
            zip_stat_t stat;
            zip_stat_index(archive, i, 0, &stat);

            zip_file_t *file = zip_fopen_index(archive, i, 0);
            if (file) {
                string output_path = string(output_dir) + "/" + stat.name;
                FILE *output_file = fopen(output_path.c_str(), "wb");

                if (output_file) {
                    char buffer[65536];
                    zip_fread(file, buffer, sizeof(buffer));
                    fwrite(buffer, 1, zip_fread(file, buffer, sizeof(buffer)), output_file);
                    fclose(output_file);
                }

                zip_fclose(file);
            }
        }

        zip_close(archive);
        remove((string(archive_path) + ".dec").c_str());
    }
}

// Function to bind an EXE to media
void bind_exe_to_media(const char *media_file, const char *exe_file, const char *output_media_file) {
    FILE *media = fopen(media_file, "rb");
    FILE *exe = fopen(exe_file, "rb");
    FILE *output_media = fopen(output_media_file, "wb");

    if (media && exe && output_media) {
        fseek(media, 0, SEEK_END);
        long media_size = ftell(media);
        fseek(media, 0, SEEK_SET);

        fseek(exe, 0, SEEK_END);
        long exe_size = ftell(exe);
        fseek(exe, 0, SEEK_SET);

        unsigned char *media_data = (unsigned char *)malloc(media_size);
        fread(media_data, 1, media_size, media);

        unsigned char *exe_data = (unsigned char *)malloc(exe_size);
        fread(exe_data, 1, exe_size, exe);

        fwrite(media_data, 1, media_size, output_media);
        fwrite(exe_data, 1, exe_size, output_media);

        free(media_data);
        free(exe_data);

        fclose(media);
        fclose(exe);
        fclose(output_media);
    }
}

// Function to extract the EXE from bound media
void extract_exe_from_media(const char *bound_media_file, const char *output_exe_file) {
    FILE *media = fopen(bound_media_file, "rb");
    FILE *output_exe = fopen(output_exe_file, "wb");

    if (media && output_exe) {
        fseek(media, 0, SEEK_END);
        long media_size = ftell(media);
        fseek(media, 0, SEEK_SET);

        unsigned char *media_data = (unsigned char *)malloc(media_size);
        fread(media_data, 1, media_size, media);

        const char *exe_magic_header = "MZ";
        const char *exe_start = strstr(reinterpret_cast<const char *>(media_data), exe_magic_header);

        if (exe_start) {
            fwrite(exe_start, 1, media_size - (exe_start - reinterpret_cast<const char *>(media_data)), output_exe);
        } else {
            cout << "No EXE data found in the bound media." << endl;
        }

        free(media_data);
        fclose(media);
        fclose(output_exe);
    }
}

// Main function
int main() {
    try {
        // Step 1: Generate or load RSA keys
        auto[key_private, key_public] = generate_rsa_keypair();
        save_rsa_key(key_private, "private_key.pem", "Passphrase123");  // Replace passphrase
        save_rsa_key(key_public, "public_key.pem");

        // Step 2: Encrypt a file with Fernet
        string fernet_key = FERNET_generate_key();
        encrypt_file("input.txt", "encrypted.fernet", fernet_key);

        // Step 3: Encrypt the Fernet key with the RSA public key
        key_public = load_rsa_key("public_key.pem");
        string encrypted_fernet_key = encrypt_fernet_key(fernet_key, key_public);

        ofstream fernet_key_file("encrypted_fernet_key", ios::binary);
        fernet_key_file.write(encrypted_fernet_key.c_str(), encrypted_fernet_key.size());
        fernet_key_file.close();

        // Step 4: Sign the file with the RSA private key
        sign_file("input.txt", key_private);

        // Step 5: Verify the digital signature of the file
        bool verified = verify_signature("input.txt", key_public);
        if (verified) {
            cout << "Digital signature is valid." << endl;
        } else {
            cout << "Digital signature is invalid or missing." << endl;
        }

        // Step 6: Calculate the hash of the encrypted Fernet key
        string encrypted_fernet_key_hash = calculate_hash("encrypted_fernet_key");
        cout << "Hash of the encrypted Fernet key: " << encrypted_fernet_key_hash << endl;

        // Step 7: Decrypt the Fernet key with the RSA private key
        ifstream encrypted_fernet_key_file("encrypted_fernet_key", ios::binary);
        stringstream encrypted_fernet_key_stream;
        encrypted_fernet_key_stream << encrypted_fernet_key_file.rdbuf();
        encrypted_fernet_key_file.close();

        key_private = load_rsa_key("private_key.pem", "Passphrase123");  // Replace passphrase
        string```cpp
        encrypted_fernet_key = decrypt_fernet_key(encrypted_fernet_key_stream.str(), key_private);

        // Step 8: Decrypt the file with the decrypted Fernet key
        decrypt_file("encrypted.fernet", "decrypted.txt", encrypted_fernet_key);
        cout << "File encrypted and decrypted successfully." << endl;

        // Step 9: Encrypt multiple files into a single archive
        vector<string> file_paths_to_encrypt = {"file1.txt", "file2.txt"};
        const char *output_archive = "multiple_files_archive.zip";
        const char *payload = "This is a payload text that will be injected into the archive.";  // Replace with your payload
        encrypt_multiple_files(file_paths_to_encrypt, output_archive, encrypted_fernet_key, payload);

        // Step 10: Decrypt a single archive containing multiple files
        const char *output_dir = "decrypted_files";
        decrypt_multiple_files(output_archive, output_dir, encrypted_fernet_key);
        cout << "Multiple files encrypted and decrypted successfully." << endl;

        // Step 11: Bind an EXE to a media file
        bind_exe_to_media("media.mp4", "your_program.exe", "media_with_exe.mp4");

        // Step 12: Extract the EXE from the bound media
        extract_exe_from_media("media_with_exe.mp4", "extracted_program.exe");

        cout << "EXE bound to media and extracted successfully." << endl;
    } catch (const exception &e) {
        cerr << "An error occurred: " << e.what() << endl;
    }

    return 0;
}