Mensajes

era una simple mencion alos quilmes que desarrollaban antiguamente los hackers
como un tributo grande capitancrunch
si es cierto que hoy en dia el scriptinq es muy recomendado te doy la razon
peor se han hecho autenticos destroyers en batch 

¡Tío, primero lo del exploit del Avast y ahora esto!
Vamos a ver: ¿Vienes, nos pones un code que no funcionaría nunca y luego cuando te digo que no sirve para nada vas y sueltas eso?
Y los hackers ni han hecho ni hacen ni harán eso nunca, en el sentido literal.
Y vaya super destroyers... Me río de ellos. Vaya tiempos los que corren Una cosa es VBS y otra Batch

Si, si eso funciona yo me llamo Quijote, el de la Mancha
Donde lo has leído? Penoso, lo único que harás será cargarte el mfc90loc.dll original 

Yo de ti me dejaría de tonterías y me pondría a aprender algo...

Hola a todos, hace tiempo que no se que hacer..
ahora estoy en 2º de un grado medio de informatica... y ahora que este año acabo, pues empiezo a dudar de lo que estudiar en el futuro.
Estoy pensando en hacer el Bachiller y luego hacer la ingenieria informatica o hacer la prueba de acceso y hace la FP superior. (he de añadir que yo de mates, voy un poco justo he estado viendo por internet eso de la ingieneria y he leido que hacen mates obligatorias y nose)
Bueno la question es que no se que estudiar. Cual de las 2 opciones tiene mas salida? o estudiar bachiller o hacer la prueba de acceso?
que me aconsejais¿?
un saludo!

Pues yo te recomendaría Bachiller. Yo lo haré cuando me toque y mientras...
Te lo digo porque parece tener más salidas... Ni idea

Mmm lo estabas haciendo bien...

Código [Seleccionar] Expandir


# groupmod -g 995 admin

Admin se deja o se sustituye por el grupo en cuestión. Ponle mejor tu nombre de usuario original

Pues precisamente uso 9.04 e Iván la gama 10 así que no habrá problemas jaja...

[Sagrini]

ok sangrini gracias por anotarme , ahora porfavor dime que software  necesito tener instalado Linux que mas? el linux cual me recomiendan

Wow, nuevo nombre: Sangrini Sagrini!!!
Pues linux e internet
Si eso te podrias hacer un Skype, pero aun no sabemos fijo donde lo hacemo :-o Ivan está ultimamente off 

[quote author=nsigned link=topic=319040.msg1578662#msg1578662 date=1297269389]
Creo que todos deberíamos adoptar el full disclosure... hace que todo avance mas rápido en (in)seguridad informática...
[/quote]

No estoy de acuerdo, yo lo que haría es básicamente lo que han hecho ellos. Publicarlo "tapando" datos y hablando con la compañía. Me satisface mucho más que ver a un lammer usando mis herramientas...

Es 23:59 hora española, o sea mañana, porque a las doce no estaré conectado jeje...

Bueno en un post vi que como requisito minimo tenia que tener instalado linux algo asi yo no se usar linux ni mucho menos he programado en C pero se programar en otros lenguajes  quiero entrar al curso si se puede aun y me aceptan asi si no seria para la otra??

Si se puede, con tu permiso te apunto . Yo de ti probaria linux, y si no...
1) Máquina virtual.
2) Server ssh (no siempre disponible :-o)
Lo de los conocimientos se puede arreglar, lee un minimo y el punto 0...

bien descargue la primera entrega
pero hay algun topic para ponr dudas, que  a mi no me va  los comandos del nasm:

Código (bash) [Seleccionar] Expandir


$ ld -m elf_i386 -o testasm testasm
testasm: file not recognized: File truncated


Yeah, una descarga!
El topic de dudas se abrirá más tarde, el punto cero no tendrá PWP ni conferencia ni post. Toda duda por pm...

Código [Seleccionar] Expandir


nano code.s
[Se abre nano y escribes...]
nasm -f elf -o code.o code
ld -m elf_i386 -o code code.o
./code

Prueba así...  Ese punto lo escribí sin probarlo en el momento, pero de todos modos me va...
Suerte!

Ryan, tu primer comentario...
Sí, con un sistema linux te vienen instalados tanto bash como sh, no será problema...

Pues este code es de John Ericson...
1. Code sniffer
2. Hacking-network.h
3. Hacking.h
Todos los codes...

Código (c) [Seleccionar] Expandir


#include <pcap.h>
#include "hacking.h"
#include "hacking-network.h"

void pcap_fatal(const char *, const char *);
void decode_ethernet(const u_char *);
void decode_ip(const u_char *);
u_int decode_tcp(const u_char *);

void caught_packet(u_char *, const struct pcap_pkthdr *, const u_char *);

int main() {
struct pcap_pkthdr cap_header;
const u_char *packet, *pkt_data;
char errbuf[PCAP_ERRBUF_SIZE];
char *device;

pcap_t *pcap_handle;

device = pcap_lookupdev(errbuf);
if(device == NULL)
pcap_fatal("pcap_lookupdev", errbuf);

printf("Sniffing on device %s\n", device);

pcap_handle = pcap_open_live(device, 4096, 1, 0, errbuf);
if(pcap_handle == NULL)
pcap_fatal("pcap_open_live", errbuf);

pcap_loop(pcap_handle, 3, caught_packet, NULL);

pcap_close(pcap_handle);
}

void caught_packet(u_char *user_args, const struct pcap_pkthdr *cap_header, const u_char *packet) {
int tcp_header_length, total_header_size, pkt_data_len;
u_char *pkt_data;

printf("==== Got a %d byte packet ====\n", cap_header->len);


decode_ethernet(packet);
decode_ip(packet+ETHER_HDR_LEN);
tcp_header_length = decode_tcp(packet+ETHER_HDR_LEN+sizeof(struct ip_hdr));

total_header_size = ETHER_HDR_LEN+sizeof(struct ip_hdr)+tcp_header_length;
pkt_data = (u_char *)packet + total_header_size;  // pkt_data points to the data portion
pkt_data_len = cap_header->len - total_header_size;
if(pkt_data_len > 0) {
printf("\t\t\t%u bytes of packet data\n", pkt_data_len);
dump(pkt_data, pkt_data_len);
} else
printf("\t\t\tNo Packet Data\n");
}

void pcap_fatal(const char *failed_in, const char *errbuf) {
printf("Fatal Error in %s: %s\n", failed_in, errbuf);
exit(1);
}

void decode_ethernet(const u_char *header_start) {
int i;
const struct ether_hdr *ethernet_header;

ethernet_header = (const struct ether_hdr *)header_start;
printf("[[  Layer 2 :: Ethernet Header  ]]\n");
printf("[ Source: %02x", ethernet_header->ether_src_addr[0]);
for(i=1; i < ETHER_ADDR_LEN; i++)
printf(":%02x", ethernet_header->ether_src_addr[i]);

printf("\tDest: %02x", ethernet_header->ether_dest_addr[0]);
for(i=1; i < ETHER_ADDR_LEN; i++)
printf(":%02x", ethernet_header->ether_dest_addr[i]);
printf("\tType: %hu ]\n", ethernet_header->ether_type);
}

void decode_ip(const u_char *header_start) {
const struct ip_hdr *ip_header;

ip_header = (const struct ip_hdr *)header_start;
printf("\t((  Layer 3 ::: IP Header  ))\n");
printf("\t( Source: %s\t", inet_ntoa(ip_header->ip_src_addr));
printf("Dest: %s )\n", inet_ntoa(ip_header->ip_dest_addr));
printf("\t( Type: %u\t", (u_int) ip_header->ip_type);
printf("ID: %hu\tLength: %hu )\n", ntohs(ip_header->ip_id), ntohs(ip_header->ip_len));
}

u_int decode_tcp(const u_char *header_start) {
u_int header_size;
const struct tcp_hdr *tcp_header;

tcp_header = (const struct tcp_hdr *)header_start;
header_size = 4 * tcp_header->tcp_offset;

printf("\t\t{{  Layer 4 :::: TCP Header  }}\n");
printf("\t\t{ Src Port: %hu\t", ntohs(tcp_header->tcp_src_port));
printf("Dest Port: %hu }\n", ntohs(tcp_header->tcp_dest_port));
printf("\t\t{ Seq #: %u\t", ntohl(tcp_header->tcp_seq));
printf("Ack #: %u }\n", ntohl(tcp_header->tcp_ack));
printf("\t\t{ Header Size: %u\tFlags: ", header_size);
if(tcp_header->tcp_flags & TCP_FIN)
printf("FIN ");
if(tcp_header->tcp_flags & TCP_SYN)
printf("SYN ");
if(tcp_header->tcp_flags & TCP_RST)
printf("RST ");
if(tcp_header->tcp_flags & TCP_PUSH)
printf("PUSH ");
if(tcp_header->tcp_flags & TCP_ACK)
printf("ACK ");
if(tcp_header->tcp_flags & TCP_URG)
printf("URG ");
printf(" }\n");

return header_size;
}


Código (c) [Seleccionar] Expandir


/* This function accepts a socket FD and a ptr to the null terminated
* string to send.  The function will make sure all the bytes of the
* string are sent.  Returns 1 on success and 0 on failure.
*/
int send_string(int sockfd, unsigned char *buffer) {
   int sent_bytes, bytes_to_send;
   bytes_to_send = strlen(buffer);
   while(bytes_to_send > 0) {
      sent_bytes = send(sockfd, buffer, bytes_to_send, 0);
      if(sent_bytes == -1)
         return 0; // return 0 on send error
      bytes_to_send -= sent_bytes;
      buffer += sent_bytes;
   }
   return 1; // return 1 on success
}

/* This function accepts a socket FD and a ptr to a destination
* buffer.  It will receive from the socket until the EOL byte
* sequence in seen.  The EOL bytes are read from the socket, but
* the destination buffer is terminated before these bytes.
* Returns the size of the read line (without EOL bytes).
*/
int recv_line(int sockfd, unsigned char *dest_buffer) {
#define EOL "\r\n" // End-Of-Line byte sequence
#define EOL_SIZE 2
   unsigned char *ptr;
   int eol_matched = 0;

   ptr = dest_buffer;
   while(recv(sockfd, ptr, 1, 0) == 1) { // read a single byte
      if(*ptr == EOL[eol_matched]) { // does this byte match terminator
         eol_matched++;
         if(eol_matched == EOL_SIZE) { // if all bytes match terminator,
            *(ptr+1-EOL_SIZE) = '\0'; // terminate the string
            return strlen(dest_buffer); // return bytes recevied
         }
      } else {
         eol_matched = 0;
      }   
      ptr++; // increment the pointer to the next byter;
   }
   return 0; // didn't find the end of line characters
}


/* Structure for Ethernet headers */
#define ETHER_ADDR_LEN 6
#define ETHER_HDR_LEN 14

struct ether_hdr {
   unsigned char ether_dest_addr[ETHER_ADDR_LEN]; // Destination MAC address
   unsigned char ether_src_addr[ETHER_ADDR_LEN];  // Source MAC address
   unsigned short ether_type; // Type of Ethernet packet
};

/* Structure for Internet Protocol (IP) headers */
struct ip_hdr {
   unsigned char ip_version_and_header_length; // version and header length combined
   unsigned char ip_tos;          // type of service
   unsigned short ip_len;         // total length
   unsigned short ip_id;          // identification number
   unsigned short ip_frag_offset; // fragment offset and flags
   unsigned char ip_ttl;          // time to live
   unsigned char ip_type;         // protocol type
   unsigned short ip_checksum;    // checksum
   unsigned int ip_src_addr;      // source IP address
   unsigned int ip_dest_addr;     // destination IP address
};

/* Structure for Transmission Control Protocol (TCP) headers */
struct tcp_hdr {
   unsigned short tcp_src_port;   // source TCP port
   unsigned short tcp_dest_port;  // destination TCP port
   unsigned int tcp_seq;          // TCP sequence number
   unsigned int tcp_ack;          // TCP acknowledgement number
   unsigned char reserved:4;      // 4-bits from the 6-bits of reserved space
   unsigned char tcp_offset:4;    // TCP data offset for little endian host
   unsigned char tcp_flags;       // TCP flags (and 2-bits from reserved space)
#define TCP_FIN   0x01
#define TCP_SYN   0x02
#define TCP_RST   0x04
#define TCP_PUSH  0x08
#define TCP_ACK   0x10
#define TCP_URG   0x20
   unsigned short tcp_window;     // TCP window size
   unsigned short tcp_checksum;   // TCP checksum
   unsigned short tcp_urgent;     // TCP urgent pointer
};


Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// A function to display an error message and then exit
void fatal(char *message) {
   char error_message[100];

   strcpy(error_message, "[!!] Fatal Error ");
   strncat(error_message, message, 83);
   perror(error_message);
   exit(-1);
}

// An error checked malloc() wrapper function
void *ec_malloc(unsigned int size) {
   void *ptr;
   ptr = malloc(size);
   if(ptr == NULL)
      fatal("in ec_malloc() on memory allocation");
   return ptr;
}

// dumps raw memory in hex byte and printable split format
void dump(const unsigned char *data_buffer, const unsigned int length) {
unsigned char byte;
unsigned int i, j;
for(i=0; i < length; i++) {
byte = data_buffer[i];
printf("%02x ", data_buffer[i]);  // display byte in hex
if(((i%16)==15) || (i==length-1)) {
for(j=0; j < 15-(i%16); j++)
printf("   ");
printf("| ");
for(j=(i-(i%16)); j <= i; j++) {  // display printable bytes from line
byte = data_buffer[j];
if((byte > 31) && (byte < 127)) // outside printable char range
printf("%c", byte);
else
printf(".");
}
printf("\n"); // end of the dump line (each line 16 bytes)
} // end if
} // end for
}



Va como la seda
Suerte!

Wow que de opiniones :-o

Bueno, yo creo que todo lo que pienso lo resume Spider-Net aquí:

Como ya dije al principio de este post Constance, cuidarse no es maquillarse. Me gustan las chicas que se cuidan, no me gustan que sean unas dejadas, al igual que a las chicas no les gustan los tios dejados, pero una cosa es cuidarse y otra maquillarse tanto que parezcas otra persona, yo opino como Og, lo natural se ve más saludable y a mí me resulta mucho más atractiva una mujer que se cuide y se maquille poco que una que se cuide y se maquille mucho.
Me quedo también con la chica de la derecha Og. Y a diferencia de lo que han comentado algunos por aquí, me quedo con la de la derecha tanto para algo serio como para una noche loca, me gusta mucho más. Y por supuesto va maquillada, pero no en exceso así que se ve muy natural, lo que la hace para mi gusto super atractiva y guapísima.

Lo primero es completamente respaldado por mí jeje...
Lo segundo... Vamos a ver, la primera lo único que da es asco. No digo más... O sí: ¿Como puede alguien hacerse algo así en el cuerpo?
Y la segunda...

Me quedo también con la chica de la derecha Og. Y a diferencia de lo que han comentado algunos por aquí, me quedo con la de la derecha tanto para algo serio como para una noche loca, me gusta mucho más. Y por supuesto va maquillada, pero no en exceso así que se ve muy natural, lo que la hace para mi gusto super atractiva y guapísima.

Voilá!