Ocultar modulos, rootkit ring3

Dentro de los rootkits existen los de ring3 (En modo Usuario) que bien pueden afectar solo a un proceso o la división entre MK y MU. Una manera de ocultar los que afectan a un solo proceso es eliminando rastro de que esta cargado ante los ojos del proceso o cualquier otro (como un AV) que esté en busca de librerías maliciosas.
Esto consiste en modificar las LIST_ENTRY de la PEB del proceso, en el source solo aplique InLoadOrderModuleList, pero para eliminar la mayor parte del rastro podemos modificar las tres listas; InLoadOrderModuleList, InMemoryOrderModuleList, InInitializationOrderModuleList.

Antes de ocultar el módulo.


Después de ocultar el módulo.


Descarga: http://www.sendspace.com/file/db4d33

Saludos!

Dumpear un módulo en memoria a disco[Parte 1]

Había estado buscando esta información hace mucho tiempo, pero por desgracia no la encontré o no supe como buscarla. A continuación hablaremos de como obtener un volcado (dump) de un módulo en memoria a un archivo en disco.

[+]Volcado de módulo.
[-]Conocimiento Previo.
[-]Conversión disco-memoria.
[-]Estructura de proceso y los módulos.
[-]Comenzando con el volcado.
[-]Archivo en disco.
[-]Referencias y agradecimientos.

[+]Volcado de módulo.[-]Conocimiento previo.

Para el entendimiento de este documento se necesita estudiar la cabecera PE, para ello les recomiendo el texto de The Swash "Formato de ficheros ejecutables", existen mas requerimientos pero tratare de ser explicativo en ese ámbito, les recuerdo que no soy un experto en este campo y lo que escribo son investigaciones que he hecho.

[-]Conversión disco-memoria.

Como el título lo dice para entender el volcado de un módulo, cualquier archivo que contenga una cabecera PE como es el caso de un Ejecutable o una DLL (Dynamic Link Library) con la única diferencia de que la DLL contiene una tabla de exportaciones válida y ciertas flags activadas en la cabecera PE, primero es necesario entender como un archivo en disco es cargado por el Loader de Windows en memoria ya sea en un proceso nuevo o dentro de un proceso.
Dentro de IMAGE_OPTIONAL_HEADER se encuentran muchos de los datos que nos interesan como es el caso de ImageAddress, SizeOfImage, SectionAlignment, FileAlignment y los DataDirectory's; como es sabido la cabecera y las secciones están alineadas siempre en múltiplos de FileAlignment y esto se repite en memoria pero tomando como unidad SectionAlignment que normalmente tiene el valor de 0x1000, el tamaño de una página de la memoria RAM.
Dentro del proceso de conversión lo que a nosotros nos importa es cuando se copian las secciones del disco a la memoria, ese proceso comienza tomando el valor de ImageBase (normalmente 0x400000) y a partir de ese valor se comienza a copiar la cabecera PE posterior a eso se copian las secciones; antes de que el proceso comience a correr el Loader carga los módulos o librerías que se necesitan leyendo la tabla de importaciones (IT) y llenando la tabla de direcciones de importaciones (IAT) para que el proceso completo pueda hacer uso de APIs.
¿Donde podemos encontrar la IAT?
Bueno la Import Table (IT) es un array de IMAGE_IMPORT_DESCRIPTOR, el cual contiene el nombre de la DLL, existe un elemento del array por DLL. El array tiene su fin en un espacio vacío, les dejo su estructura en C.

typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
ULONG Characteristics; //Valor en 0 para terminar el array
ULONG OriginalFirstThunk; // Un RVA a el primer IMAGE_THUNK_DATA de la DLL
} DUMMYUNIONNAME;

ULONG TimeDateStamp; //No sirve de mucho, muestra la fecha de la DLL
ULONG ForwarderChain; // -1 if no forwarders
ULONG Name; //Un RVA a el nombre de la DLL
ULONG FirstThunk; //Este valor en memoria contiene un puntero a la IAT de la DLL
} IMAGE_IMPORT_DESCRIPTOR;

Como ven FirstThunk contiene un puntero a el primer IMAGE_THUNK_DATA, ¿cuál es la diferencia entre FirstThunk y OriginalFirstThunk?, la diferencia es que FirstThunk es actualizado por el Loader de Windows por las direcciones a lasAPIs actuales y OriginalFisrtThunk contiene la lista virgen.
Les dejo la estructura en C de IMAGE_THUNK_DATA :

typedef struct IMAGE_THUNK_DATA {
union {
LPBYTE    ForwarderString;
FARPROC Function;
DWORD     Ordinal;
PIMAGE_IMPORT_BY_NAME   AddressOfData;
} u1;
} IMAGE_THUNK_DATA,*PIMAGE_THUNK_DATA;

Esta estructura solo tiene un valor... Pero podemos utilizarla a gusto en la IAT se usa el valor Function el cual contiene un puntero a un procedimiento, en otras palabras a una API.
El caso de AddressOfData tiene un RVA a una estructura tipo IMAGE_IMPORT_BY_NAME. Su estructura es la siguiente:

typedef struct IMAGE_IMPORT_BY_NAME {
WORD    Hint;
BYTE    Name[1];
} IMAGE_IMPORT_BY_NAME,*PIMAGE_IMPORT_BY_NAME;

La variable Hint contiene el index de la función en la DLL (Si también se pueden cargar APIs por index)
La variable Name es el comienzo del nombre de la DLL.

En otra entrega continuare con el tema.
Saludos!

Enumerar módulos de procesos externos

Tenía un pequeño lío con los punteros pues no me concordaban hasta que pense un poco el problema y logre hacerlo funcionar.
Primero el proceso lista los procesos corriendo en el momento, pos teriormente los recorre uno por uno obtiene el PEB del proceso y obtiene una entrada al primer módulo, obtenemos su BaseAddress y su nombre, obtiene la siguiente entrada y así continua hasta el final.

El código esta explicado pero si hay alguna duda no duden en comentar

Descarga SendSpace

¡Saludos!

Obtener ImageBase con PEB

Me habia ausentado del blog, pero ya estare activo y comienzo con este código que devuelve la ImageBase de un proceso, se le pasa un handle con privilegios de PROCESS_ALL_ACCESS o PROCESS_VW_READ y devuelve la ImageBase del proceso.
Para ello usamos la PEB (Process Environment Block) contiene los datos íntimos del proceso, pronto sacaré una función que liste los Thread de un proceso con la TEB (Thread Environment Block)

unit PEBData;

interface
uses Windows;

type
  PNtAnsiString = ^TNtAnsiString;
  TNtAnsiString = packed record
    Length: Word;
    MaximumLength: Word;
    Buffer: PAnsiChar;
  end;

  PNtUnicodeString = ^TNtUnicodeString;
  TNtUnicodeString = packed record
    Length: Word;
    MaximumLength: Word;
    Buffer: PWideChar;
  end;

  PLdrModule = ^TLdrModule;
  TLdrModule = packed record
    InLoadOrderModuleList          : TListEntry;      // 0h
    InMemoryOrderModuleList        : TListEntry;      // 8h
    InInitializationOrderModuleList: TListEntry;      // 10h
    BaseAddress                    : THandle;         // 18h
    EntryPoint                     : THandle;         // 1Ch
    SizeOfImage                    : Cardinal;        // 20h
    FullDllName                    : TNtUnicodeString;// 24h
                                   // Length (2)         24h
                                   // MaximumLength (2)  26h
                                   // Buffer (4)         28h
    BaseDllName                    : TNtUnicodeString;// 2Ch
    Flags                          : ULONG;           // 34h
    LoadCount                      : SHORT;           // 38h
    TlsIndex                       : SHORT;           // 3Ah
    HashTableEntry                 : TListEntry;      // 3Ch
    TimeDataStamp                  : ULONG;           // 44h
  end;

  PPebLdrData = ^TPebLdrData;
  TPebLdrData = packed record
    Length                         : Cardinal;        // 0h
    Initialized                    : LongBool;        // 4h
    SsHandle                       : THandle;         // 8h
    InLoadOrderModuleList          : TListEntry;      // 0Ch
    InMemoryOrderModuleList        : TListEntry;      // 14h
    InInitializationOrderModuleList: TListEntry;      // 1Ch
  end;

  PCurDir = ^TCurDir;
  TCurDir = packed record
    DosPath: TNtUnicodeString;
    Handle : THandle;
  end;

  PRtlDriveLetterCurDir = ^TRtlDriveLetterCurDir;
  TRtlDriveLetterCurDir = packed record
    Flags    : Word;
    Length   : Word;
    TimeStamp: Cardinal;
    DosPath  : TNtAnsiString;
  end;

  PRtlUserProcessParameters = ^TRtlUserProcessParameters;
  TRtlUserProcessParameters = record
    MaximumLength    : Cardinal;
    Length           : Cardinal;
    Flags            : Cardinal;
    DebugFlags       : Cardinal;
    ConsoleHandle    : THandle;
    ConsoleFlags     : Cardinal;
    StandardInput    : THandle;
    StandardOutput   : THandle;
    StandardError    : THandle;
    CurrentDirectory : TCurDir;
    DllPath          : TNtUnicodeString;
    ImagePathName    : TNtUnicodeString;
    CommandLine      : TNtUnicodeString;
    Environment      : Pointer;
    StartingX        : Cardinal;
    StartingY        : Cardinal;
    CountX           : Cardinal;
    CountY           : Cardinal;
    CountCharsX      : Cardinal;
    CountCharsY      : Cardinal;
    FillAttribute    : Cardinal;
    WindowFlags      : Cardinal;
    ShowWindowFlags  : Cardinal;
    WindowTitle      : TNtUnicodeString;
    DesktopInfo      : TNtUnicodeString;
    ShellInfo        : TNtUnicodeString;
    RuntimeData      : TNtUnicodeString;
    CurrentDirectores: Array [0..31] of TRtlDriveLetterCurDir;
  end;

  PPebFreeBlock = ^TPebFreeBlock;
  TPebFreeBlock = record
    Next: PPebFreeBlock;
    Size: Cardinal;
  end;

  PPeb = ^TPeb;
  TPeb = packed record
    InheritedAddressSpace         : Boolean;
    ReadImageFileExecOptions      : Boolean;
    BeingDebugged                 : Boolean;
    SpareBool                     : Boolean;
    Mutant                        : Pointer;
    ImageBaseAddress              : Pointer;
    Ldr                           : PPebLdrData;
    ProcessParameters             : PRtlUserProcessParameters;
    SubSystemData                 : Pointer;
    ProcessHeap                   : Pointer;
    FastPebLock                   : Pointer;
    FastPebLockRoutine            : Pointer;
    FastPebUnlockRoutine          : Pointer;
    EnvironmentUpdateCount        : Cardinal;
    KernelCallbackTable           : Pointer;
    case Integer of
      4: (
        EventLogSection           : Pointer;
        EventLog                  : Pointer);
      5: (
        SystemReserved            : Array [0..1] of Cardinal;
  { end; }
    FreeList                      : PPebFreeBlock;
    TlsExpansionCounter           : Cardinal;
    TlsBitmap                     : Pointer;
    TlsBitmapBits                 : Array [0..1] of Cardinal;
    ReadOnlySharedMemoryBase      : Pointer;
    ReadOnlySharedMemoryHeap      : Pointer;
    ReadOnlyStaticServerData      : ^Pointer;
    AnsiCodePageData              : Pointer;
    OemCodePageData               : Pointer;
    UnicodeCaseTableData          : Pointer;
    NumberOfProcessors            : Cardinal;
    NtGlobalFlag                  : Cardinal;
    Unknown                       : Cardinal;
    CriticalSectionTimeout        : TLargeInteger;
    HeapSegmentReserve            : Cardinal;
    HeapSegmentCommit             : Cardinal;
    HeapDeCommitTotalFreeThreshold: Cardinal;
    HeapDeCommitFreeBlockThreshold: Cardinal;
    NumberOfHeaps                 : Cardinal;
    MaximumNumberOfHeaps          : Cardinal;
    ProcessHeaps                  : ^Pointer;
    GdiSharedHandleTable          : Pointer;
    ProcessStarterHelper          : Pointer;
    GdiDCAttributeList            : Cardinal;
    LoaderLock                    : Pointer;
    OSMajorVersion                : Cardinal;
    OSMinorVersion                : Cardinal;
    OSBuildNumber                 : Word;
    OSCSDVersion                  : Word;
    OSPlatformId                  : Cardinal;
    ImageSubsystem                : Cardinal;
    ImageSubsystemMajorVersion    : Cardinal;
    ImageSubsystemMinorVersion    : Cardinal;
    ImageProcessAffinityMask      : Cardinal;
    GdiHandleBuffer               : Array [0..33] of Cardinal;
    PostProcessInitRoutine        : ^Pointer;
    TlsExpansionBitmap            : Pointer;
    TlsExpansionBitmapBits        : Array [0..31] of Cardinal;
    SessionId                     : Cardinal;
    AppCompatInfo                 : Pointer;
    CSDVersion                    : TNtUnicodeString);
  end;

  TProcessInfoClass = (
    ProcessBasicInformation,
    ProcessQuotaLimits,
    ProcessIoCounters,
    ProcessVmCounters,
    ProcessTimes,
    ProcessBasePriority,
    ProcessRaisePriority,
    ProcessDebugPort,
    ProcessExceptionPort,
    ProcessAccessToken,
    ProcessLdtInformation,
    ProcessLdtSize,
    ProcessDefaultHardErrorMode,
    ProcessIoPortHandlers,          // Note: this is kernel mode only
    ProcessPooledUsageAndLimits,
    ProcessWorkingSetWatch,
    ProcessUserModeIOPL,
    ProcessEnableAlignmentFaultFixup,
    ProcessPriorityClass,
    ProcessWx86Information,
    ProcessHandleCount,
    ProcessAffinityMask,
    ProcessPriorityBoost,
    ProcessDeviceMap,
    ProcessSessionInformation,
    ProcessForegroundInformation,
    ProcessWow64Information,
    MaxProcessInfoClass);

  PROCESS_BASIC_INFORMATION = packed record
    ExitStatus: DWORD;
    PebBaseAddress: Pointer;
    AffinityMask: DWORD;
    BasePriority: DWORD;
    UniqueProcessId: DWORD;
    InheritedUniquePID:DWORD;
  end;
  TProcessBasicInformation = PROCESS_BASIC_INFORMATION;
  PProcessBasicInformation = ^TProcessBasicInformation;

function ZwQueryInformationProcess(hProcess: THandle; InformationClass: DWORD; Buffer: PProcessBasicInformation; BufferLength : DWORD; ReturnLength: PDWORD): Cardinal; stdcall; external 'ntdll.dll' name 'ZwQueryInformationProcess';
function ZwReadVirtualMemory(ProcessHandle: DWord; BaseAddress: Pointer; Buffer: Pointer; BufferLength: DWord; ReturnLength: PDWord): Cardinal; stdcall; external 'ntdll.dll';

function GetProcessImageBase(hProcess: THandle): Integer;

implementation

function NtSuccess(AStatus: Longint): Boolean;
begin
  Result := AStatus >= 0;
end;

function GetProcessImageBase(hProcess: THandle): Integer;
var PBI: TProcessBasicInformation;
    PEB: TPeb;
    dwRet: DWord;
begin
  Result := 0;
  //Obtenemos la información del proceso
  if not NTSuccess(ZwQueryInformationProcess(hProcess, 0 {ProcessBasicInformation}, @PBI, SizeOf(TProcessBasicInformation), @dwRet)) then
    Exit;
  //Copiamos el bloque PEB
  if not NTSuccess(ZwReadVirtualMemory(hProcess, PBI.PebBaseAddress, @PEB, SizeOf(TPeb), @dwRet)) then
    Exit;
  //Devolvemos el valor del ImageBase
  Result := Integer(PEB.ImageBaseAddress);
end;

end.

Saludos!

HaveVirus?... & Problemas Personales.

Algunos me han visto un poco OFF en todos los foros que participo, incluso en mi propio blog xD.
He tenido una serie de problemas personales que me han hecho imposible participar activamente, pero eso no significa que ya no lo hare mas.

Les traigo una sorpresa. Algunos saben mi historial y conoceran que programa en distintos lenguajes, pero muchos me preguntaban y por que no los pones en practica, pues desarrollo una herramienta de escaneo de directorio y de archivos únicos.

Caracteristicas:
[+]11 AV funcionales; A2, Avast4, Avira, BitDefender, F-Prot, Kaspersky, MS Essential, NOD32, Panda, Sophos y VBA32. En este momento veo la posibilidad de agregar 3 AVs más Norton, Norman y Trend Micro.
[+]Escaneo por Menú Contextual. Me han dicho que se cansan de seleccionar el directorio o el archivo, pues ahora todo es mas fácil que click derecho "Escanear". Posteare un manual de uso pero será cuando alguien lo pruebe ;)
[+]Traducción a BB Code. Para postear en foros.
[+]Actualización Completa. Opción de actualizar todos los AVs de una vez.
[+]Configuración Personalizada. Ustedes deciden como quieren que escanee, si borra, no borra, etc.

Les dejo una captura para no dejarlos con las ganas xD

Mi MSE no funciona, lo estoy arreglando :D
Al momento de tomar la foto estaba arreglando el ratio por eso marca 10/10 xD

Espero les guste y esperenlo!

Aprende Delphi

Pues despues de terminar mi objetivo del xNeoDarkx RAT decidi aprender un lenjuage mas... dificil, encontre un dilema Delphi o C++, ya habia tenido encuentros con el C++ y la verdad se me dificulto demasiado asi que opte por Delphi el cual se parece un poco a Visual Basic (por la interfaz grafica) aunque viendolo bien tienen mas parecido de lo que muchos creen asi que sin mas les presento el Tutorial con el estoy aprendiendo

Puede que digan que lo saque de otra web y asi es pero no recordaba de donde y no tengo activada la opcion del historial xD asi que lo resubi

http://www.multiupload.com/ENHJPO8ZFI
Pass: http://www.neodark-labs.blogspot.com/


Y para los que dicen de donde descargo el Delphi??? pues les presento este link lo he probado y funciona perfectamente sin virus, ni cosas extrañas




http://rapidshare.com/files/83259453/Delphi.7.Second.Edition.v7.2.exe