├── .gitignore
├── README.md
├── ReadMe.txt
├── RunAsSystem.cpp
├── RunAsSystem.h
├── RunAsSystem.sln
├── RunAsSystem.vcproj
├── RunAsSystem.vcxproj
├── main.cpp
├── stdafx.cpp
├── stdafx.h
└── targetver.h


/.gitignore:
--------------------------------------------------------------------------------
 1 | Release
 2 | Debug
 3 | RunAsSystem.ncb
 4 | RunAsSystem.suo
 5 | RunAsSystem.vcproj.WIN-JNBDPQE2AJ8.Mixer.user
 6 | RunAsSystem.sln.old
 7 | RunAsSystem.suo.old
 8 | RunAsSystem.v12.suo
 9 | RunAsSystem.vcxproj
10 | RunAsSystem.vcxproj.user
11 | UpgradeLog.XML
12 | _UpgradeReport_Files/UpgradeReport.css
13 | _UpgradeReport_Files/UpgradeReport.xslt
14 | _UpgradeReport_Files/UpgradeReport_Minus.gif
15 | _UpgradeReport_Files/UpgradeReport_Plus.gif
16 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # RunAsSystem
2 | # RunAsSystem
3 | 


--------------------------------------------------------------------------------
/ReadMe.txt:
--------------------------------------------------------------------------------
 1 | ========================================================================
 2 |     CONSOLE APPLICATION : RunAsSystem Project Overview
 3 | ========================================================================
 4 | 
 5 | AppWizard has created this RunAsSystem application for you.
 6 | 
 7 | This file contains a summary of what you will find in each of the files that
 8 | make up your RunAsSystem application.
 9 | 
10 | 
11 | RunAsSystem.vcproj
12 |     This is the main project file for VC++ projects generated using an Application Wizard.
13 |     It contains information about the version of Visual C++ that generated the file, and
14 |     information about the platforms, configurations, and project features selected with the
15 |     Application Wizard.
16 | 
17 | RunAsSystem.cpp
18 |     This is the main application source file.
19 | 
20 | /////////////////////////////////////////////////////////////////////////////
21 | Other standard files:
22 | 
23 | StdAfx.h, StdAfx.cpp
24 |     These files are used to build a precompiled header (PCH) file
25 |     named RunAsSystem.pch and a precompiled types file named StdAfx.obj.
26 | 
27 | /////////////////////////////////////////////////////////////////////////////
28 | Other notes:
29 | 
30 | AppWizard uses "TODO:" comments to indicate parts of the source code you
31 | should add to or customize.
32 | 
33 | /////////////////////////////////////////////////////////////////////////////
34 | 


--------------------------------------------------------------------------------
/RunAsSystem.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // RunAsSystem - RunAsSystem.cpp - by Michael Badichi
  3 | 
  4 | 
  5 | #include <Windows.h>
  6 | #include <Ntsecapi.h>
  7 | #include <Psapi.h>
  8 | #include <UserEnv.h>
  9 | #include <LMCons.h>
 10 | #include <Shlwapi.h>
 11 | #include <string>
 12 | #include <vector>
 13 | #include <sstream>
 14 | #include <memory>
 15 | 
 16 | #pragma comment (lib, "advapi32")
 17 | #pragma comment (lib, "Psapi")
 18 | #pragma comment (lib, "UserEnv")
 19 | #pragma comment (lib, "Shlwapi")
 20 | 
 21 | template< typename T > std::wstring toString( const T& value )
 22 | {
 23 |     std::wstringstream oss;
 24 |     oss << value;
 25 |     return oss.str();
 26 | }
 27 | typedef std::auto_ptr< SID > SidPtr_t;
 28 | 
 29 | SidPtr_t _LookupAccountName( std::wstring sName, std::wstring sSystem )
 30 | {
 31 |     DWORD cbSid = 0;
 32 |     DWORD cbDomain = 0;
 33 |     SID_NAME_USE tSid;
 34 |     LookupAccountName( sSystem.c_str(), sName.c_str(), NULL, &cbSid, NULL, &cbDomain, &tSid );
 35 |     if( cbSid != 0 )
 36 |     {
 37 |         SID * pSid = (SID *)new char[ cbSid ];
 38 |         std::vector<WCHAR> domain( cbDomain );
 39 |         if( LookupAccountName( sSystem.c_str(), sName.c_str(), pSid, &cbSid, &domain[0], &cbDomain, &tSid ) )
 40 |         {
 41 |             return SidPtr_t( pSid );
 42 |         }
 43 |     }
 44 | 
 45 |     return SidPtr_t(NULL);
 46 | }
 47 | 
 48 | LSA_HANDLE _LsaOpenPolicy( ACCESS_MASK iAccess )
 49 | {
 50 |     LSA_OBJECT_ATTRIBUTES lsaAttr = {0};
 51 |     LSA_HANDLE hPolicy;
 52 |     if( SUCCEEDED( LsaOpenPolicy( NULL, &lsaAttr, iAccess, &hPolicy ) ) )
 53 |     {
 54 |         return hPolicy;
 55 |     }
 56 |     return INVALID_HANDLE_VALUE;
 57 | }
 58 | 
 59 | bool _LsaAddAccountRights( std::wstring sName, std::wstring sRight )
 60 | {
 61 |     bool retCode = false;
 62 |     std::wstring domain;
 63 |     SidPtr_t sid = _LookupAccountName( sName, L"" );
 64 |     SID * pSid = sid.get();
 65 |     if( IsValidSid( pSid ) )
 66 |     {
 67 |         LSA_HANDLE hPolicy = _LsaOpenPolicy( 0x811 );
 68 |         if( hPolicy != INVALID_HANDLE_VALUE )
 69 |         {
 70 |             int iLen = sRight.length() * 2;
 71 |             std::vector< WCHAR > tRight( iLen );
 72 |             wcscpy_s( &tRight[0], iLen, sRight.c_str() );
 73 |             LSA_UNICODE_STRING unicode;
 74 |             unicode.Length = iLen;
 75 |             unicode.MaximumLength = iLen + 2;
 76 |             unicode.Buffer = &tRight[0];
 77 |             if( SUCCEEDED( LsaAddAccountRights( hPolicy, pSid, &unicode, 1 ) ) )
 78 |             {
 79 |                 retCode = true;
 80 |             }
 81 |             LsaClose( hPolicy );
 82 |         }
 83 |         retCode = true;
 84 |     }
 85 |     return retCode;
 86 | }
 87 | 
 88 | bool _SetPrivilege( std::wstring Privilege )
 89 | {
 90 |     bool retCode = false;
 91 |     HANDLE curProc = GetCurrentProcess();
 92 |     HANDLE hToken;
 93 |     if( OpenProcessToken( curProc, TOKEN_ALL_ACCESS, &hToken ) )
 94 |     {
 95 |         TOKEN_PRIVILEGES tp;
 96 |         tp.PrivilegeCount = 1;
 97 |         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 98 |         LookupPrivilegeValue( L"", Privilege.c_str(), &tp.Privileges[0].Luid );
 99 |         TOKEN_PRIVILEGES tpout;
100 |         DWORD retLen = 0;
101 |         BOOL stat = AdjustTokenPrivileges( hToken, FALSE, &tp, sizeof(tpout), &tpout, &retLen );
102 |         DWORD lasterr = GetLastError();
103 |         if( lasterr  != 0)
104 |         {
105 |             //OutputDebugString( (std::wstring(L"AdjustTokenPrivilefes(")+Privilege+L") :"+toString(lasterr)).c_str() );
106 |             if( lasterr == ERROR_NOT_ALL_ASSIGNED ) 
107 |             {
108 |                 WCHAR uname[ UNLEN+1 ];
109 |                 DWORD cbUname = sizeof( uname ) / sizeof( uname[0] );
110 |                 if( GetUserName( uname, &cbUname ) )
111 |                 {
112 |                     if( _LsaAddAccountRights( uname, Privilege ) )
113 |                     {
114 |                         OutputDebugString( (std::wstring(L"Reboot required for changes to take effect: ")+Privilege).c_str() );
115 |                         stat = TRUE;
116 |                     }
117 |                     else
118 |                     {
119 |                         OutputDebugString( (std::wstring(L"Error: The right was probably not added correctly to your account: ")+Privilege).c_str() );
120 |                         stat = FALSE;
121 |                     }
122 |                 }
123 |             }
124 |         }
125 |         CloseHandle( hToken );
126 |         retCode = ( stat == TRUE );
127 |     }
128 |     return retCode;
129 | }
130 | 
131 | bool IsProcessIdMatchingName( DWORD processID, std::wstring name )
132 | {
133 |     bool retCode = false;
134 |     WCHAR szProcessName[ MAX_PATH ] = L"<unknown>";
135 |     HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID );
136 |     if ( hProcess )
137 |     {
138 |         WCHAR path[ MAX_PATH + FILENAME_MAX + 1];
139 |         if( GetProcessImageFileName( hProcess, path, sizeof( path ) / sizeof( path[0] ) ) )
140 |         {
141 |             WCHAR * fname = StrRChr( path, NULL, L'\\' );
142 |             if( fname )
143 |             {
144 |                 fname++;
145 |                 //OutputDebugString( (std::wstring(L"Testing process name ")+fname).c_str() );
146 |                 retCode = ( _wcsicmp( fname, name.c_str() ) == 0 );
147 |             }
148 |         }
149 |         CloseHandle( hProcess );
150 |     }
151 |     else
152 |     {
153 |         //OutputDebugString((std::wstring(L"Error opening process ID ")+toString(processID)).c_str());
154 |     }
155 |     return retCode;
156 | }
157 | 
158 | DWORD GetProcessIdByName( std::wstring name, DWORD sessionID )
159 | {
160 |     DWORD retCode = 0;
161 |     DWORD aProcesses[16*1024];
162 |     DWORD cbNeeded;
163 |     unsigned int i;
164 |     if ( EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
165 |     {
166 |         DWORD cProcesses = cbNeeded / sizeof(DWORD);
167 |         for ( i = 0; i < cProcesses; i++ )
168 |         {
169 |             if( aProcesses[i] != 0 )
170 |             {
171 |                 //OutputDebugString( (std::wstring(L"Testing process ID ")+toString(aProcesses[i])).c_str() );
172 |                 if( IsProcessIdMatchingName( aProcesses[i], name ) )
173 |                 {
174 |                     DWORD sesID = 0;
175 |                     if( ProcessIdToSessionId( aProcesses[i], &sesID ) )
176 |                     {
177 |                         if( sesID == sessionID )
178 |                         {
179 |                             //found it
180 |                             retCode = aProcesses[i];
181 |                             break;
182 |                         }
183 |                     }
184 |                 }
185 |             }
186 |         }
187 |     }
188 |     return retCode;
189 | }
190 | 
191 | VOID * _GetEnvironmentBlock( DWORD processID )
192 | {
193 |     VOID * retCode = NULL;
194 | 
195 | 	HANDLE hProc = OpenProcess( 0x02000000, FALSE, processID );
196 |     if( hProc )
197 |     {
198 |         HANDLE hToken;
199 |         if( OpenProcessToken( hProc, TOKEN_DUPLICATE | TOKEN_QUERY, &hToken ) )
200 |         {
201 |             if( CreateEnvironmentBlock( &retCode, hToken, TRUE ) )
202 |             {
203 |                 //yey
204 |             }
205 |             CloseHandle( hToken );
206 |         }
207 |         CloseHandle( hProc );
208 |     }
209 |     return retCode;
210 | }
211 | 
212 | 
213 | 
214 | bool RunAsSystem( const WCHAR * cmd_, const WCHAR * runFromDir_, DWORD * procDoneRetCode_ = NULL )
215 | {
216 | 	std::wstring cmd = cmd_ ? cmd_ : L"";
217 | 	std::wstring runFromDir = runFromDir_ ? runFromDir_ : L"";
218 |     bool retCode = false;
219 |     WCHAR * winlogon = L"winlogon.exe";
220 |     WCHAR * privileges[] = {
221 |         L"SeDebugPrivilege",
222 |         L"SeAssignPrimaryTokenPrivilege",
223 |         L"SeIncreaseQuotaPrivilege"
224 |     };
225 |     for( int i=0; i<sizeof(privileges)/sizeof(privileges[0]); i++ ) {
226 |         _SetPrivilege( privileges[i] );
227 |     }
228 |     DWORD sessionID = WTSGetActiveConsoleSessionId();
229 |     if( sessionID != 0xFFFFFFFF )
230 |     {
231 |         DWORD processId = GetProcessIdByName( winlogon, sessionID );
232 |         if( processId )
233 |         {
234 |             HANDLE hProc = OpenProcess( 0x001F0FFF, FALSE, processId );
235 |             if( hProc != NULL )
236 |             {
237 |                 HANDLE hToken;
238 |                 if( OpenProcessToken( hProc, TOKEN_DUPLICATE, &hToken ) )
239 |                 {
240 |                     HANDLE hDupToken;
241 |                     if( DuplicateTokenEx( hToken, 0x001F0FFF, NULL, SecurityIdentification, TokenPrimary, &hDupToken ) )
242 |                     {
243 |                         VOID * envBlock = _GetEnvironmentBlock( processId );
244 |                         DWORD createFlags = NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE;
245 |                         if( envBlock ) createFlags |= CREATE_UNICODE_ENVIRONMENT;
246 |                         STARTUPINFO si = {0};
247 |                         PROCESS_INFORMATION pi = {0};
248 |                         si.cb = sizeof( si );
249 |                         si.lpDesktop = L"winsta0\\default";
250 | 
251 |                         typedef BOOL (WINAPI *CreateProcessWithTokenW_proto) ( HANDLE hToken, DWORD dwLogonFlags, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );
252 |                         CreateProcessWithTokenW_proto CreateProcessWithTokenW_fn = NULL;
253 |                         HMODULE hMod = LoadLibrary( L"ADVAPI32.dll" );
254 |                         if( hMod ) 
255 |                         {
256 |                             CreateProcessWithTokenW_fn = (CreateProcessWithTokenW_proto)GetProcAddress( hMod, "CreateProcessWithTokenW" );
257 |                         }
258 | 
259 |                         if( CreateProcessWithTokenW_fn == NULL || !CreateProcessWithTokenW_fn( hDupToken, LOGON_WITH_PROFILE, NULL, (LPWSTR)cmd.c_str(), createFlags, envBlock, runFromDir.empty() ? NULL : runFromDir.c_str(), &si, &pi ) )
260 |                         {
261 |                             //failed crating with token, try create as user
262 |                             if( !CreateProcessAsUserW( hDupToken, NULL, (LPWSTR)cmd.c_str(), NULL, NULL, FALSE, createFlags, envBlock, runFromDir.empty() ? NULL : runFromDir.c_str(), &si, &pi ) )
263 |                             {
264 |                                 //failed calling as user
265 |                             }
266 |                             else
267 |                             {
268 |                                 retCode = true;
269 |                             }
270 |                         }
271 |                         else
272 |                         {
273 |                             retCode = true;
274 |                         }
275 | 
276 |                         if( retCode && procDoneRetCode_ != NULL ) 
277 |                         {
278 |                             WaitForSingleObject( pi.hProcess, INFINITE );
279 |                             GetExitCodeProcess( pi.hProcess, procDoneRetCode_ );
280 |                         }
281 | 
282 |                         if( hMod )
283 |                         {
284 |                             FreeLibrary( hMod );
285 |                         }
286 | 
287 |                         if( envBlock )
288 |                         {
289 |                             DestroyEnvironmentBlock( envBlock );
290 |                         }
291 |                         CloseHandle( hDupToken );
292 |                     }
293 |                     CloseHandle( hToken );
294 |                 }
295 | 				else
296 | 				{
297 | 					//error opening process token
298 | 					MessageBox( NULL, toString(GetLastError()).c_str(), L"biii",MB_OK );
299 | 				}
300 |                 CloseHandle( hProc );
301 |             }
302 |         }
303 |     }
304 | 	return retCode;
305 | }
306 | 


--------------------------------------------------------------------------------
/RunAsSystem.h:
--------------------------------------------------------------------------------
1 | 
2 | // RunAsSystem - main.h - by Michael Badichi
3 | 
4 | #pragma once
5 | #include <Windows.h>
6 | 
7 | bool RunAsSystem( const WCHAR * cmd, const WCHAR * runFromDir, DWORD * procDoneRetCode_ = NULL );
8 | 


--------------------------------------------------------------------------------
/RunAsSystem.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RunAsSystem", "RunAsSystem.vcxproj", "{6037894A-BAB5-45FA-8E6F-701375015B51}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|Win32 = Debug|Win32
 9 | 		Release|Win32 = Release|Win32
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{6037894A-BAB5-45FA-8E6F-701375015B51}.Debug|Win32.ActiveCfg = Debug|Win32
13 | 		{6037894A-BAB5-45FA-8E6F-701375015B51}.Debug|Win32.Build.0 = Debug|Win32
14 | 		{6037894A-BAB5-45FA-8E6F-701375015B51}.Release|Win32.ActiveCfg = Release|Win32
15 | 		{6037894A-BAB5-45FA-8E6F-701375015B51}.Release|Win32.Build.0 = Release|Win32
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/RunAsSystem.vcproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="Windows-1252"?>
  2 | <VisualStudioProject
  3 | 	ProjectType="Visual C++"
  4 | 	Version="9.00"
  5 | 	Name="RunAsSystem"
  6 | 	ProjectGUID="{6037894A-BAB5-45FA-8E6F-701375015B51}"
  7 | 	RootNamespace="RunAsSystem"
  8 | 	Keyword="Win32Proj"
  9 | 	TargetFrameworkVersion="196613"
 10 | 	>
 11 | 	<Platforms>
 12 | 		<Platform
 13 | 			Name="Win32"
 14 | 		/>
 15 | 	</Platforms>
 16 | 	<ToolFiles>
 17 | 	</ToolFiles>
 18 | 	<Configurations>
 19 | 		<Configuration
 20 | 			Name="Debug|Win32"
 21 | 			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
 22 | 			IntermediateDirectory="$(ConfigurationName)"
 23 | 			ConfigurationType="1"
 24 | 			CharacterSet="1"
 25 | 			>
 26 | 			<Tool
 27 | 				Name="VCPreBuildEventTool"
 28 | 			/>
 29 | 			<Tool
 30 | 				Name="VCCustomBuildTool"
 31 | 			/>
 32 | 			<Tool
 33 | 				Name="VCXMLDataGeneratorTool"
 34 | 			/>
 35 | 			<Tool
 36 | 				Name="VCWebServiceProxyGeneratorTool"
 37 | 			/>
 38 | 			<Tool
 39 | 				Name="VCMIDLTool"
 40 | 			/>
 41 | 			<Tool
 42 | 				Name="VCCLCompilerTool"
 43 | 				Optimization="0"
 44 | 				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
 45 | 				MinimalRebuild="true"
 46 | 				BasicRuntimeChecks="3"
 47 | 				RuntimeLibrary="3"
 48 | 				UsePrecompiledHeader="0"
 49 | 				WarningLevel="3"
 50 | 				DebugInformationFormat="4"
 51 | 			/>
 52 | 			<Tool
 53 | 				Name="VCManagedResourceCompilerTool"
 54 | 			/>
 55 | 			<Tool
 56 | 				Name="VCResourceCompilerTool"
 57 | 			/>
 58 | 			<Tool
 59 | 				Name="VCPreLinkEventTool"
 60 | 			/>
 61 | 			<Tool
 62 | 				Name="VCLinkerTool"
 63 | 				OutputFile="c:\$(ProjectName).exe"
 64 | 				LinkIncremental="2"
 65 | 				GenerateDebugInformation="true"
 66 | 				SubSystem="2"
 67 | 				TargetMachine="1"
 68 | 			/>
 69 | 			<Tool
 70 | 				Name="VCALinkTool"
 71 | 			/>
 72 | 			<Tool
 73 | 				Name="VCManifestTool"
 74 | 			/>
 75 | 			<Tool
 76 | 				Name="VCXDCMakeTool"
 77 | 			/>
 78 | 			<Tool
 79 | 				Name="VCBscMakeTool"
 80 | 			/>
 81 | 			<Tool
 82 | 				Name="VCFxCopTool"
 83 | 			/>
 84 | 			<Tool
 85 | 				Name="VCAppVerifierTool"
 86 | 			/>
 87 | 			<Tool
 88 | 				Name="VCPostBuildEventTool"
 89 | 			/>
 90 | 		</Configuration>
 91 | 		<Configuration
 92 | 			Name="Release|Win32"
 93 | 			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
 94 | 			IntermediateDirectory="$(ConfigurationName)"
 95 | 			ConfigurationType="1"
 96 | 			CharacterSet="1"
 97 | 			WholeProgramOptimization="1"
 98 | 			>
 99 | 			<Tool
100 | 				Name="VCPreBuildEventTool"
101 | 			/>
102 | 			<Tool
103 | 				Name="VCCustomBuildTool"
104 | 			/>
105 | 			<Tool
106 | 				Name="VCXMLDataGeneratorTool"
107 | 			/>
108 | 			<Tool
109 | 				Name="VCWebServiceProxyGeneratorTool"
110 | 			/>
111 | 			<Tool
112 | 				Name="VCMIDLTool"
113 | 			/>
114 | 			<Tool
115 | 				Name="VCCLCompilerTool"
116 | 				Optimization="2"
117 | 				EnableIntrinsicFunctions="true"
118 | 				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
119 | 				RuntimeLibrary="0"
120 | 				EnableFunctionLevelLinking="true"
121 | 				UsePrecompiledHeader="0"
122 | 				WarningLevel="3"
123 | 				DebugInformationFormat="3"
124 | 			/>
125 | 			<Tool
126 | 				Name="VCManagedResourceCompilerTool"
127 | 			/>
128 | 			<Tool
129 | 				Name="VCResourceCompilerTool"
130 | 			/>
131 | 			<Tool
132 | 				Name="VCPreLinkEventTool"
133 | 			/>
134 | 			<Tool
135 | 				Name="VCLinkerTool"
136 | 				OutputFile="c:\$(ProjectName).exe"
137 | 				LinkIncremental="1"
138 | 				GenerateDebugInformation="true"
139 | 				SubSystem="2"
140 | 				OptimizeReferences="2"
141 | 				EnableCOMDATFolding="2"
142 | 				TargetMachine="1"
143 | 			/>
144 | 			<Tool
145 | 				Name="VCALinkTool"
146 | 			/>
147 | 			<Tool
148 | 				Name="VCManifestTool"
149 | 			/>
150 | 			<Tool
151 | 				Name="VCXDCMakeTool"
152 | 			/>
153 | 			<Tool
154 | 				Name="VCBscMakeTool"
155 | 			/>
156 | 			<Tool
157 | 				Name="VCFxCopTool"
158 | 			/>
159 | 			<Tool
160 | 				Name="VCAppVerifierTool"
161 | 			/>
162 | 			<Tool
163 | 				Name="VCPostBuildEventTool"
164 | 			/>
165 | 		</Configuration>
166 | 	</Configurations>
167 | 	<References>
168 | 	</References>
169 | 	<Files>
170 | 		<Filter
171 | 			Name="Source Files"
172 | 			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
173 | 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
174 | 			>
175 | 			<File
176 | 				RelativePath=".\main.cpp"
177 | 				>
178 | 			</File>
179 | 			<File
180 | 				RelativePath=".\RunAsSystem.cpp"
181 | 				>
182 | 			</File>
183 | 			<File
184 | 				RelativePath=".\stdafx.cpp"
185 | 				>
186 | 			</File>
187 | 		</Filter>
188 | 		<Filter
189 | 			Name="Header Files"
190 | 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
191 | 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
192 | 			>
193 | 			<File
194 | 				RelativePath=".\RunAsSystem.h"
195 | 				>
196 | 			</File>
197 | 			<File
198 | 				RelativePath=".\stdafx.h"
199 | 				>
200 | 			</File>
201 | 			<File
202 | 				RelativePath=".\targetver.h"
203 | 				>
204 | 			</File>
205 | 		</Filter>
206 | 		<Filter
207 | 			Name="Resource Files"
208 | 			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
209 | 			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
210 | 			>
211 | 		</Filter>
212 | 		<File
213 | 			RelativePath=".\ReadMe.txt"
214 | 			>
215 | 		</File>
216 | 	</Files>
217 | 	<Globals>
218 | 	</Globals>
219 | </VisualStudioProject>
220 | 


--------------------------------------------------------------------------------
/RunAsSystem.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="4.0" 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 |   </ItemGroup>
 13 |   <PropertyGroup Label="Globals">
 14 |     <ProjectGuid>{6037894A-BAB5-45FA-8E6F-701375015B51}</ProjectGuid>
 15 |     <RootNamespace>RunAsSystem</RootNamespace>
 16 |     <Keyword>Win32Proj</Keyword>
 17 |   </PropertyGroup>
 18 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 19 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 20 |     <ConfigurationType>Application</ConfigurationType>
 21 |     <CharacterSet>Unicode</CharacterSet>
 22 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 23 |   </PropertyGroup>
 24 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 25 |     <ConfigurationType>Application</ConfigurationType>
 26 |     <CharacterSet>Unicode</CharacterSet>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 29 |   <ImportGroup Label="ExtensionSettings">
 30 |   </ImportGroup>
 31 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
 32 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 33 |   </ImportGroup>
 34 |   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
 35 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 36 |   </ImportGroup>
 37 |   <PropertyGroup Label="UserMacros" />
 38 |   <PropertyGroup>
 39 |     <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
 40 |     <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
 41 |     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>
 42 |     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
 43 |     <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
 44 |     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>
 45 |     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
 46 |   </PropertyGroup>
 47 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 48 |     <ClCompile>
 49 |       <Optimization>Disabled</Optimization>
 50 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 51 |       <MinimalRebuild>true</MinimalRebuild>
 52 |       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
 53 |       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
 54 |       <PrecompiledHeader>
 55 |       </PrecompiledHeader>
 56 |       <WarningLevel>Level3</WarningLevel>
 57 |       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
 58 |     </ClCompile>
 59 |     <Link>
 60 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 61 |       <SubSystem>Console</SubSystem>
 62 |       <TargetMachine>MachineX86</TargetMachine>
 63 |     </Link>
 64 |     <PostBuildEvent>
 65 |       <Command>
 66 |       </Command>
 67 |     </PostBuildEvent>
 68 |   </ItemDefinitionGroup>
 69 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 70 |     <ClCompile>
 71 |       <Optimization>MaxSpeed</Optimization>
 72 |       <IntrinsicFunctions>true</IntrinsicFunctions>
 73 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 74 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
 75 |       <FunctionLevelLinking>true</FunctionLevelLinking>
 76 |       <PrecompiledHeader>
 77 |       </PrecompiledHeader>
 78 |       <WarningLevel>Level3</WarningLevel>
 79 |       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
 80 |     </ClCompile>
 81 |     <Link>
 82 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 83 |       <SubSystem>Console</SubSystem>
 84 |       <OptimizeReferences>true</OptimizeReferences>
 85 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
 86 |       <TargetMachine>MachineX86</TargetMachine>
 87 |       <EntryPointSymbol>
 88 |       </EntryPointSymbol>
 89 |     </Link>
 90 |     <PostBuildEvent>
 91 |       <Command>
 92 |       </Command>
 93 |     </PostBuildEvent>
 94 |   </ItemDefinitionGroup>
 95 |   <ItemGroup>
 96 |     <ClCompile Include="main.cpp" />
 97 |     <ClCompile Include="RunAsSystem.cpp" />
 98 |     <ClCompile Include="stdafx.cpp" />
 99 |   </ItemGroup>
100 |   <ItemGroup>
101 |     <ClInclude Include="RunAsSystem.h" />
102 |     <ClInclude Include="stdafx.h" />
103 |     <ClInclude Include="targetver.h" />
104 |   </ItemGroup>
105 |   <ItemGroup>
106 |     <None Include="ReadMe.txt" />
107 |   </ItemGroup>
108 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
109 |   <ImportGroup Label="ExtensionTargets">
110 |   </ImportGroup>
111 | </Project>


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | // RunAsSystem - main.cpp - by Michael Badichi
 3 | 
 4 | #include "stdafx.h"
 5 | #include "RunAsSystem.h"
 6 | 
 7 | #include <sstream>
 8 | #include <string>
 9 | #include <vector>
10 | #include <stdlib.h>
11 | 
12 | #define DLOG 0
13 | 
14 | #define SSTR( x ) dynamic_cast< std::wostringstream & >( ( std::wostringstream() << std::dec << x ) ).str()
15 | 
16 | #pragma warning (disable:4996)
17 | 
18 | std::wstring AsWideString( const std::string& s )
19 | {
20 |     size_t mbSize = s.size() + 1;
21 |     size_t wcSize = mbstowcs( 0, s.c_str(), mbSize ) + 1;
22 |     std::vector< wchar_t > w( wcSize, 0 );
23 |     mbstowcs( &w[0], s.c_str(), mbSize );
24 |     return std::wstring( &w[0] );
25 | }
26 | 
27 | int __stdcall WinMain( __in HINSTANCE hInstance, __in_opt HINSTANCE hPrevInstance, __in_opt LPSTR lpCmdLine, __in int nShowCmd )
28 | {
29 |     DWORD retCode = 0;
30 |     //skip whitespace
31 |     while( lpCmdLine[0]==' ') lpCmdLine++;
32 |     if( strlen( lpCmdLine ) == 0 )
33 |     {
34 |         MessageBox( NULL, L"usage: RunAsSystem  [--block] <cmdline>", L"RunAsSystem", MB_OK );
35 |         MessageBeep( MB_ICONWARNING );
36 |     }
37 |     else
38 |     {
39 |         DWORD * pRetcode = NULL;
40 |         if( strstr( lpCmdLine, "--block" ) == lpCmdLine ) {
41 |             lpCmdLine += 8;
42 |             pRetcode = &retCode;
43 |             while( lpCmdLine[0]==' ') lpCmdLine++;
44 |         }
45 | 
46 |         std::wstring cmd = AsWideString( std::string( lpCmdLine ) );
47 |         const WCHAR * runFromDir = NULL;    //can be empty - in which case - use my dir
48 | 
49 |         bool ok = RunAsSystem( cmd.c_str(), runFromDir, pRetcode ); //if we dont provide retCode pointer, function dont wait for process to finish
50 | 
51 | #if DLOG
52 |         std::wstring log = L"RunAsSystem --> '";
53 |         log += cmd;
54 |         log += L"' --> ";
55 |         log += (ok ? L"ok" : L"FAIL" );
56 |         if( ok ) 
57 |         {
58 |             log += SSTR( " ==> " << retCode );
59 |         }
60 |         OutputDebugString( log.c_str() );
61 | #endif
62 |     }
63 |     return (int)retCode;
64 | }
65 | 
66 | #ifdef _CONSOLE
67 | 
68 | int main( int argc, char ** argv ) 
69 | {
70 |     HINSTANCE hInstance = GetModuleHandle(NULL);
71 |     LPSTR lpCmdLine = GetCommandLineA();
72 |     LPSTR pCmdLine = lpCmdLine;
73 |     if( *pCmdLine == '"' ) {
74 |         char * p = strstr( pCmdLine+1, "\"" );
75 |         if( p ) {
76 |             p++;
77 |             while( *p == ' ' ) p++;
78 |             pCmdLine = p;
79 |         }
80 |     } 
81 |     else 
82 |     {
83 |         while( char * p = strstr( pCmdLine, " " ) ) {
84 |             if( p > pCmdLine && *(p-1) != '\\' ) {
85 |                 pCmdLine = p+1;
86 |                 break;
87 |             }
88 |             pCmdLine = p+1;
89 |         }
90 |     }
91 |     if( pCmdLine == lpCmdLine ) pCmdLine = "";
92 |     return WinMain( hInstance, NULL, pCmdLine, SW_SHOWNORMAL );
93 | }
94 | 
95 | #endif
96 | 


--------------------------------------------------------------------------------
/stdafx.cpp:
--------------------------------------------------------------------------------
1 | // stdafx.cpp : source file that includes just the standard includes
2 | // RunAsSystem.pch will be the pre-compiled header
3 | // stdafx.obj will contain the pre-compiled type information
4 | 
5 | #include "stdafx.h"
6 | 
7 | // TODO: reference any additional headers you need in STDAFX.H
8 | // and not in this file
9 | 


--------------------------------------------------------------------------------
/stdafx.h:
--------------------------------------------------------------------------------
 1 | // stdafx.h : include file for standard system include files,
 2 | // or project specific include files that are used frequently, but
 3 | // are changed infrequently
 4 | //
 5 | 
 6 | #pragma once
 7 | #define WIN32_LEAN_AND_MEAN
 8 | #include <Windows.h>
 9 | #include "targetver.h"
10 | 
11 | #include <stdio.h>
12 | #include <tchar.h>
13 | 
14 | 
15 | 
16 | // TODO: reference additional headers your program requires here
17 | 


--------------------------------------------------------------------------------
/targetver.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // The following macros define the minimum required platform.  The minimum required platform
 4 | // is the earliest version of Windows, Internet Explorer etc. that has the necessary features to run 
 5 | // your application.  The macros work by enabling all features available on platform versions up to and 
 6 | // including the version specified.
 7 | 
 8 | // Modify the following defines if you have to target a platform prior to the ones specified below.
 9 | // Refer to MSDN for the latest info on corresponding values for different platforms.
10 | #ifndef _WIN32_WINNT            // Specifies that the minimum required platform is Windows Vista.
11 | #define _WIN32_WINNT 0x0600     // Change this to the appropriate value to target other versions of Windows.
12 | #endif
13 | 
14 | 


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