Programm->adminrechte->CreateProcess->ohne adminrechte!

lippoliv

Naja ich habe irgendwo gelesen, dass ich dafür etwas erlauben muss wenn fehler 1314 (A required privilege is not held by the client.)kommt...

Ich muss das nochmal raussuchen, stand hier im Forum sogar...

[edit]ich merke gerade: http://www.c-plusplus.net/forum/viewtopic-var-t-is-106037-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-createprocessasuser-and-start-is-10.html hier hat er 11 Parameter für Logon...

retValue = 	CreateProcessWithLogonW(
						(LPCWSTR)"ADMIN",					//benutzer
						(LPCWSTR)".",						//domaine
						(LPCWSTR)"ADMIN",					//pw
						LOGON_WITH_PROFILE,					//flags
						NULL,								//program name
						(LPCWSTR)"SyD_Watch.exe",			//like system( "command" )
						NULL,			//creation flags
						NULL,							
						NULL,						//userProfilname
						&myStartInfo,						//startinformation
						&myProcessInfo						//prozessinformation
					);

das ist mein Code...^

SyD_Prog.c: In function `main':
SyD_Prog.c:56: warning: passing arg 6 of `CreateProcessWithLogonW' discards qual
ifiers from pointer target type
SyD_Prog.c:56: warning: passing arg 7 of `CreateProcessWithLogonW' makes integer
 from pointer without a cast
SyD_Prog.c:56: warning: passing arg 10 of `CreateProcessWithLogonW' from incompa
tible pointer type

das ist meine ausgabe^

Wenn ich bei den letztn 3 NULLs den ersten auf 0 setze ist die Ausgabe wie folgt:

SyD_Prog.c: In function `main':
SyD_Prog.c:56: warning: passing arg 6 of `CreateProcessWithLogonW' discards qual
ifiers from pointer target type
SyD_Prog.c:56: warning: passing arg 10 of `CreateProcessWithLogonW' from incompa
tible pointer type

Aber wieso mecker er noch?

yogle

Du solltest dich etwas besser an die entsprechenden Typen halten! Du verwendest die Wide-Version der Funktion (CreateProcessWithLogonW). Wenn da was von einem LPCWSTR steht nimmt man keinen Ansi-String und castet ihn auf LPCWSTR! Mach das so:

L"ladmin"

Das 'L' vor dem String sagt dem Compiler, dass es ein Wide-String ist, so wie es die Funktion verlangt. Genauso wie man für den Wert eines DWORD nicht NULL sondern 0 einsetzen sollte. Parameter 6 ist ein LPWSTR, also nicht const. Param 7 ist wie du auch schon herausgefunden hast ein DWORD also 0, nicht NULL. Und ich nehme an du hast für den Param 10 nicht die LPSTARTUPINFOW Struktur genommen, sondern die LPSTARTUPINFOA oder einfach LPSTARTUPINFO und kompilierst mit Ansi.

Martin Richter

Ist Dir eigentlich der Unterscheid zwiswchen einem char* und einem wchar_t* bekannt? Wenn nicht solltest Du das erstmal lernen, ansonsten brauchen wir hier nicht weiter zu machen.

Und bitte versuche mal zu verstehen was für ein Quatsch Deine Casts sind.

lippoliv

retValue = 	CreateProcessWithLogonW(
					L"ADMIN",					//benutzer
					(LPCWSTR)'.',						//domaine
					L"AMDIN",					//pw
					LOGON_WITH_PROFILE,					//flags
					NULL,								//program name
					L"SyD_Watch.exe",					//like system( "command" )
					0,									//creation flags
					NULL,							
					NULL,								//userProfilname
					&myStartInfoW,						//startinformation
					&myProcessInfo						//prozessinformation
				);

Jetzt läufts.

Ok also

yogle schrieb:

Du solltest dich etwas besser an die entsprechenden Typen halten!

Das versuche ich mit diesem (TYPECASTHERE) gedöns, so kenne ich das, da T"admin" nicht funktioniert hat...

yogle schrieb:

Du verwendest die Wide-Version der Funktion (CreateProcessWithLogonW).

^^dafür steht also das W.. Danke

yogle schrieb:

Wenn da was von einem LPCWSTR steht nimmt man keinen Ansi-String und castet ihn auf LPCWSTR! Mach das so:[...]

Danke, aber was nehm ich für arg 2?

yogle schrieb:

Und ich nehme an du hast für den Param 10 nicht die LPSTARTUPINFOW Struktur genommen, sondern die LPSTARTUPINFOA oder einfach LPSTARTUPINFO und kompilierst mit Ansi.

STARTUPINFO			myStartInfo;

So habe ich das bis jetzt immer gemacht, ist die STARTUPINFOW genau gleich?(scheint so compiler meckert nicht.)

Martin Richter schrieb:

Ist Dir eigentlich der Unterscheid zwiswchen einem char* und einem wchar_t* bekannt?

char* ist ein Pointer auf ein bereich im Speicher mit charactern.
wchar_t* ist auch ein pointer auf einen Speicherbereich allerdings mit wide-charactern, wobei ich nicht weiß was wide mit charactern zu tun hat, das _t kann ich dir nicht erklären, so kann ich darüber was lesen?

Dake für die Antworten

yogle

Okay schon besser, doch so ganz am Ziel der Erkenntnis sind wir noch nicht angelangt. Prinzipiell solltest du dir vornehmen, beim Funktionsparameters nicht zu casten.

lippoliv schrieb:

yogle schrieb:

Du solltest dich etwas besser an die entsprechenden Typen halten!

Das versuche ich mit diesem (TYPECASTHERE) gedöns, so kenne ich das, da T"admin" nicht funktioniert hat...

Versuch mal

TEXT("admin")

das sollte gehen. Für den Parameter 2 machst du es genauso wie bei 1 und 3. Er möchte da einen Wide-String (kein einzelner Character) also gibts du ihm das

L"."

Parameter 5 ist kein LPCWSTR! Das heißt du darfst ihm nicht solch einen String übergeben. Doku lesen:

MSDN schrieb:

lpCommandLine: The function can modify the contents of this string. Therefore, this parameter cannot be a pointer to read-only memory (such as a const variable or a literal string). If this parameter is a constant string, the function may cause an access violation.

Du musst einen String via malloc/new allokieren und der Funktion übergeben, damit sie ihn verändern kann.

typedef struct _STARTUPINFOA {
    DWORD   cb;
    LPSTR   lpReserved;
    LPSTR   lpDesktop;
    LPSTR   lpTitle;
    DWORD   dwX;
    DWORD   dwY;
    DWORD   dwXSize;
    DWORD   dwYSize;
    DWORD   dwXCountChars;
    DWORD   dwYCountChars;
    DWORD   dwFillAttribute;
    DWORD   dwFlags;
    WORD    wShowWindow;
    WORD    cbReserved2;
    LPBYTE  lpReserved2;
    HANDLE  hStdInput;
    HANDLE  hStdOutput;
    HANDLE  hStdError;
} STARTUPINFOA, *LPSTARTUPINFOA;
typedef struct _STARTUPINFOW {
    DWORD   cb;
    LPWSTR  lpReserved;
    LPWSTR  lpDesktop;
    LPWSTR  lpTitle;
    DWORD   dwX;
    DWORD   dwY;
    DWORD   dwXSize;
    DWORD   dwYSize;
    DWORD   dwXCountChars;
    DWORD   dwYCountChars;
    DWORD   dwFillAttribute;
    DWORD   dwFlags;
    WORD    wShowWindow;
    WORD    cbReserved2;
    LPBYTE  lpReserved2;
    HANDLE  hStdInput;
    HANDLE  hStdOutput;
    HANDLE  hStdError;
} STARTUPINFOW, *LPSTARTUPINFOW;
#ifdef UNICODE
typedef STARTUPINFOW STARTUPINFO;
typedef LPSTARTUPINFOW LPSTARTUPINFO;
#else
typedef STARTUPINFOA STARTUPINFO;
typedef LPSTARTUPINFOA LPSTARTUPINFO;
#endif // UNICODE

Es gibt für (fast) jede WinAPI Funktion eine Ansi und eine Wide Variante. Also entweder CreateProcessWithLogonW oder CreateProcessWithLogonA die Funktion CreateProcessWithLogon existiert so gar nicht, sondern ist nur ein Makro auf eine der beiden Funktionen. Der Compiler entscheidet dann welche er verwendet, abhängig ob du für Unicode (Wide) oder für Multi-Byte (Ansi/UTF) kompilierst. Das gleiche gilt für Strukturen die Strings enthalten (STARTUPINFO). Wenn du ihm vorgibst die Wide-Variante zu verwenden musst du ihm auch die passenden Parameter liefern.

lippoliv

Bist du Lehrer?
Super Beitrag hat viel erklärt.

Also ich habe mich jetzt rangesetzt und... naja eher probiert als gewusst;)

yogle schrieb:

Du musst einen String via malloc/new allokieren und der Funktion übergeben, damit sie ihn verändern kann.

Ich habe folgendes versucht:

main
//...
	WCHAR				*myCmdLine;
	myCmdLine = malloc( 512 );//wieso will er nur einen Parameter?

	strcpy( myCmdLine, "SyD_Watch.exe" );
	retValue = 	CreateProcessWithLogonW(
					L"ADMIN",					//benutzer
					L".",						//domaine
					L"ADMIN",					//pw
					LOGON_WITH_PROFILE,					//flags
					NULL,								//program name
					myCmdLine,					//like system( "command" )
					0,									//creation flags
					NULL,							
					NULL,								//userProfilname
					&myStartInfoW,						//startinformation
					&myProcessInfo						//prozessinformation
				);

das ging nicht... Strcpy will einen anderen Pointer...

main
//...
	char				*myCmdLine;
	myCmdLine = malloc( 512 );//wieso will er nur einen Parameter?

	strcpy( myCmdLine, "SyD_Watch.exe" );
	retValue = 	CreateProcessWithLogonW(
					L"ADMIN",					//benutzer
					L".",						//domaine
					L"ADMIN",					//pw
					LOGON_WITH_PROFILE,					//flags
					NULL,								//program name
					myCmdLine,					//like system( "command" )[ergiebt fehler: passing arg 6 of `CreateProcessWithLogonW' from incompatible pointer type]
					0,									//creation flags
					NULL,							
					NULL,								//userProfilname
					&myStartInfoW,						//startinformation
					&myProcessInfo						//prozessinformation
				);

^^dieser fehler ist Logisch weils ein Charpointer ist, auf den WCHAR kann aich aber nicht allocieren... oder mach ich da was falsch?

Danke schonmal

yogle

Danke, aber nein ich bin kein Lehrer.
Das was du versuchst ich fast richtig. strcpy ist zuerst einmal die Ansi-Variante, wcscpy wäre die Wide-Variante und _tcscpy die universale Methode, diese funktioniert aber nur für den Microsoft Visual C++ Compiler. Allerdings sollte man eher wcsncpy verwenden, um (mögliche) Buffer-Overflows zu vermeiden. malloc möchte als Parameter nur die Größe des zu allkoierenden Speicherbereiches und gibt dir einen void Pointer zurück. Den kann/darf man auf alle Typen casten!

// WCHAR ist nur ein typedef von wchar_t 
wchar_t *myCmdLine = NULL;    // Man sollte Variablen immer initialisieren

myCmdLine = (wchar_t*) malloc (512 * sizeof (wchar_t));

wcsncpy (myCmdLine, L"SyD_Watch.exe", 512);

So sollte es gehen. Du musst beachten, dass wenn du Wide-Strings verwendest, die Größe deines Speichers in Bytes nicht mehr der Größe/Länge deines Strings entspricht (im Gegensatz zur Ansi-Strings). Ein Wide-Zeichen benötigt nämlich 2 Bytes!

lippoliv

Danke dir, jetzt bekomme ich ein error 1305 "The revision level is unknown."...

Ich mach jetz feierabend, aber wer n Link hat wo sowas schonmal behandelt worden ist, oder wer eine Antwort weiß und lust hat diese zu Posten, feel free

Ich werde aber auf j eden fall noch mal selber suchen.

Popoklopfer

Wechsel mal Compiler

lippoliv

Hehe... ich muss euch was gestehen.
Der Fehler 1305 liegt nicht bei CreateProcessWithLogonW sondern bei dem darauffolgenden CreateProcess

//code
	STARTUPINFO 		myStartInfo;
	SECURITY_ATTRIBUTES mySec;
		//irgendwas
		ZeroMemory( &myProcessInfo, sizeof(PROCESS_INFORMATION) );
		ZeroMemory( &myStartInfo, sizeof(STARTUPINFO) );
		myStartInfo.cb = sizeof(STARTUPINFO);

		retValue = 	CreateProcess(
						NULL,			//program name
						"SyD_Mail.exe oliver@sonstwas.de",		//like system( "command" )
						&mySec,			//process security attributes
						NULL,			//primary thread security attributes
						FALSE,			//inherited handles
						0,				//creation flags
						NULL,			//use parents enviroments
						NULL,			//use parents current direction
						&myStartInfo,
						&myProcessInfo
					);
//code

[edit]Wieso denn das? Ich habe das schon das ein-oder-andere mal angewandt...

[edit2]funktioniert, musste das Security_Attribute nicht mitübergeben...

Jochen Kalmbach

Der zweite Parameter muss beschreibbar sein und darf kein String-Literal sein...
Auch musst Du bei "SECURITY_ATTRIBUTES" die "nLength" korrekt setzen und der Rest auf NULL (bzw. es ganz weglassen!)!

lippoliv

Siehe edit2... Danke trotzdem...

Kann mir wer sagen warum mein Programm (trotz erfolg von CreateWithLogon...) keine Adminrechte hat?

int main( void )
{
	PROCESS_INFORMATION	myProcessInfo;
	STARTUPINFOW		myStartInfoW;
	STARTUPINFO 		myStartInfo;
	BOOL				retValue;
	wchar_t				*myCmdLine = NULL;
	char buff[5];

	myCmdLine = (wchar_t*)malloc( 512 * sizeof(wchar_t) );

	wcsncpy( myCmdLine, L"SyD_Watch.exe", 512 );

	ZeroMemory( &myProcessInfo, sizeof(PROCESS_INFORMATION) );
	ZeroMemory( &myStartInfoW, sizeof(STARTUPINFOW) );

	retValue = 	CreateProcessWithLogonW(
					L"ADMIN",					//benutzer
					L".",						//domaine
					L"ADMIN",					//pw
					LOGON_WITH_PROFILE,			//flags
					NULL,						//program name
					myCmdLine,					//like system( "command" )
					0,							//creation flags
					NULL,							
					NULL,						//userProfilname
					&myStartInfoW,				//startinformation
					&myProcessInfo				//prozessinformation
				);
}

lippoliv

Ich muss meine aussage revidieren(schreibt sich das so?)

Ich sehe im Taskmanager das SyD_Watch von ADMIN ausgeführt wird, aber ich habe trotzdem keine Adminrechte... Wie kommt das?

Jochen Kalmbach

Vista?

lippoliv

Ja.... Verdammt nicht schon wieder...

WIESO IST VISTA SO GEIL UND TROTZDEM SONE KATASTROPHE?

Mir platzt gleich der Kopf... Das ist ein endloses gefrikel mit admin nich admin usw...

Liegt das echt an Vista?

Jochen Kalmbach

Wenn Du in Vista ein Admin bist, hast Du keine Adminrechte Du musst den Prozess "elevated" starten

Frag mich jetzt aber bitte nicht wie das geht.. muss ich auch zuerst rausfinden....

Eine Erklärung wie das Windows selber macht ist hier:
http://msdn2.microsoft.com/en-us/library/bb756945.aspx

Wenn Du den Prozess mit "RunAs" als Command startest, wird auch automatisch der "UAC-Dialog" gezeigt und Du bist richtiger Admin.

Natürlich kann Deine EXE auch ein "requireAdministartor" im Manifest haben, dann wird es sofort unter dem Admin-Account ausgeführt, ohne dass Du was spezielles machen musst (aber nur mit ShellExecute!)!

lippoliv

Es sieht nach einem Lösungsweg aus!?

Kannst du etwas genauer werden bitte?

Es ist also möglich über ShellExecute einen Prozess wirklich mit Adminrechten zu Starten OHNE das der User eine eingabe machen muss?
Passwort und Benutzername können erstmal Statisch im Quellcode sein ist mir egal, aber es ist echt möglich ja?

Martin Richter

lippoliv schrieb:

Es ist also möglich über ShellExecute einen Prozess wirklich mit Adminrechten zu Starten OHNE das der User eine eingabe machen muss?
Passwort und Benutzername können erstmal Statisch im Quellcode sein ist mir egal, aber es ist echt möglich ja?

Es erfolgt kein Prompt, wenn der startende Prozess bereits elevated läuft.
Läuft der Prozess der den neuen Prozess als Admin starten will nicht elevated erfolgt immer der UAC Prompt. Und das ist gut so!

lippoliv

Gut sschon, ist sicher aber pass auf:
Ich habe einen Computer auf dem gibt es einen "Admin" acc. mit dem pw "admin"(Musterdaten).
Jetzt soll ich ein Programm schreiben das unter dem Useracc läuft was SMART ausliest.
Ich habe mich damit abgefunden erstmal eine Version zu erstellen bei der man das Prog als Admin startet. Der User soll davon nichts mitbekommen, er kennt das Adminpw nicht.

Also will ich (erstaml) fest in einen Quellcode Daten tippen, anhand derer ein Programm als Admin*(mit dessen rechten)* laufen soll.

Frage: Ist das möglich?

Sogut Vista auch ist, ich glaube nciht das dies machbar ist

Danke schonmal für die Antworten

Martin Richter

Mach es richtig:
- Schreib einen Service, der die Daten liest
- Schreib ein Programm, dass die daten aus dem Service abholt und darstellt.

Programm-&gt;adminrechte-&gt;CreateProcess-&gt;ohne adminrechte!

Programm->adminrechte->CreateProcess->ohne adminrechte!