Piped Console

1
#include <iostream>
2
#include <stdexcept>
3
#include <string>
4

5
#include <windows.h>
6
#include <fmt/core.h>
7

8
#include "piped_console/piped_console.hpp"
9

10
int main() {
11
    SetConsoleTitleA("Emitter");
12

13
    try {
14
        piped_console::Configuration config{ "\\\\.\\pipe\\piped_console" };
15
        piped_console::Emitter emitter(config);
16

17
        fmt::println("[+] Connected to console");
18

19
        while (true) {
20
            fmt::print("Message: ");
21
            std::string message{};
22
            std::getline(std::cin, message);
23
            emitter.sendMessage(message);
24
        }
25
    } catch (const std::runtime_error& e) {
26
        MessageBoxA(nullptr, e.what(), "Error", MB_OK);
27
        return 1;
28
    }
29
}

1
#include <chrono>
2
#include <thread>
3

4
#include <windows.h>
5
#include <fmt/core.h>
6
#include <piped_console/piped_console.hpp>
7
#include <winuser.h>
8

9
int main() {
10
    SetConsoleTitleA("Console");
11

12
    try {
13
        piped_console::Configuration config{ "\\\\.\\pipe\\piped_console" };
14
        piped_console::Listener listener(config);
15

16
        while (true) {
17
            fmt::println("[+] Waiting for client connection...");
18

19
            if (listener.connectToNamedPipe()) {
20
                fmt::println("[+] Client connected");
21

22
                while (listener.isConnected()) {
23
                    const auto message = listener.getMessage();
24
                    if (!message || message.value().empty()) {
25
                        break;
26
                    }
27

28
                    fmt::println("[message] {}", message.value());
29
                }
30

31
                fmt::println("[?] Client disconnected");
32
                listener.disconnectFromNamedPipe();
33

34
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
35
            } else {
36
                fmt::println("[!] Failed to connect to client");
37
                std::this_thread::sleep_for(std::chrono::seconds(1));
38
            }
39
        }
40
    } catch (const std::exception& e) {
41
        MessageBoxA(nullptr, e.what(), "Error", MB_OK);
42
        return 1;
43
    }
44
}

1
#include <chrono>
2
#include <cstdint>
3
#include <cstdlib>
4
#include <thread>
5

6
#include <windows.h>
7
#include <fmt/core.h>
8
#include <libloaderapi.h>
9
#include <piped_console/piped_console.hpp>
10
#include <winuser.h>
11

12
uint32_t main_thread(HMODULE module_handle) {
13
    try {
14
        piped_console::Configuration config{ "\\\\.\\pipe\\piped_console" };
15
        piped_console::Emitter emitter(config);
16

17
        fmt::println("[+] Connected to console");
18

19
        while (!GetAsyncKeyState(VK_HOME)) {
20
            const auto message =
21
                std::format("Main module base address: 0x{:X}", reinterpret_cast<uintptr_t>(GetModuleHandle(nullptr)));
22
            emitter.sendMessage(message);
23

24
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
25
        }
26
    } catch (const std::runtime_error& e) {
27
        MessageBoxA(nullptr, e.what(), "Error", MB_OK);
28
    }
29

30
    FreeLibraryAndExitThread(module_handle, EXIT_SUCCESS);
31
}
32

33
BOOL WINAPI DllMain(HINSTANCE module_handle, DWORD call_reason, LPVOID) {
34
    if (call_reason != DLL_PROCESS_ATTACH) {
35
        return TRUE;
36
    }
37

38
    if (const auto handle = CreateThread(nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(main_thread),
39
                                         module_handle, 0, nullptr)) {
40
        CloseHandle(handle);
41
    }
42

43
    return TRUE;
44
}