Hola, aunque llevo unos meses atareado con varios proyectos, hay uno que terminé la v1.0 hace unas semanas. HackMyBugs es una app web vulnerable para practicar vulnerabilidades tanto por el lado del cliente como por el del servidor. Puse mucho esfuerzo en incluir algunas de las vulnerabilidades más comunes en esta área, así como en que aparecieran en un entorno "realista". Para más información, visiten el repo del proyecto:
https://github.com/infernoidpl4y/HackMyBugs

Gracias por leer .

Eres un crack

Muchas gracias 

En un contexto tan digitalizado como el nuestro, los estafadores encuentran cada vez más vías para ocultar sus engaños. Así, muchos de ellos se apoyan en la suplantación de organismos oficiales con el fin de ganar credivilidad. Mensajes fraudulentos, correos electrónicos y enlaces engañosos se han convertido en una herramienta habitual; y, para ello, se aprovechan de la falta de información o de la vulnerabilidad que les lleva a obtener los datos personales y bancarios de sus víctimas.

El Servicio Público de Empleo Estatal (SEPE) ha vuelto a advertir a la ciudadanía sobre una nueva estafa que está circulando a través de sus supuestas comunicaciones. En concreto, los ciberdelincuentes se hacen pasar por el organismo para contactar con personas desempleadas o beneficiarias de alguna prestación. El objetivo no es otro que el de robar información sensible. Por ello, desde el SEPE, insisten en la necesidad de extremar las precauciones y recuerdan que la entidad nunca solicita datos confidenciales fuera de sus canales oficiales.

Si, parche son actualizaciones.
Aunque segun leo, Windows 10 era azul , y windows 11 negro

https://www.digitalcitizen.life/ctrl-alt-delete/

Parches es actualizaciones ?

Y se pueden cambiar para tenerlo como antes ?

Saludos

A mi tambien me pasa, creo qie se debe a las ultimos parches.

Sigo intentando avanzar esto... Aquí algunas capturar con ejecutable x64... la calculadora de windows de ejemplo:



Secciones del ejecutable:



Un ojo a las funciones que importa:



Buscando funciones sospechosas:



Probando el  visor de Export Table en una DLL x64 (NTDLL.DLL):




El código practicamente esta ya ordenado en diferentes archivos en un proyecto en Code::Blocks, poco a poco lo iré avanzando segun tenga tiempo...

Si hay algún interesado en participar, ya sabeís. y para el que quiera probar esta versión tan primeriza dejo el ejecutable.


https://www.mediafire.com/file/3wqvx8h9acz8v5m/Visor_PE_compilado.rar/file

saludos.

Bueno, pues retomando un poco el maravilloso formato PE  Me estoy lanzando a crear un visor PE con GUI y con modo consola en C

Este es el código del modo consola 

// Sencillo Visor PE  Consola v0.1
// codigo por Fary
// foro.elhacker.net
 
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
 
int MostrarSecciones(void * Mapa); // Muestra los datos de las secciones
int MostrarImportaciones(void * Mapa); //Muestra las imports
int MostrarExportaciones(void * Mapa); // Muestra las exports
 
int RVAToOffset(int IDDVirtual, int ISHVirtual, int ISHRaw); // Convierte direccion virtual en offset fisico
DWORD AltRVAToOffset(DWORD RVA, void *Mapa); // AltRVAToOffset -> Convierte direccion virtual en offset fisico, version mejorada.
 
 
HANDLE Consola;
 
int main()
{
    HANDLE archivo;
    HANDLE marchivo;
    DWORD TamanoArchivo;
    LPVOID MapaArchivo;
    int Opcion = 0;
    char ruta[MAX_PATH] = {0};
 
    Consola = GetStdHandle(STD_OUTPUT_HANDLE);
    printf("Indica la ruta del archivo (La Ruta no puede tener espacios): \n");
    scanf("%s", &ruta);
 
    archivo = CreateFile(ruta, GENERIC_READ | GENERIC_WRITE,  0,0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); // abrimos el archivo EXE
 
    if(archivo == INVALID_HANDLE_VALUE)
    {
        printf("Error: No se pudo abrir el archivo.\n");
        return 1;
    }
 
    TamanoArchivo = GetFileSize(archivo,0);
 
    marchivo = CreateFileMappingA(archivo, 0 ,PAGE_READWRITE, 0, TamanoArchivo,0);
 
    if (marchivo == NULL)
    {
        printf("No se puede abrir el mapeo del archivo\n");
        CloseHandle(archivo);
        return 1;
    }
 
    MapaArchivo = MapViewOfFile(marchivo, FILE_MAP_ALL_ACCESS, 0, 0, 0);
 
    IMAGE_DOS_HEADER  * idh = (IMAGE_DOS_HEADER*)&MapaArchivo[0]; // Rellenamos el IMAGE_DOS_HEADER
 
    if (idh->e_magic != IMAGE_DOS_SIGNATURE)
    {
        printf("No es un PE Valido\n");
        CloseHandle(archivo);
        CloseHandle(marchivo);
        return 0;
    }
 
    IMAGE_NT_HEADERS * INTH = (IMAGE_NT_HEADERS*)&MapaArchivo[idh->e_lfanew];
 
    while(1)
    {
    system("CLS");
    if(INTH->FileHeader.Machine == IMAGE_FILE_MACHINE_I386) // Mostrador el parametro machine
    {
        printf("FileHeader->Machine: x86\n");
    }else if(INTH->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
    {
        printf("FileHeader->Machine: x64\n");
    }
 
    if (INTH->FileHeader.Characteristics == IMAGE_FILE_EXECUTABLE_IMAGE) // Characteristics
    {
        printf("FileHeader->Characteristics: EXE");
    }else if(INTH->FileHeader.Characteristics == IMAGE_FILE_DLL)
    {
        printf("FileHeader->Characteristics: DLL");
    }else if(INTH->FileHeader.Characteristics == IMAGE_FILE_32BIT_MACHINE)
    {
        printf("FileHeader->Characteristics: 32-Bit\n");
    }
 
    printf("FileHeader->NumberOfSections: 0x%x\n",INTH->FileHeader.NumberOfSections);
 
 
    printf("OptionaHeader->AddressOfEntryPoint: 0x%x\n", INTH->OptionalHeader.AddressOfEntryPoint);
    printf("OptionalHeader->ImageBase: 0x%x\n", INTH->OptionalHeader.ImageBase);
    printf("OptionalHeader->SectionAlignment: 0x%x\n",INTH->OptionalHeader.SectionAlignment);
    printf("OptionalHeader->FileAlignment: 0x%x\n",INTH->OptionalHeader.FileAlignment);
    printf("OptionalHeader->SizeOfImage: 0x%x\n", INTH->OptionalHeader.SizeOfImage);
    printf("OptionalHeader->SizeOfHeaders: 0x%x\n",INTH->OptionalHeader.SizeOfHeaders);
 
    printf("\nSelecciona que quieres hacer ahora: \n");
    printf("1 - Ver secciones.\n");
    printf("2 - Ver Import Table.\n");
    printf("3 - Ver Export Table.\n");
    printf("4 - Salir.\n->");
    scanf("%i", &Opcion);
 
    switch(Opcion)
    {
        case 1:
            system("CLS");
            MostrarSecciones(MapaArchivo);
            break;
        case 2:
            system("CLS");
            MostrarImportaciones(MapaArchivo);
            break;
        case 3:
            system("CLS");
            MostrarExportaciones(MapaArchivo);
            break;
        case 4:
            CloseHandle(archivo);
            CloseHandle(marchivo);
            return 0;
    }
    system("PAUSE");
    }
    return 0;
}
 
int MostrarExportaciones(void * Mapa)
{
    IMAGE_DOS_HEADER * IDH = (IMAGE_DOS_HEADER*)&Mapa[0];
    IMAGE_NT_HEADERS * INTH = (IMAGE_NT_HEADERS*)&Mapa[IDH->e_lfanew];
    IMAGE_SECTION_HEADER * ISH;
 
    IMAGE_DATA_DIRECTORY * IDD = (IMAGE_DATA_DIRECTORY*)&(INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]);
 
    if (IDD->VirtualAddress == 0)
    {
        printf("No hay ExportTable.\n");
        return 1;
    }
 
    int i;
 
 
    DWORD exportRaw = AltRVAToOffset(IDD->VirtualAddress, Mapa);
 
    IMAGE_EXPORT_DIRECTORY *IED = (IMAGE_EXPORT_DIRECTORY *)&Mapa[exportRaw];
 
    int a = AltRVAToOffset(IED->AddressOfNames, Mapa);
 
    DWORD * NombreFuncion = &Mapa[a];
 
    int e = AltRVAToOffset(IED->AddressOfFunctions, Mapa);
    DWORD * DirFuncion = &Mapa[e];
 
    int z = AltRVAToOffset(IED->AddressOfNameOrdinals, Mapa);
    WORD * Ordinal = &Mapa[z];
 
    for (i = 0; i < IED->NumberOfNames; i++)
    {
        DWORD nameOffset = AltRVAToOffset(NombreFuncion[i], Mapa);
        char * funcName = (char*)&Mapa[nameOffset];
 
        DWORD dirfun = DirFuncion[Ordinal[i]];
 
        printf("%s -> 0x%x\n",funcName, dirfun);
    }
 
    return 0;
}
 
int MostrarImportaciones(void * Mapa)
{
    system("CLS");
 
    IMAGE_DOS_HEADER * IDH = (IMAGE_DOS_HEADER*)&Mapa[0];
    IMAGE_NT_HEADERS * INTH = (IMAGE_NT_HEADERS*)&Mapa[IDH->e_lfanew];
    IMAGE_DATA_DIRECTORY * IDD = (IMAGE_DATA_DIRECTORY*)&(INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]);
    IMAGE_SECTION_HEADER * ISH;
 
    if (IDD->VirtualAddress == 0)
    {
        printf("No se encontro tabla de importaciones.\n");
        return 1;
    }
 
 
    int i;
 
    ISH = IMAGE_FIRST_SECTION(INTH);
 
    for (i = 0; i < INTH->FileHeader.NumberOfSections; i++)
    {
        //ISH = (IMAGE_SECTION_HEADER*)&Mapa[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
 
        if(IDD->VirtualAddress >= ISH[i].VirtualAddress && IDD->VirtualAddress < (ISH[i].VirtualAddress + ISH[i].Misc.VirtualSize))
        {
            break;
        }
    }
 
    DWORD Offset = AltRVAToOffset(IDD->VirtualAddress, Mapa);//DWORD Offset = RVAToOffset(IDD->VirtualAddress,ISH[i].VirtualAddress, ISH[i].PointerToRawData);//(IDD->VirtualAddress - ISH->VirtualAddress) + ISH->PointerToRawData;
 
    IMAGE_IMPORT_DESCRIPTOR * IID = (IMAGE_IMPORT_DESCRIPTOR*)&Mapa[Offset];
 
    while (IID->Name != NULL)
    {
        DWORD nameOffset = AltRVAToOffset(IID->Name, Mapa);//RVAToOffset(IID->Name, ISH[i].VirtualAddress, ISH[i].PointerToRawData);//(IID->Name - ISH->VirtualAddress) + ISH->PointerToRawData;
        char *dllName = (char*)&Mapa[nameOffset];
 
        SetConsoleTextAttribute(Consola, FOREGROUND_RED);
        printf("DLL: %s\n", dllName);
        SetConsoleTextAttribute(Consola, 0x0F);
 
        DWORD ThunkOffset = AltRVAToOffset(IID->OriginalFirstThunk,Mapa);//RVAToOffset(IID->OriginalFirstThunk,ISH[i].VirtualAddress, ISH[i].PointerToRawData);
        IMAGE_THUNK_DATA * ITD = (IMAGE_THUNK_DATA*)&Mapa[ThunkOffset];
 
        while (ITD->u1.AddressOfData != NULL)
        {
            DWORD dirNombreFuncion = AltRVAToOffset(ITD->u1.AddressOfData, Mapa);//RVAToOffset(ITD->u1.AddressOfData,ISH[i].VirtualAddress, ISH[i].PointerToRawData);
            IMAGE_IMPORT_BY_NAME *IIBN = (IMAGE_IMPORT_BY_NAME*)&Mapa[dirNombreFuncion];
            printf("Funcion: %s\n",IIBN->Name);
            ITD++;
        }
 
        IID++;
    }
    return 0;
 
}
 
 
DWORD AltRVAToOffset(DWORD RVA, void *Mapa)
{
    BYTE *base = (BYTE *)Mapa;
 
    IMAGE_DOS_HEADER *IDH = (IMAGE_DOS_HEADER *)base;
    IMAGE_NT_HEADERS *INTH =
        (IMAGE_NT_HEADERS *)(base + IDH->e_lfanew);
 
    IMAGE_SECTION_HEADER *ISH =
        IMAGE_FIRST_SECTION(INTH);
 
    // Caso: RVA en headers
    if (RVA < INTH->OptionalHeader.SizeOfHeaders)
        return RVA;
 
    for (WORD i = 0; i < INTH->FileHeader.NumberOfSections; i++)
    {
        DWORD va   = ISH[i].VirtualAddress;
        DWORD size = max(ISH[i].Misc.VirtualSize,
                          ISH[i].SizeOfRawData);
 
        if (RVA >= va && RVA < va + size)
        {
            return (RVA - va) + ISH[i].PointerToRawData;
        }
    }
 
    // No encontrado
    return 0;
}
 
int RVAToOffset(int IDDVirtual, int ISHVirtual, int ISHRaw)
{
    return ((IDDVirtual - ISHVirtual) +  ISHRaw);
}
 
int MostrarSecciones(void * Mapa)
{
    IMAGE_DOS_HEADER * IDH = (IMAGE_DOS_HEADER*)&Mapa[0];
    IMAGE_NT_HEADERS * INTH = (IMAGE_NT_HEADERS*)&Mapa[IDH->e_lfanew];
 
 
    IMAGE_SECTION_HEADER * ISH = IMAGE_FIRST_SECTION(INTH);
 
    int i;
    for (i = 0; i < INTH->FileHeader.NumberOfSections; i++)
    {
        SetConsoleTextAttribute(Consola, FOREGROUND_RED);
        printf("Name: %.8s\n", ISH[i].Name);
        SetConsoleTextAttribute(Consola, 0x0F);
        printf("VirtualAddress: 0x%x\n", ISH[i].VirtualAddress);
        printf("SizeOfRawData: 0x%x\n",ISH[i].SizeOfRawData);
        printf("PointerToRawData: 0x%x\n",ISH[i].PointerToRawData);
    }
 
    return 0;
}
 

Se aceptan sugerencias de mejora y gente que quiera aprender junto a mí.

saludos.