¿Se puede usar mprotect () para cambiar los permisos de .rodata?

2

La sección .rodata en los archivos ELF contiene partes del segmento de texto que no deben modificarse. De forma predeterminada, todas las páginas de esta sección son de solo lectura, y cualquier intento de modificación provocará un error de protección general. Linux syscall mprotect() es capaz de modificar los permisos de acceso por página. Me pregunto si la naturaleza de solo lectura de .rodata es impuesta por el kernel, de manera que syscalls no puede cambiar sus permisos de acceso, o si el kernel simplemente establece los permisos predeterminados para la página. Si lo primero es cierto, entonces se puede confiar en el segmento de datos de solo lectura para evitar que incluso un programa comprometido lo modifique en tiempo de ejecución.

¿El kernel de Linux impone la naturaleza de solo lectura de .rodata ?

    
pregunta forest 29.11.2017 - 22:24
fuente

2 respuestas

2
  • Las secciones no existen en el contexto de un proceso en ejecución, solo segmentos.
  • mprotect se puede usar para cambiar los permisos de las páginas a las que se asigna el segmento text . Aquí hay un tutorial sobre cómo lograr esto: Escribiendo una automutación x86_64 C Programa
  • de las notas en la página de manual de mprotect :
      

    En Linux siempre está permitido llamar a mprotect () en cualquier dirección en el espacio de direcciones de un proceso (excepto en el área del kernel vsyscall). En particular, se puede usar para cambiar las asignaciones de código existentes para que puedan escribirse .

La información de la sección se almacena en la tabla de encabezado de la sección. La tabla de encabezado de sección es una matriz de encabezados de sección. La tabla de encabezado de sección no se asigna a ningún segmento y no es analizada por el cargador de programas. El cargador utiliza información de segmentos solo cuando se asigna un programa a la memoria virtual.

Los segmentos, no las secciones, tienen permisos, y estos se almacenan en el encabezado del programa del segmento en el campo p_flags . Los encabezados del programa residen en la tabla de encabezado del programa del binario.

Todo esto se documenta en los capítulos 4 y 5 en ABI del sistema V (genérico) .

En la salida a continuación, podemos ver los permisos asociados con cada segmento en la columna flags :

$ readelf -l /bin/ls

Elf file type is EXEC (Executable file)
Entry point 0x404890
There are 9 program headers, starting at offset 64

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000400040 0x0000000000400040
                 0x00000000000001f8 0x00000000000001f8  R E    8
  INTERP         0x0000000000000238 0x0000000000400238 0x0000000000400238
                 0x000000000000001c 0x000000000000001c  R      1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x0000000000019d44 0x0000000000019d44  R E    200000
  LOAD           0x0000000000019df0 0x0000000000619df0 0x0000000000619df0
                 0x0000000000000804 0x0000000000001570  RW     200000
  DYNAMIC        0x0000000000019e08 0x0000000000619e08 0x0000000000619e08
                 0x00000000000001f0 0x00000000000001f0  RW     8
  NOTE           0x0000000000000254 0x0000000000400254 0x0000000000400254
                 0x0000000000000044 0x0000000000000044  R      4
  GNU_EH_FRAME   0x000000000001701c 0x000000000041701c 0x000000000041701c
                 0x000000000000072c 0x000000000000072c  R      4
  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000000 0x0000000000000000  RW     10
  GNU_RELRO      0x0000000000019df0 0x0000000000619df0 0x0000000000619df0
                 0x0000000000000210 0x0000000000000210  R      1

 Section to Segment mapping:
  Segment Sections...
   00     
   01     .interp 
   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame 
   03     .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss 
   04     .dynamic 
   05     .note.ABI-tag .note.gnu.build-id 
   06     .eh_frame_hdr 
   07     
   08     .init_array .fini_array .jcr .dynamic .got
  

La sección .rodata en los archivos ELF contiene partes del segmento de texto que no deben modificarse.

Esto es falso. El segmento text completo es de lectura / ejecución.

  

De forma predeterminada, todas las páginas de esta sección son de solo lectura, y cualquier intento de modificación provocará un error de protección general.

Esto es falso. Los segmentos, no las secciones, se asignan a páginas (de ahí los valores de Align ) y tienen permisos (de ahí los valores de Flags ).

Más información se puede encontrar aquí:

respondido por el SYS_V 30.11.2017 - 01:01
fuente
1

En el manual :

  

En Linux siempre está permitido llamar a mprotect () en cualquier dirección en   el espacio de direcciones de un proceso (excepto para el área de kernel vsyscall). En   en particular, se puede utilizar para cambiar las asignaciones de código existentes para ser   escribible.

Aquí hay un programa de ejemplo para demostrar.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>

#define PAGE_SIZE 4096

const unsigned char rodata[3*PAGE_SIZE] = {1,2,3};

int main(void)
{
    printf("rodata = %p\n", rodata);
    uintptr_t page_base = ((uintptr_t)rodata / PAGE_SIZE + 1) * PAGE_SIZE;
    unsigned char *p = (unsigned char *)rodata + PAGE_SIZE;
    //*p = '!'; // this would cause a segfault
    puts("Before mprotect:");
    system("cat /proc/$PPID/maps");
    if (mprotect((void*)page_base, 1, PROT_READ | PROT_WRITE) < 0) {
        perror("mprotect");
        return 1;
    }
    puts("After mprotect:");
    system("cat /proc/$PPID/maps");
    *p = '!';
    return 0;
}

Por supuesto, cualquier información que escriba en la página permanecerá en la memoria. Linux ve que el proceso está escribiendo en una página que actualmente está asignada como de solo lectura y hace una copia. En el momento de la escritura, el kernel no distingue esto de la copia en escritura después de que se haya bifurcado un proceso. Puede observar esto forzando, escribiendo en un proceso y leyendo en el otro: el otro proceso no verá la escritura ya que es una escritura en la memoria del proceso de escritura, no en la memoria del proceso de lectura.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>

#define PAGE_SIZE 4096

const unsigned char rodata[3*PAGE_SIZE] = {0};

void writer(char *p)
{
    if (mprotect(p, 1, PROT_READ | PROT_WRITE) < 0) {
        perror("mprotect");
        return 1;
    }
    puts("After mprotect:");
    system("cat /proc/$PPID/maps");
    *p = 1;
    printf("wrote %d\n", *p);
}

void reader(char *p)
{
    printf("read %d\n", *p);
}

int main(void)
{
    printf("rodata = %p\n", rodata);
    uintptr_t page_base = (((uintptr_t)rodata / PAGE_SIZE + 1) * PAGE_SIZE);
    volatile char *p = (volatile char *)page_base;
    //*p = '!'; // this would cause a segfault
    puts("Before mprotect:");
    system("cat /proc/$PPID/maps");
    if (fork() == 0) {
        writer(p);
    } else {
        sleep(1);
        reader(p);
    }
    return 0;
}

Sospecho que hay parches de refuerzo que impiden que un proceso cambie sus propias asignaciones de memoria, pero no tengo una para ofrecer.

    
respondido por el Gilles 30.11.2017 - 00:54
fuente

Lea otras preguntas en las etiquetas