Resulta que he comprado un portatil nuevo, concretamente un Lenovo G580 con un i7 y 8GB de RAM  

Pero el problema es que no reconoce la tarjeta de red, y los drivers que proporciona el fabricante no funcionan  

En fin, alguna idea?

Saludos y gracias de antemano!

Edito: Solucionado, hay que conectar el portatil a internet con cable o una tarjeta externa e ir a Sistema->Administracion->Controladores de Hardware, descargarlo todo e instalar y listo.

Bueno pues esa es la pregunta... Por ejemplo he visto que C te permite hacer cosas a bajo nivel sin tener que usar ASM, que en Visual Basic o Delphi es sencillo crear interfaces graficas, que Java tiene muchas cosas de alto nivel y es muy portable...

Bueno os dejo a vosotros que sigais  

PD: Tambien estaria bien que digais que valorais de un IDE o entorno de desarrollo.
PD2: Si alguien dice algo sobre debuggers, tambien estaria bien  

He encontrado una implementacion de strlen en ASM, podriais ayudarme a entenderla?

; Will return the length of a null-terminated string
; The result will be written to ECX
;
; Usage:
; hello_tmp db "test",0
; ...
; ccall   strlen, hello_tmp
proc  strlen, strInput
 mov ecx,-1
 mov al,0
 mov edi,[strInput]
 cld
 repne scasb
 not ecx
 dec ecx
 ret
endp

Enlace: http://www.betamaster.us/blog/?p=471

Saludos.

Bueno de casualidad encontre este tutorial: http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html y al probar un ejemplo, concretamente este:

ehdr:                                                 ; Elf32_Ehdr
                db      0x7F, "ELF", 1, 1, 1, 0         ;   e_ident
        times 8 db      0
                dw      2                               ;   e_type
                dw      3                               ;   e_machine
                dd      1                               ;   e_version
                dd      _start                          ;   e_entry
                dd      phdr - $$                       ;   e_phoff
                dd      0                               ;   e_shoff
                dd      0                               ;   e_flags
                dw      ehdrsize                        ;   e_ehsize
                dw      phdrsize                        ;   e_phentsize
                dw      1                               ;   e_phnum
                dw      0                               ;   e_shentsize
                dw      0                               ;   e_shnum
                dw      0                               ;   e_shstrndx
 
  ehdrsize      equ     $ - $$
 
  phdr:                                                 ; Elf32_Phdr
                dd      1                               ;   p_type
                dd      0                               ;   p_offset
                dd      $$                              ;   p_vaddr
                dd      $$                              ;   p_paddr
                dd      filesize                        ;   p_filesz
                dd      filesize                        ;   p_memsz
                dd      5                               ;   p_flags
                dd      0x1000                          ;   p_align
 
  phdrsize      equ     $ - phdr
 
  _start:
                mov     ebx, 0
                xor     eax, eax
                inc     eax
                int     0x80
 
 
  filesize      equ     $ - $$

En el que se reduce el tamaño del ejecutable a 91 bytes, el programa termina por una señal SIGTERM, si alguien me pudiera decir que porque falla?

Saludos.

Bueno aqui os dejo esta pequeña herramienta que he hecho para ver algunos datos sobre los simbolos de una libreria dinamica o un ejecutable ELF: http://es.wikipedia.org/wiki/Executable_and_Linkable_Format

Cualquier pregunta, comentario o critica constructiva posteen 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <elf.h>
 
int main(int argc, char **argv)
{
 
 char *shstrtabdata, *strtabdata, *dynstrdata;
 int i, off;
 bool strtabf=true, symtabf=true, dynsymf=true;
 
 size_t ret;
 
 Elf32_Ehdr *hdr = malloc(sizeof(Elf32_Ehdr));
 Elf32_Shdr shdr, shstrtab, strtab, dynsym, dynstr;
 Elf32_Sym sym;
 
 FILE *dyn = fopen(argv[1], "rb");
 if(!dyn)
 {
  perror("fopen");
  exit(1);
 }
 
 fread(hdr, sizeof(Elf32_Ehdr), 1, dyn);
 fseek(dyn, hdr->e_shoff+hdr->e_shentsize*hdr->e_shstrndx, SEEK_SET);
 fread(&shstrtab, sizeof(shstrtab), 1, dyn);
 shstrtabdata = malloc(shstrtab.sh_size);
 if(!shstrtabdata)
 {
  perror("malloc");
  exit(2);
 }
 fseek(dyn, shstrtab.sh_offset, SEEK_SET);
 fread(shstrtabdata, 1, shstrtab.sh_size, dyn);
 fseek(dyn, hdr->e_shoff, SEEK_SET);
 
 fwrite(shstrtabdata, 1, shstrtab.sh_size, stdin);
 
 for(i=0; i<hdr->e_shnum; i++)
 {
  fread(&shdr, sizeof(shdr), 1, dyn);
  if(!strcmp(shstrtabdata+shdr.sh_name, ".symtab"))
  {
   printf(".symtab encontrada: offset: 0x%x\n", shdr.sh_offset);
   printf("Tamaño de .symtab: %d\n", shdr.sh_size);
   printf("Numero de sym headers: %f\n", (float) shdr.sh_size/(float) sizeof(Elf32_Sym));
   symtabf = false;
   break;
  }
 }
 
 if(symtabf)
 {
  printf("sección .symtab no encontrada.\n");
 }
 
 fseek(dyn, hdr->e_shoff, SEEK_SET);
 
 for(i=0; i<hdr->e_shnum; i++)
 {
  fread(&dynsym, sizeof(dynsym), 1, dyn);
  if(!strcmp(shstrtabdata+dynsym.sh_name, ".dynsym"))
  {
   printf(".dynsym encontrada: offset: 0x%x\n", dynsym.sh_offset);
   dynsymf=false;
   break;
  }
 }
 
 fseek(dyn, hdr->e_shoff, SEEK_SET);
 
 for(i=0; i<hdr->e_shnum; i++)
 {
  fread(&dynstr, sizeof(dynstr), 1, dyn);
  if(!strcmp(shstrtabdata+dynstr.sh_name, ".dynstr"))
  {
   printf(".dynstr encontrada: offset: 0x%x\n", dynstr.sh_offset);
   printf("Tamaño de .dynstr: 0x%x\n", dynstr.sh_size);
   break;
  }
 }
 
 dynstrdata = malloc(dynstr.sh_size);
 if(!dynstrdata)
 {
  perror("malloc");
  exit(5);
 }
 
 fseek(dyn, dynstr.sh_offset, SEEK_SET);
 ret = fread(dynstrdata, 1, dynstr.sh_size, dyn);
 
 fseek(dyn, hdr->e_shoff, SEEK_SET);
 
 for(i=0; i<hdr->e_shnum; i++)
 {
  fread(&strtab, sizeof(strtab), 1, dyn);
  if(!strcmp(shstrtabdata+strtab.sh_name, ".strtab"))
  {
   printf(".strtab encontrada: offset: 0x%x\n", strtab.sh_offset);
   strtabf = false;
   break;
  }
 }
 
 if(strtabf)
 {
  printf("sección .strtab no encontrada.\n");
 }
 
 
 if(!strtabf)
 {
  strtabdata = malloc(strtab.sh_size);
  if(!strtabdata)
  {
   perror("malloc");
   exit(3);
  }
  fseek(dyn, strtab.sh_offset, SEEK_SET);
  ret=fread(strtabdata, 1, strtab.sh_size, dyn);
  if(ret!=strtab.sh_size)
  {
    perror("fread");
    exit(4);
  }
 }
 
 
  fseek(dyn, shdr.sh_offset, SEEK_SET);
 
 
 if(!symtabf)
 {
  printf("***Symtab***\n\n");
  i=0;
  while(shdr.sh_size>i)
  {
   ret=fread(&sym, sizeof(sym), 1, dyn);
   i+=sizeof(sym);
   printf("%s\n", strtabdata+sym.st_name);
   printf("Direccion: 0x%x\t", sym.st_value);
   printf("Tamaño: 0x%x\t", sym.st_size);
   if(sym.st_info & STT_NOTYPE) printf("Tipo no definido\t");
   if(sym.st_info & STT_OBJECT) printf("Data object\t");
   if(sym.st_info & STT_FUNC) printf("Funcion\t");
   if(sym.st_info & STT_FILE) printf("Fichero fuente\t");
   printf("\n");
  }
  printf("Numero de simbolos: %d\n", i/16); 
 }
 
 fseek(dyn, dynsym.sh_offset, SEEK_SET);
 
 if(!dynsymf)
 {
  printf("***Dynsym***\n\n");
  i=0;
  while(dynsym.sh_size>i)
  {
   ret=fread(&sym, sizeof(sym), 1, dyn);
   i+=sizeof(sym);
   printf("%s\n", dynstrdata+sym.st_name);
   printf("Direccion: 0x%x\t", sym.st_value);
   printf("Tamaño: 0x%x\t", sym.st_size);
   if(sym.st_info & STT_NOTYPE) printf("Tipo no definido\t");
   if(sym.st_info & STT_OBJECT) printf("Data object\t");
   if(sym.st_info & STT_FUNC) printf("Funcion\t");
   if(sym.st_info & STT_FILE) printf("Fichero fuente\t");
   printf("\n");
  }
  printf("Numero de simbolos: %d\n", i/16);
 }
 
 if(!strtabf) free(strtabdata);
 free(shstrtabdata);
 if(!dynsymf) free(dynstrdata);
 
 return 0;
 
}

El modo de uso es tan simple como pasarle como argumento la ruta del archivo a analizar.

Saludos!

Bueno comparto esta pelicula con vosotros porque me parece que te hace reflexionar sobre el sistema educativo actual, y eso es algo que, si la base de la sociedad es la educacion, es urgente.

La pelicula esta licenciada bajo Creative Commons, cosa que aplaudo.

Bueno disfrutenla, reflexionen y comenten!

Bueno estoy haciendo un pequeño crypter, y tengo que hardcodear un push. Tengo que meter en la pila un puntero al entrypoint del ejecutable, y desensamblando un programa simple para ver cual es el opcode de un push me doy cuenta de que detras del opcode (0x68) se pone el valor que se quiere empujar, pero con los bytes al reves. Entonces un codigo simple como este:

push 0x80484ee

Genera:

68 ee 84 04 08

Entonces como puedo, en C o en ASM, darle la vuelta a una direccion de memoria para hardcodear un push?

Puede que ya se hayan dado cuenta pero miren los estados de sus contactos en whatsapp...

Hola!

Veran estoy haciendo un pequeño codigo en asm que debe comprobar si se tienen permisos de root y si los tiene cargar un modulo del kernel. Al parecer hay una syscall que lo hace, la 0x31, pero he optado por llamar a la funcion de C(http://www.kernel.org/doc/man-pages/online/pages/man2/init_module.2.html). Tengo dos problemas:

-No se el tamaño de la struct image, y no lo encuentro por ninguna parte.
-No se con que hay que linkar o que hay que hacer para hacer un call a init_module, el assembler (nasm) me dice: 'symbol "init_module" undefined'.

Y en realidad tengo otro, y es que no se si tengo que rellenar la estructura o algo, no hay ejemplos ni nada, pero con eso ya me apaño.

extern init_module
section .text
 global _start
 
_start:
 
xor eax,eax
add eax,0x31
int 0x80
test eax,eax
jz init
 
exit:
xor eax,eax
inc eax
xor ebx,ebx
or ebx,eax
int 0x80
 
init:
xor eax,eax
or eax,80
add eax,48
push image
jmp n
m:
call init_module
jmp exit
 
n:
call m
name: 
db "mylkm.o",0
 
 
 
section .bss
 
image: resb (tamanio de struct image)

Saludos y gracias de antemano

Edit: Tenia que declarar init_module como extern claro :') Ahora el ensamblador no me dice nada, pero el linker me salta con undefined reference to 'init_module'.

Bueno aqui dejo este codigo que he estado haciendo estos dias, espero que les guste, se aceptan sugerencias, criticas constructivas, comentarios... etc. Basicamente crea varios hilos (he llegado a probar hasta 50) y cada uno de estos hilos envia peticiones HTTP a la pagina objetivo.

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <stdbool.h>
 
 
#define MAX_dani 0xF0000 
 
struct params{ /* En esta estructura se almacenan los parametros de la funcion t*/
  char web[20]; // Dominio web
  int port;  // Puerto (sera el 80, para peticiones HTTP)
  int thread; // El numero de thread
  int nrequests; // El numero de peticiones
  int sleeptime; // El tiempo de espera entre cada peticion
};
 
int total_requests; // Para almacenar el numero total de peticiones
pthread_mutex_t lock; // Para evitar que varios threads modifiquen total_requests a la vez
int nthreads; // Numero de threads a crear
 
void* t(void *p) /* Esta es la funcion que va a ejecutar cada thread*/
{
  int n = ((struct params*)p)->thread+1; // El numero de thread
  printf("Proceso %i: presente\n", n); // Presentacion
  char request[128]; // Para almacenar la peticion 
  _Bool connected; // Variable auxiliar, indica si el socket esta conectado
  struct hostent *host = gethostbyname(((struct params*)p)->web); // Obtener la IP de la web
  if(!host)
  {
    printf("Proceso %i: No se ha podido resolver la direccion del servidor\n", n);
    return NULL;
  }
  printf("Proceso %i: Direccion IP(v4): %s\n", n, inet_ntoa(*((struct in_addr *)host->h_addr)));
  /*Para getpeername()*/
  struct sockaddr sockbuf;
  int stsize = sizeof(sockbuf);
  /*Preparar los datos de la conexion */ 
  struct sockaddr_in sock; 
  sock.sin_family = AF_INET;
  sock.sin_port = htons(((struct params*)p)->port);
  sock.sin_addr.s_addr = inet_addr(inet_ntoa(*((struct in_addr *)host->h_addr)));
 
  int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Creamos el socket
 if(sockfd==-1)
 {
  printf("Proceso %i: No se pudo crear el socket\n", n);
  return NULL;
 }
 printf("Proceso %i: Socket creado\n", n);
 printf("Proceso %i: Conectando...\n", n);
 int aux;
 connect(sockfd, (struct sockaddr*) &sock, sizeof(struct sockaddr)); // Conectamos
 printf("Proceso %i: Conectado\n", n);
 connected=true;
 sprintf(request, "GET / HTTP/1.1\nHost: %s\nUser-Agent: Mozilla/4.0\n\n ", host->h_name); // Ponemos la peticion en una cadena
 printf("Proceso %i: Peticion en request\n", n);
 for(aux=0; aux<(((struct params*)p)->nrequests); aux++)
 {
   if(getpeername(sockfd, &sockbuf, &stsize)<0) // Comprobar que el socket esta conectado
   {
     if(errno==ENOTCONN) // Si no lo esta, cerrar y reconectar
     printf("Proceso %i: Reconectando socket...\n", n);
     close(sockfd);
     sockfd = socket(AF_INET, SOCK_STREAM, 0);
     if(connect(sockfd, (struct sockaddr*) &sock, sizeof(struct sockaddr))==-1)
     {
      connected=false;
      break;
     }
   }
   if(!connected) // Si no se pudo reconectar, decrementar aux y reiniciar el bucle
   {
     aux--;
     continue;
   }
   write(sockfd, request, strlen(request)); // Hacer la peticion HTTP
   printf("Proceso %i: %i peticion/es\n", n, aux+1); 
   pthread_mutex_lock(&lock); // Incrementar el numero total de peticiones
   total_requests++;
   pthread_mutex_unlock(&lock);
   sleep(((struct params*)p)->sleeptime); // Pausar
   }
 close(sockfd); // Cerrar el socket
 pthread_exit(NULL); // Salir
}
 
int main(int argc, char *argv[])
{
 /*Tratamiento de linea de comandos*/
 if(argc!=6)
  {
   printf("Uso: %s numero_de_threads dominio_web puerto(80) numero_de_peticiones_por_thread tiempo_de_espera\n", argv[0]);
   exit(0);
  }
 
 
 /*Inicializar algunas estructuras y parametros*/
 pthread_mutex_init(&lock, NULL);
 pthread_t *mythreads = (pthread_t*)malloc(atoi(argv[1])*sizeof(pthread_t));
 pthread_attr_t a;
 struct params *p = (struct params*)malloc(atoi(argv[1])*sizeof(struct params));
 int i, ret, j; // Algunas variables auxiliares
 nthreads = atoi(argv[1]); // Numero de threads
 for(j=0; j<nthreads; j++)
 {
  strcpy(p[j].web, argv[2]);
  p[j].thread = j;
  p[j].port = atoi(argv[3]);
  p[j].nrequests = atoi(argv[4]);
  p[j].sleeptime = atoi(argv[5]);
 }
 /*Setear la cantidad de memoria que un thread puede usar*/
 pthread_attr_init(&a);
 pthread_attr_setstacksize(&a, MAX_dani);
 /*Saber el tiempo que hace que se inicio el programa*/
 time_t start=time(NULL), end;
 /*Crear los threads*/
 for(i=0; i<nthreads; i++)
 {
  ret = pthread_create(&mythreads[i], &a, t, &p[i]);
  switch(ret)
  {
   case 0:
    printf("Thread %i creado\n", i+1);
    break;
   case EAGAIN:
    printf("EAGAIN\n");
    _exit(1);
   case EINVAL:
    printf("EINVAL\n");
    _exit(2);
   case EPERM:
    printf("EPERM\n");
    _exit(3);
  }
 }
 /*Esperar a que terminen los threads, liberar memoria y mostrar algunas estadisticas aproximadas*/
 pthread_attr_destroy(&a);
 for(j=0; j<nthreads; j++)
 pthread_join(mythreads[j], NULL);
 end=time(NULL);
 pthread_mutex_destroy(&lock);
 printf("Retornaron los hilos\n");
 printf("Total de peticiones: %i\n", total_requests);
 printf("Numero de peticiones por segundo: %lf\n", total_requests/((double)(difftime(end, start))));
 free(mythreads);
 free(p);
 return 0;
}

Saludos!