Shellcode-Loader

Shellcode-Loader ist ein einfaches Kommandozeilentool zum Testen von Shellcodes.
Es ist in C geschrieben und wird Open Source bereitgestellt.
Funktioniert auf jedem Windows von WinXP bis Win10.

Shellcode-Loader

Mehr Infos und Download auf seiner Seite

CryptoGear-Verschlüsselungsalgorithmus
Blockverschlüsselung mit symmetrischem Schlüssel, entwickelt von BreakingSecurity.

Die C++-Implementierung finden Sie hier.

RC4-Klasse in C++

Standard RC4-Verschlüsselungsalgorithmus.
Einfach und schnell, es ist ein berühmter Algorithmus, der in vielen Anwendungen verwendet wird.

cRC4.h :

/**************************************************** **********
* Standard-RC4-Verschlüsselung
* C++-Klasse
* Kodiert von Viotto © BreakingSecurity.net
****************************************************** *********/
#einschließen
Verwendung von Namensraum Standard;
Klasse CRC4
{
Öffentlichkeit:
	CRC4(ohne Vorzeichen verkohlen* pTaste, ohne Vorzeichen int lenKey);
	CRC4();
	ungültig RC4(ohne Vorzeichen verkohlen pData[], ohne Vorzeichen lange lenData);
	Schnur RC4Str(ohne Vorzeichen verkohlen* pEingabedaten, ohne Vorzeichen lange Eingabegröße);
	ungültig Initialisieren(ohne Vorzeichen verkohlen* pTaste, ohne Vorzeichen int lenKey);
Privatgelände:
	int m_sBox[256]; //Substitutionsbox
	int a, b;	
	ohne Vorzeichen verkohlen Tauschen;
};

 

cRC4.cpp :

/**************************************************** **********
* Standard-RC4-Verschlüsselung
* C++-Klasse
* Kodiert von Viotto © BreakingSecurity.net
****************************************************** *********/

#include "cRC4.h"
// Konstrukteur. Es generiert eine S-Box basierend auf dem bereitgestellten Schlüssel.
// Auf diese Weise müssen zukünftige Verschlüsselungs-/Entschlüsselungsroutinen die S-Box nicht jedes Mal neu erstellen.
CRC4::CRC4(ohne Vorzeichen verkohlen* pTaste, ohne Vorzeichen int lenKey)
{
	Initialisieren (pTaste, lenKey);
}
/* Überladener Costructor ohne Argumente.
   S-Box muss manuell initialisiert werden. */
CRC4::CRC4()
{}

ungültig CRC4::Initialize(ohne Vorzeichen verkohlen* pTaste, ohne Vorzeichen int lenKey)
{
	// Substitutionsbox initialisieren, basierend auf dem bereitgestellten Schlüssel.
	b = 0;
	aufgrund (a = 0; a < 256; a++)
	{
		m_sBox[a] = a;
	}
	aufgrund (a = 0; a < 256; a++)
	{
		b = (b + m_sBox[a] + pKey[a % lenKey]) % 256;
		tauschen = m_sBox[a];
		m_sBox[a] = m_sBox[b];
		m_sBox[b] = Tauschen;
	}
}

ungültig CRC4::RC4(ohne Vorzeichen verkohlen pData[], ohne Vorzeichen lange lenData)
{
	int sBox[256];
	int i = 0, j = 0;
	lange Offset;
	// Erstellen Sie eine lokale Kopie der S-Box. Besser als jedes Mal neu erstellen vor dem Verschlüsseln/Entschlüsseln.
	memcpy(sBox, m_sBox, 256 * Größe von(int));
	//Daten verschlüsseln
	aufgrund (Versatz = 0; Offsetdruck < lenData; Offset++)
	{
		i = (i + 1) % 256;
		j = (j + sBox[i]) % 256;
		tauschen = sBox[i];
		sBox[i] = sBox[j];
		sBox[j] = Tauschen;
		pData[Offset] ^= sBox[(sBox[i] + sBox[j]) % 256];
	}
}

// Diese Funktion überschreibt die Eingabe nicht mit der Ausgabe, sondern speichert sie in einem separaten String.
Schnur CRC4::RC4Str(ohne Vorzeichen verkohlen* pEingabedaten, ohne Vorzeichen lange Eingabegröße)
{
	Schnur sInputOutputData((verkohlen*)pEingabedaten, Eingabegröße);
	RC4((ohne Vorzeichen verkohlen*)sInputOutputData.c_str(), Eingabegröße);
	Rückkehr sInputOutputData;
}
C++-Dateisuche

Eine einfache und schnelle rekursive Funktion, die verwendet werden kann, um nach einem Dateinamen oder einem Teil davon zu suchen,
in einem bestimmten Ordner und allen seinen Unterverzeichnissen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#einschließen
#enthalten
#einschließen
Verwendung von Namensraum Standard;
//_____________________________________________
//
// FileSearch-Funktion
// 
// Diese Funktion sucht nach einem Dateinamen oder einem Teil davon,
// innerhalb des angegebenen Verzeichnisses und in allen Unterverzeichnissen.
// © BreakingSecurity.net
//
// PARAMETER:
// sSearch: String, der einen Dateinamen oder einen Teil des Dateinamens angibt, nach dem gesucht werden soll.
// sDir: Suchpfad (z. B.: "C:\\Windows")
//_____________________________________________
//
bool Dateisuche(String sSuche, Schnur sDir)
{
	// Alle Zeichen in Kleinbuchstaben umwandeln
	std::transform(sSearch.begin(), sSearch.end(), sSearch.begin(), ::zu senken);
	
	// Suchen Sie nach abschließendem Schrägstrich im Pfad und hängen Sie ihn an, falls er fehlt
	if (sDir[sDir.länge() -1] != '\\')
	{
		sDir += "\\";
	}
	
	WIN32_FIND_DATA Dateiinformation;
	GRIFF hFinden = FindFirstFileA(string(sDir + "*").c_str(), &Dateiinformation);
	if (hFinden == INVALID_HANDLE_VALUE)
	{
		FindClose(hFind);
		Rückkehr falsch;
	}
	Schnur sFileInfo;
	während (FindNextFile(hFind, &Dateiinformation) != 0)
	{
		if (FileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
			&& strcmp(Dateiinfo.cDateiname, ".") != 0
			&& strcmp(Dateiinfo.cDateiname, "..") != 0)
		{
			// Rekursive Suche im Unterverzeichnis
			Schnur sRecursiveDir = sDir + Zeichenfolge (Dateiinfo.cDateiname);
			FileSearch(sSearch, sRecursiveDir);
		}
		
		Schnur sFileName(FileInfo.cFileName);
		
		// Alle Zeichen in Kleinbuchstaben umwandeln
		std::transform(sDateiname.begin(), sFileName.end(), sDateiname.begin(), ::zu senken);
		
		// Prüfen, ob Dateiname Suchzeichenfolge enthält
		if (sDateiname.find(sSuche) != string::npos)
		{
			//Suchzeichenfolge wurde im Dateinamen gefunden
			printf(string(sDir + FileInfo.cDateiname + "\n").c_str());
		}
	}
	FindClose(hFind);
	Rückkehr was immer dies auch sein sollte.;
}
// Anwendungsbeispiel:
// FileSearch.exe "Notepad" "C:Windows"
ungültig Haupt-(int Argumente, verkohlen* arg[])
{
	if (Arg == 3)
	{
		FileSearch(argv[1], arg[2]);
		printf ("Suche beendet!\n");
	}
	sonst printf ("Falsche Parameteranzahl\n");
	System("Pause");
}
[ C ] Prozesspfad von PID auf Kernel-Ebene abrufen

Auf Benutzerebene ist eine so einfache Aufgabe durch die Verwendung von APIs wie GetModuleFileNameEx() unkompliziert, wie sie sollte.

Es gibt jedoch keine dokumentierte Möglichkeit, dies auf Kernel-Ebene zu tun.
Ich habe viele Leute gefunden, die danach gefragt haben, aber kein klar funktionierendes Snippet gefunden, also dachte ich, es könnte nützlich sein, meins zu teilen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
BOOLEAN KrnGetProcessPath(HANDHABEN hProcessId)
// ProcessID-Handle kann mit PsGetCurrentProcessId() abgerufen werden,
// oder durch Verwendung von Prozess-Callback-Routinen wie PsSetCreateProcessNotifyRoutine()
{
	GRIFF hProzess = NULL;
	OBJECT_ATTRIBUTES obj_attr;
	KUNDEN ID Säure;
	cid.UniqueProcess = hProcessId; 
	cid.UniqueThread = NULL;
	InitializeObjectAttributes(&obj_attr, NULL, 0, NULL, NULL);
	ZwOpenProcess(&hProzess, GENERIC_READ, &obj_attr, &cid);
	// Wenn der ProcessInformationClass-Parameter ProcessImageFileName ist, 
	// Der Puffer, auf den der ProcessInformation-Parameter zeigt, sollte groß genug sein, um eine UNICODE_STRING-Struktur aufzunehmen, 
	// sowie der String selbst.
	WCHAR ustrBuffer[(Größe von(UNICODE_STRING) / Größe von(WCHAR)) + 260];
	UNICODE_STRING ustrPfad;
	// UNICODE_STRING initialisieren
	ustrPath.Puffer = ustrPuffer;
	ustrPfad.Länge = 0x0;
	ustrPath.MaximumLength = Größe von(ustrPuffer);
	// Der Prozesspfad wird im Unicode-String gespeichert.
	NTSTATUS ret = ZwQueryInformationProcess(hProcess, ProcessImageFileName, &ustrPfad, Größe von(ustrPuffer), NULL);
	if (NT_SUCCESS(ret))
	{
		DbgPrintEx(DPFLTR_IHVDRIVER_ID, 0, "[DEBUG] Prozesspfad: %wZ\n", ustrPfad);
		Rückkehr WAHR;
	}
	sonst
	{
		DbgPrintEx(DPFLTR_IHVDRIVER_ID, 0, "[FEHLER] Fehler beim Abrufen des Prozesspfads: %x\n", zurück);
		Rückkehr FALSCH;
	}
}
LoadDll: LoadLibrary-Alternative in C

Der folgende Code ist ein Ersatz für die Windows-Funktion LoadLibrary(), eine alternative Methode zum Laden einer DLL in unseren Adressraum.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#enthalten
// UNICODE_STRING-Struktur
typedef struct _UNICODE_STRING 
{
    USKURZ Länge;
    USKURZ Maximale Länge;
    PWSTR  Puffer;
} UNICODE_STRING, *PUNICODE_STRING;
//Prototyp der LdrLoadDll-Funktion 
typedef NTSTATUS (WINAPI *fLdrLoadDll) 
(
	IN PWCHAR PfadZuDatei OPTIONAL,
	IN ULANG Flags OPTIONAL, 
	IN PUNICODE_STRING Moduldateiname, 
	OUT PHANDEL ModulHandle 
); 
//Prototyp der RtlInitUnicodeString-Funktion
typedef LEERE (WINAPI *fRtlInitUnicodeString) 
(
	PUNICODE_STRING ZielString,
	PCWSTR SourceString
);
HMODUL hNtDll;
fLdrLoadDll _LdrLoadDll;
fRtlInitUnicodeString _RtlInitUnicodeString;
//_____________________________________________
//
// LoadDll: LoadLibrary-Ersetzung
// 
// Diese Funktion lädt die angegebene DLL in unseren Prozess.
// Diese Funktion ist ein Ersatz für die Windows-Funktion LoadLibrary(). 
//
// PARAMETER:
// szFileName: Pfad der zu ladenden DLL.
//
// RÜCKGABEWERT:
// HMODULE DllHandle: Ein Handle für das DLL-Modul im Speicher.
//_____________________________________________
//
HMODUL LoadDll( LPCSTR szDateiname) 
{  
   // Benötigte Funktionen dynamisch laden
   hNtDll = GetModuleHandleA("ntdll.dll");
   _LdrLoadDll = (fLdrLoadDll) GetProcAddress( hNtDll, "LdrLoadDll");
   _RtlInitUnicodeString = (fRtlInitUnicodeString) GetProcAddress( hNtDll, "RtlInitUnicodeString");
   int StrLen = lstrlenA(szDateiname);
   BSTR WideStr = SysAllocStringLen(NULL, StrLen);
   MultiByteToWideChar(CP_ACP, 0, szDateiname, StrLen, WideStr, StrLen);
   UNICODE_STRING usDllName;
   _RtlInitUnicodeString(&usDllName, WideStr);
   SysFreeString(WideStr);
   GRIFF DllHandle; 
   _LdrLoadDll(0, 0, &usDllName, &DllHandle);
   Rückkehr (HMODULE)DllHandle;
}
int Haupt-() //Anwendungsbeispiel
{
   HMODUL hmodul = LoadDll("Kernel32.dll");
   Rückkehr (int)hmodul;
}
Viotto .OCX-Registrator

Viotto OCX Registrator ist ein einfaches Tool zum Installieren, Registrieren und Abmelden OCX-Dateien.
Es wird kostenlos und Open Source veröffentlicht.
Es ist in Embarcadero C++ codiert.
Sie können es finden hier.

Menü