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

[-]Estructura de proceso y los módulos.

Como se ha dicho la ImageBase de un proceso, normalmente, es 0x400000 pero que hay antes de esa dirección bueno a grandes rasgos estan estructuras importantes algunas solo son accesibles desde modo kernel como la KPROCESS, EPROCESS, ETHREAD, KTHREAD y otras que necesitan permisos de administrador para accesar a ella como es la PEB y la TEB. A continuación se dará una pequeña explicación de cada una.
[*]EPROCESS. Contiene datos importantes del proceso, punteros otras estructuras ya mencionadas.
[*]KPROCESS. Es también llamada PCB contiene datos del stack es actualizada cada vez que el tiempo de uso del procesador de un proceso se ha agotado. Aunque no lo parezca el SO asigna un pequeño tiempo a cada proceso para que haga uso del procesador, este tiempo suele ser 10 a 100 nanosegundos dependiendo de la prioridad del proceso y al terminar ese tiempo se actualiza la PCB del proceso con los últimos valores.
[*]ETHREAD. Como sabemos en un proceso puede tener varios threads activos y cada thread tiene su propia tabla.
[*]KTHREAD. Tiene un puntero a la estructura TEB entre otros puntos.
[*]PEB. Contiene información del archivo orientada a los archivos y módulos activos, como el nombre del proceso, ruta del archivo, entrada al primer módulo, entre otras cosas.
[*]TEB. Contiene información del hilo, el PID del proceso al cual pertenece, el último error producido por el thread, etc.

Hasta aquí es una introducción a las estructuras si quieren profundizar mas en el tema los invito a leer el siguiente PDF contiene una explicación mas amplia de como inicia un proceso.
http://www.alex-ionescu.com/part1.pdf

Y en este link pueden encontrar las declaraciones de estructuras en C, bueno pueden encontrar gran parte de las estructuras de ring0.
http://www.nirsoft.net/kernel_struct/vista/

En este punto existe un espacio vacío ya que los bloques no ocupan mucho espacio, gracias a ello es posible mover la ImageBase cuando compilamos el proyecto o con alguna herramienta, en caso de que ImageBase + SizeOfImage ya este ocupada el Loader hace una Relocation que por ahora no entraremos en ese tema.

Una vez que termino la ImageBase, siguen todos los módulos cargados por el Loader alineados según sus propias cabeceras, se ha de recordar que las DLL y los EXE tienen la misma estructura solo que con diferentes flags activas.

En la próxima entrega comenzaremos con lo interesante, lo termino aquí porqué espero que la próxima entrada sea larga y no quiero fastidiar con la lectura.
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!

HashDB en crecimiento.

Ultimamente he tenido my descuidado el blog, debido a que tenía proyectos y se me ha olvidado xD.
Esta vez les traigo esta base de datos de Hash en MD5, actualemten tenemos mas de 1,500,000 de hashe (Relativamente pequeño) pero sigue creciendo, pronto implementare un sistema de usuarios con crackeo, lo que resultará en que les desencriptamos sus hashes :)

Entrada a la base de datos

Saludos!

ChromeBook y Chrome OS

El dia de hoy despierto y procedo a inciar mi navegador, cosa de rutina y me encuentro con una aviso de Google Chrome "Nuevas Chromebook, compralas ahora", la verdad si me interese en ellas revisando precios, creo que estan dentro de un rango razonable.
[-]$349.99 para la NoteBook con Wifi
[-]$449.99 para la NoteBook con 3G.

Su informacion tecnica

Samsung Series 5 XE500C21-A01US Wi-Fi Chromebook
Intel Atom N570 1.66GHz
2GB DDR3
16GB SSD
12.1" Display
6-Cell, 8.5 Hour Battery Life
Google Chrome OS
White or Silver

Comence a buscar mas información y bueno cito textualmente algunas partes de la pagina oficial.

Los Chromebook están diseñados para mejorar con las actualizaciones automáticas. Algunas de las últimas actualizaciones incluyen:
Nueva pantalla de inicio de sesión
La página de inicio de sesión de los Chromebook ahora incluye un proceso de verificación en dos pasos para aquellos que habiliten esta función de seguridad.
Aplicaciones sin conexión
Con Gmail sin conexión y otras aplicaciones que funcionan sin conexión, ahora puedes sacar más partido a tu Chromebook incluso cuando no te hayas conectado a Internet.
Compatibilidad con NTFS
Ahora los Chromebook admiten unidades con el sistema de archivos NTFS, por lo que te resultará más fácil conectarlos a dispositivos de almacenamiento externo.

Para seguir leyendo: http://www.google.com/intl/es/chromebook/#features

Mi siguiente pregunta fue ¿Que S.O. usa?, ¿usaron algún otro S.O. como base para desarrollarlo, si es su S.O. propio?
Pues bueno mi pregunta no duro mucho estas NoteBooks usan el Chrome OS
Lo demas se los dejo de la Wikipedia xD

Google Chrome OS es un proyecto llevado a cabo por la compañía Google para desarrollar un sistema operativo basado en web. A través de su blog oficial, Google anunció el 7 de julio de 2009 que Google Chrome OS será un sistema realizado con base en código abierto (Núcleo Linux) y orientado inicialmente para miniportátiles, estando disponible en junio de 2011. Funcionará sobre microprocesadores con tecnología x86 o ARM.
Google ha declarado que el código fuente del proyecto Google Chrome OS fue liberado en noviembre de 2009 bajo el proyecto «Chromium OS», para incorporar la colaboración de la comunidad de software libre y ayudar en el desarrollo del proyecto.

Mas información: http://es.wikipedia.org/wiki/Google_Chrome_OS

Personalmente, no me agrada la idea de un S.O. basado en web pues te limita demasiado si tu banda es limitada o tu conexión no es la mejor, pero bueno veamos si les funciona esta nueva apuesta en el mercado.

Les dejo un video donde se muestra su funcionamiento:
http://www.youtube.com/watch?v=XeKMbGnSmYc

Pre-PMA 2.5.Beta

Hola usuarios,
Es hora de actualizar este gran AV, pero para eso necesitamos de su ayuda. Tenemos planeado grandes pasos y para eso necesitamos asegurar los pequeños.
¿A que me refiero? pues necesitamos que prueben un DLL que acompañará la nueva verión 2.5.Beta

Solo necesitan llenar los TextBox del ejecutable "Project1.exe" el primero con la ruta del archivo "Firmas1.pau" y el segundo con la ruta del archivo prueba ya sea el archivo "test.exe" o "test-lite.exe".
Después comentar este hilo diciendo su S.O. y el uso de su RAM y CPU al momento de la prueba ademas de si surgio algún percance ya sea un error, un "No Responde", etc.

Contamos con ustedes y esperen la nueva version que esta proxima y con grandes sorpresas!

www.multiupload.com/W0JOB9RP6F