VirtualProtectEx() schlägt immer fehl, wieso???

hallo, ich will eine keine Anwendung schreiben, bzw hab sie geschrieben( funktioniert nur net) mit der man per VirtualProtectEx() die protection-Flags im speicher neu setzen kann. ZIEL PAGE_GUARD auszuschalten.
hier mal der code:
Code:
/*******************************************************************************

    Author  : Tobias Stein
    Date    : 8th July '07
    Project : Kill PAGE_GUARD
    File    : KillPG.cpp
    Remark  : Many memory addresses will protected by PAGE_GUARD, if you want to
              manipulate or read an address, PAGE_GUARD cause an exception, so
              you got no access.
              This application should turn off the fucking PAGE_GUARD.

    All Rights Reserved!

*******************************************************************************/


//--- Includes -----------------------------------------------------------------

#include <windows.h>
#include <iostream>
#include <stdio.h>
    using namespace std;

//--- Globals ------------------------------------------------------------------

HWND hProcessWnd;
HANDLE hProcess;
DWORD dwProcessID;
DWORD dwSize;
SYSTEM_INFO si;
char szWndName[ 128 ];

//--- Prototypes ---------------------------------------------------------------

bool getProcessHandle( char * );
bool kickPAGE_GUARD( );

//--- Main ---------------------------------------------------------------------

int main( int argc, char* argv[] ) {

    SetConsoleTitle( "Kill the fucking PAGE_GUARD!" );
    system( " mode con COLS=54 LINES=40 " );

    cout << "\n"
         << "       *** Enter name of running window! ***         \n"
         << "=====================================================\n"
         << "\n"
         << " Windowname: ";

    cin.getline( szWndName, sizeof( szWndName ) );
    cout << "=====================================================\n"
         << "=====================================================\n\n\n";

    if( getProcessHandle( szWndName ) ) {

    memset( &si, 0, sizeof( SYSTEM_INFO ) );
    GetSystemInfo( &si );
    dwSize = (DWORD)( (DWORD)si.lpMinimumApplicationAddress + (DWORD)si.lpMaximumApplicationAddress );

    cout << "           *** Systeminfo of computer ***            \n"
         << "=====================================================\n"
         << "\n"
         << " Page size                   : " << si.dwPageSize << "\n"
         << " Minimum application address : 0x" << hex << si.lpMinimumApplicationAddress << "\n"
         << " Maximum application address : 0x" << hex << si.lpMaximumApplicationAddress << "\n"
         << "=====================================================\n"
         << "=====================================================\n"
         << "\n\n";

        if( kickPAGE_GUARD( ) ) {

            cout << "                  *** Success! ***                   \n"
                 << "=====================================================\n"
                 << "\n"
                 << " Now you got full access to all memory addresses!    \n"
                 << "=====================================================\n"
                 << "=====================================================\n"
                 << "\n\n";

            system( "PAUSE" );
            CloseHandle( hProcess );
            VirtualFree( si.lpMinimumApplicationAddress, dwSize, MEM_DECOMMIT );
        }
        else {

            printf( "\n Failure, couldn't turn off PAGE_GUARD!\n " );
            system( "PAUSE" );
            CloseHandle( hProcess );
            VirtualFree( si.lpMinimumApplicationAddress, dwSize, MEM_DECOMMIT );
            return 0;
        }
    }
    else {

        printf( "\n The window \"%s\" was not found!\n ", szWndName );
        system( "PAUSE" );
        CloseHandle( hProcess );
        VirtualFree( si.lpMinimumApplicationAddress, dwSize, MEM_DECOMMIT );
        return 0;
    }
    return 0;
}

//--- Definitions --------------------------------------------------------------

bool getProcessHandle( char *szWindowName ) {

    hProcessWnd = FindWindow( 0, szWindowName );

    if( !hProcessWnd ) {

        return false;
    }

    GetWindowThreadProcessId( hProcess, &dwProcessID );
    hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, dwProcessID );

    return true;
}

bool kickPAGE_GUARD( ) {

    if( ( VirtualProtectEx( hProcess,
                            si.lpMinimumApplicationAddress,
                            dwSize,
                            PAGE_READWRITE | PAGE_EXECUTE_READWRITE,
                            0 ) ) == 0 ) {
        system( "PAUSE" );
        return false;
    }
    return true;
}

//--- EXIT ---------------------------------------------------------------------
wenn ihr mir sagen könnt wo mein fehler liegt, wieso des immer fahlschlägt, dann sagts mir... bin fuer jede Hilfe dankbar.

Gruß Tobi.
 
Ohne mir den Code weiter anzuschauen,könnte es sein das dir VirtualQuery fehlt?
Also das du die Speicherbereichgrenzen gar nicht kennst?

Hier mal ein Ausschnitt aus meinem APT-Hooking Code:

Code:
 MEMORY_BASIC_INFORMATION mbi;
 DWORD dwOldProtect;
 VirtualQuery((void*)msgbox_addr,&mbi,sizeof(MEMORY_BASIC_INFORMATION));
 VirtualProtect((PDWORD)mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &dwOldProtect);

mfg,
Xalon

P.S:Muss das nicht heißen "What's HARD to write must BE HARD to read!"?
 
Auch SeDebugPrivelege eingeschaltet?
sowas (enable debug privelege, aus dem DLL Injection Thread gerippt):
Code:
void EDP()
{
	TOKEN_PRIVILEGES priv;
	HANDLE hThis, hToken;
	LUID luid;
	hThis = GetCurrentProcess();

	OpenProcessToken(hThis, TOKEN_ADJUST_PRIVILEGES, &hToken);
	LookupPrivilegeValue(0, "seDebugPrivilege", &luid);
	priv.PrivilegeCount = 1;
	priv.Privileges[0].Luid = luid;
	priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
	AdjustTokenPrivileges(hToken, false, &priv, 0, 0, 0);

	CloseHandle(hToken);
	CloseHandle(hThis);
}
 
wieso muss ich die grenzen kennen? ich haette es jetz nur so gemacht:
die kleinst mögliche addresse is base address und die maximal mögliche addresse soll die size angeben... muss ich da jede speicherseite extra durchlaufen mit virtualqueryex()?

und wtf is EDP? was soll das bewirken?

Gruß Tobi.
 
Naja man kann doch nur von Pages rechte holen.
Und die Pages sind ja durch Start/Größe definiert und dafür brauchst VirtualQuery

Und EDP() holt für dein Programm erweiterte Privilegien, DebugPrivilegien eben.

mfg,
Xalon
 
hmm... könntet ihr mir dann nur im letzen teil meines codes weiter helfen?
Code:
bool kickPAGE_GUARD( ) {

    if( ( VirtualProtectEx( hProcess,
                            si.lpMinimumApplicationAddress,
                            dwSize,
                            PAGE_READWRITE | PAGE_EXECUTE_READWRITE,
                            0 ) ) == 0 ) {
        system( "PAUSE" );
        return false;
    }
    return true;
}

wie muss ich das hier veraendern das es klappt?

ich habs so versucht:
Code:
bool kickPAGE_GUARD( ) {

    VirtualQueryEx( hProcess, si.lpMinimumApplicationAddress, &mbi, sizeof( MEMORY_BASIC_INFORMATION ) );
    
    if( ( VirtualProtectEx( hProcess,
                            mbi.BaseAddress,
                            mbi.RegionSize,
                            PAGE_EXECUTE_READWRITE,
                            0 ) ) == 0 ) {
        return false;
    }
    return true;
}
scheint aber auch noch nicht richtig zu sein.

Gruß Tobi.
 
Wie gesagt: Fehlercode/Meldung wären hier sehr hilfreich. Du solltest auch mal mit einem Debugger probieren (ollyDbg) - Schritt für Schritt durchgehen, um den Fehler zu lokalisieren. Bei meinen eigenen "Experimenten" klappte die Memorystatusänderung, solange das manipulierende Programm "SeDebugPrivileges" hatte.
Allerdings habe ich immer nur existierende Speicherbereiche geändert - und musste die nicht erst erraten.
Zu Testzwecken könntest Du auch das Programm selber starten (CreateProcess) und ein wenig laufen lassen (Sleep 10000 oder so ähnlich).
 
hm also hab jetzt noch mal so probiert, und auch mit SeDebufPrivileges. doch trotzdem klappts net. er springt immer bei der allocation raus. hier mal der code.
Code:
/*******************************************************************************

    Author  : Tobias Stein
    Date    : 9th July '07
    Project : Kill PAGE_GUARD
    File    : KillPG2.cpp
    Remark  : Many memory addresses will protected by PAGE_GUARD, if you want to
              manipulate or read an address, PAGE_GUARD cause an exception, so
              you got no access.
              This application should turn off the fucking PAGE_GUARD.

    All Rights Reserved!

*******************************************************************************/


//--- Includes -----------------------------------------------------------------

#include <windows.h>
#include <commctrl.h>

//--- Globals ------------------------------------------------------------------

#define ID_BUTTON_TURNOFF               1000
#define ID_PROGRESSBAR_STATUS           1001

char szAppName[ ] = "Kick the fucking PAGE_GUARD";
char szAppTitle[ ] = "Turn off the fucking PAGE_GUARD";

//--- Prototype ----------------------------------------------------------------

LRESULT CALLBACK WinProc( HWND, UINT, WPARAM, LPARAM );
void EnableDebugPrivilege( );
bool turnItOff( HWND );

//--- Main ---------------------------------------------------------------------

WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) {

    HWND hWnd;
    WNDCLASS wc;
    MSG msg;

    wc.style = CS_VREDRAW | CS_HREDRAW;
    wc.lpfnWndProc = WinProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon( 0, IDI_APPLICATION );
    wc.hCursor = LoadCursor( 0, IDC_ARROW );
    wc.hbrBackground = reinterpret_cast< HBRUSH >( GetStockObject( BLACK_BRUSH ) );
    wc.lpszMenuName = 0;
    wc.lpszClassName = szAppName;

    if( !( RegisterClass( &wc ) ) ) {

        MessageBox( 0, "Couldn't register window by windows!", "Shutdown error!", MB_OK | MB_ICONERROR );
        return 0;
    }

    hWnd = CreateWindowEx( 0,
                           szAppName, szAppTitle,
                           WS_SYSMENU | WS_MINIMIZEBOX,
                           CW_USEDEFAULT, CW_USEDEFAULT, 320, 220,
                           0,
                           0,
                           hInstance,
                           0 );

    if( !hWnd ) {

        MessageBox( 0, "Couldn't create the window!", "Shutdown error!", MB_OK | MB_ICONERROR );
        return 0;
    }

    ShowWindow( hWnd, nCmdShow );
    UpdateWindow( hWnd );

    while( GetMessage( &msg, 0, 0, 0 ) ) {

        TranslateMessage( &msg );
        DispatchMessage( &msg );
    }

    return( msg.wParam );
}

//--- Windowprocedur -----------------------------------------------------------

LRESULT CALLBACK WinProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) {

    HINSTANCE hInst;
    static RECT wndRect;
    static HWND hButton_to;
    static HWND hProgressBar;

    switch( message ) {

        case WM_CREATE: {

            hInst = ( (LPCREATESTRUCT)lParam )->hInstance;
            InitCommonControls( );

            hButton_to = CreateWindowEx( 0, "BUTTON", "KickIT", WS_CHILD | WS_VISIBLE,
                                         107, 110, 100, 30, hWnd, (HMENU)ID_BUTTON_TURNOFF,
                                         hInst, 0 );

            hProgressBar = CreateWindowEx( WS_EX_CLIENTEDGE, PROGRESS_CLASS, 0,
                                           WS_CHILD | WS_VISIBLE | WS_BORDER,
                                           0, 0, 0, 0, hWnd, (HMENU)ID_PROGRESSBAR_STATUS,
                                           hInst, 0 );

            SendMessage( hProgressBar, PBM_SETRANGE32, 0, 524256 );
            SendMessage( hProgressBar, PBM_SETSTEP, 1, 0 );
            return 0;
        }

        case WM_SIZE: {

            GetClientRect( hWnd, &wndRect );
            MoveWindow( hProgressBar, wndRect.left, wndRect.bottom - 20, wndRect.right, 20, true );
            return 0;
        }

        case WM_COMMAND: {

            switch( LOWORD( wParam ) ) {

                case ID_BUTTON_TURNOFF: {

                    switch( HIWORD( wParam ) ) {

                        case BN_CLICKED: {

                            turnItOff( hProgressBar );
                            break;
                        }
                    }
                    break;
                }
            }
            return 0;
        }

        case WM_DESTROY: {

            PostQuitMessage( 0 );
            return 0;
        }
    }
    return( DefWindowProc( hWnd, message, wParam, lParam ) );
}

//--- Definitions --------------------------------------------------------------

void EnableDebugPrivilege( ) {

    TOKEN_PRIVILEGES priv;
	HANDLE hThis, hToken;
	LUID luid;

	hThis = GetCurrentProcess();

	OpenProcessToken( hThis, TOKEN_ADJUST_PRIVILEGES, &hToken );

	LookupPrivilegeValue( 0, "seDebugPrivilege", &luid );

	priv.PrivilegeCount = 1;
	priv.Privileges[ 0 ].Luid = luid;
	priv.Privileges[ 0 ].Attributes = SE_PRIVILEGE_ENABLED;

	AdjustTokenPrivileges( hToken, false, &priv, 0, 0, 0 );

	CloseHandle( hToken );
	CloseHandle( hThis );
}

bool turnItOff( HWND hProgressBar ) {

    SYSTEM_INFO si;
    MEMORY_BASIC_INFORMATION mbi;
    DWORD dwCurrentPage;

    EnableDebugPrivilege( );
    memset( &si, 0, sizeof( SYSTEM_INFO ) );
    memset( &mbi, 0, sizeof( MEMORY_BASIC_INFORMATION ) );

    GetSystemInfo( &si );
    dwCurrentPage = (DWORD)si.lpMinimumApplicationAddress;

    do {

        // query a new memory page
        VirtualQuery( (LPVOID)dwCurrentPage, &mbi, si.dwPageSize );

        // allocate this page
        if( ( VirtualAlloc( (LPVOID)dwCurrentPage, si.dwPageSize, MEM_COMMIT, PAGE_GUARD ) ) == 0 ) {

            MessageBox( 0, "Process fails, couldn't commit new page!", "Failure!", MB_OK | MB_ICONERROR );
            return false;
        }

        // set new protection mode
        if( ( VirtualProtect( (LPVOID)dwCurrentPage, si.dwPageSize, PAGE_READWRITE, 0 ) ) == 0 ) {

            MessageBox( 0, "Process fails, couldn't change protection mode!", "Failure!", MB_OK | MB_ICONERROR );
            return false;
        }

        // decommit allocate page
        if( ( VirtualFree( (LPVOID)dwCurrentPage, si.dwPageSize, MEM_DECOMMIT ) ) == 0 ) {

            MessageBox( 0, "Process fails, couldn't decommit current page!", "Failure!", MB_OK | MB_ICONERROR );
            return false;
        }

        SendMessage( hProgressBar, PBM_STEPIT, 0, 0 );
        dwCurrentPage += si.dwPageSize;
        
    } while( dwCurrentPage < (DWORD)si.lpMaximumApplicationAddress );

    return true;
}

//--- EXIT ---------------------------------------------------------------------

sieht da jemand evtl den fehler?
CDW du sagst du hast das auch schon gemacht, könntest du mir deine anwendung mal geben? und wenns in c++ gecoded ist, den quelltext zum angucken? waer echt nett. mit olly debugen und so hmmm irgendwie bin ich zu unfähig sowas zu machen.

Gruß Tobi.
 
hab deinen code jetzt auf die schnelle net zum laufen gebracht mit meinem compiler, aber generell brauchst du erstmal mehr debugging-infos um die ursache hier einzugrenzen..
versuch mal die funktion
Code:
void outputError(DWORD dwErr) 
{
	char *buf = (char*)LocalAlloc(LPTR, 2*1024);
	char szMsg[256];
	DWORD dwFlags = FORMAT_MESSAGE_IGNORE_INSERTS |
					FORMAT_MESSAGE_MAX_WIDTH_MASK |
					FORMAT_MESSAGE_FROM_SYSTEM;
	
	if (!FormatMessage(dwFlags, NULL, dwErr, 0, szMsg, sizeof(szMsg), NULL)) 
		strcpy(szMsg, "Unknown error.");
	sprintf (buf, "[%i] %s", dwErr, szMsg);
	MessageBox(NULL, buf, "Error!", MB_ICONERROR | MB_OK);
	LocalFree(buf);
}

in deinen code an der stelle einzubauen, wo das programm hängt (also irgendwo bei zeile 199/200 rum) und uebergib GetLastError() als parameter; evtl auch die momentane addresse noch als zusätzlichen parameter uebergeben und ausgeben lassen... auf jeden fall ist wichtig, welchen wert GetLastError zurueckgibt wenn das prog hops geht...

mfg jacky

edit: habs jetzt doch mal kompiliert und den error rausgesucht, und GLE liefert einen error 87: Falscher Parameter zurueck, und zwar bei der ersten page die versucht wird zu alloziieren..kann mir allerdings darauf auch keinen reim machen;aber evtl solltest du sowieso die logik in deinem prog nommal ueberdenken, wärs net sinnvoller die pages vorher auf ein page_lock oder zumindest ein page_commit zu ueberpruefen anstatt blind drauflos alles zu resetten?
 
hier ist schon eine etwas ueberarbeitete version...
Code:
bool turnItOff( HWND hProgressBar ) {

    SYSTEM_INFO si;
    MEMORY_BASIC_INFORMATION mbi;
    DWORD dwOldProtect;
    LPVOID lpAddress;
    DWORD dwCurrentPage;

    EnableDebugPrivilege( );
    memset( &si, 0, sizeof( SYSTEM_INFO ) );
    memset( &mbi, 0, sizeof( MEMORY_BASIC_INFORMATION ) );

    GetSystemInfo( &si );
    dwCurrentPage = (DWORD)si.lpMinimumApplicationAddress;

   do {

        VirtualQuery( (LPVOID)dwCurrentPage, &mbi, sizeof( MEMORY_BASIC_INFORMATION ) );
        lpAddress = VirtualAlloc( mbi.BaseAddress, mbi.RegionSize, MEM_COMMIT, PAGE_READWRITE );

        if( !( VirtualProtect( mbi.BaseAddress, mbi.RegionSize, PAGE_READWRITE, &dwOldProtect ) ) ) {

            lasterror( );
            return false;
        }

        VirtualFree( lpAddress, mbi.RegionSize, MEM_DECOMMIT );
        lpAddress = 0;
        SendMessage( hProgressBar, PBM_STEPIT, 0, 0 );
        dwCurrentPage += ( si.dwPageSize );

    } while( dwCurrentPage < (DWORD)si.lpMaximumApplicationAddress );

    return true;
}

GetLastError() = "Es wurde versucht, auf eine unzulässige addresse zu zugreiffen!"

hm... ich bekomm echts kotzen-.-

PS: wie kann ich seiten prüfen?
 
mit seiten pruefen meinte ich, deine struct mbi zu untersuchen, ob die seite ueberhaupt mit page_guard geschuetzt ist bzw ueberhaupt committed oder reserved, da du pages die nicht benutzt sind eh net ent-guarden musst..

Code:
VirtualFree( lpAddress, mbi.RegionSize, MEM_DECOMMIT );
ist das so eine gute idee, einfach alle pages im addressbereich des programms zu decommitten? spätestens hier muss ja wohl alles kaputt gehen oder?
und wieso btw. alloziierst du die seite ueberhaupt(VirtualAlloc) , du willst sie ja eigentlich nur von page_guard befreien oder?

mfg
 
ich würde vorerst http://www.codeproject.com/w2k/system_scaner.asp empfehlen (insbesondere MemDumpDlg.cpp), im Moment experimentiere ich damit etwas herum, eventuell ist heute auch das Ergebnis verfügbar.

EDIT:
vorerst nur XP SP2 getestet. Nicht allzu "DAU" sicher (manche Kombinationen der Flags/Speicherbereiche gehen eben nicht und bevor man z.B "NOACCESS" auf eine GUARDED Page loslässt, muss das GUARD-Flag weg - es gibt allerdings keinerlei Extrahinweise diesbezüglich), aber interessant zum rumspielen - man kann problemlos Programme crashen, wenn man den Stack auf NOACCESS setzt :).

Anleitung:
Process wählen, "Show" und dann gewünschten Speicherbereich markieren und per Rechtklickmenü den Zugriff setzen. Im oberen Menüteil sind die "einmaligen" Flags (also nicht kombinierbar) im unteren die kombinierbaren Flags. Gleichzeitig stellt das Menü auch den aktuellen Status dar.Die kombinierbaren Flags setzt oder löscht man durch die Auswahl derselben im Menü. Die nicht kombinierbaren können nur auf einen anderen Flag gesetzt werden.

Welche Flags verfügbar/setzbar sind, hängt auch vom OS ab.
Die "Guarded" Pages sind übrigens rot markiert.

Source liegt bei (MASM), da ich allerdings zum Schluss hin langsam ungeduldig wurde, sieht es demensprechend dreckig aus.
 
Zurück
Oben