¿La edición de un archivo y su guardado lo sobrescribe permanentemente?

Esto depende de la aplicación específica. Algunas aplicaciones solo sobrescribirán el bloque individual o los bloques que haya editado. Otros, más a menudo, crearán una copia nueva del archivo con un nuevo nombre temporal, luego la cambiarán de nombre y eliminarán el archivo anterior. Esto no es más "seguro" que simplemente eliminar el archivo directamente. Tendría que tener una aplicación específicamente diseñada para sobrescribir todo el archivo.

Ninguna de estas técnicas sobrescribirá el archivo completo. Para hacer eso, deberá sobrescribir cada bloque en el lugar. Esto se puede hacer con herramientas especializadas como shred(1) . Tenga en cuenta que los sistemas de archivos modernos son complejos y que aún pueden quedar restos de datos. Por ejemplo, ext4 puede mantener pequeños archivos que caben en un solo inodo en el propio inode. Se realiza una copia de seguridad del inodo en el diario, que no se sobrescribe cuando se sobrescribe el inodo. Los sistemas de archivos que admiten la copia en escritura, como btrfs, actúan como SSD en el sentido de que una sola escritura en un bloque determinado no sobrescribirá necesariamente el sector original en la unidad donde se almacena. La única solución real para eliminar la información confidencial es mantenerla encriptada y tirar la clave antes de eliminarla.

Edición en contexto

Un archivo se compone de un gran número de sectores , cada uno de un tamaño como 512 bytes. Un sector a menudo (pero no siempre) se asigna a un bloque del sistema de archivos, con un sector que es una unidad física de almacenamiento del hardware del medio de almacenamiento, y un bloque del sistema de archivos es una sola unidad de almacenamiento como lo ve lógicamente el controlador del sistema de archivos. Una escritura de sector es atómica (en teoría), y editar un solo byte requiere escribir en todo el sector en el que se encuentra (aunque el disco utiliza lectura-modificación-escritura para garantizar que no se pierdan otros datos en el sector). La edición de un archivo en su lugar solo resultará en la sobrescritura de los sectores que contienen los datos que se modifican. Suponiendo que está utilizando un sistema de archivos que no hace copia en escritura (en Linux, prácticamente todo excepto btrfs y ZFS), esto sobrescribirá solo los datos específicos que se están editando.

Una implementación de C que escribe una cadena en el lugar en el byte número 1234:

void edit(void)
{
    int fd = open("file.txt", O_RDWR);
    pwrite(fd, "Hello, world!", 13, 1234);

    fsync(fd);
    close(fd);
}

Edición atómica

A menudo, las aplicaciones editan archivos creando un nuevo archivo con un nombre temporal y llenándolo con el contenido modificado del archivo antiguo. Después de que se haya escrito (y, opcionalmente, se haya sincronizado en el disco), se le cambia el nombre al nombre original, lo que hace que el archivo anterior se elimine, pero aún esté presente en el disco. Esto es atomic , lo que significa que el archivo está completamente editado o no está editado. La intención es garantizar que un sistema bloqueado que solo tiene tiempo para realizar una escritura parcial no dañe el archivo de destino. El cambio de nombre es (o al menos se supone que es) una operación atómica. Es decir, o bien tiene éxito completo o falla, sin intermediarios.

Una implementación de C que copia el archivo y escribe una cadena en el byte número 1234:

void edit(void)
{
    int src_fd = open("file.txt", O_RDONLY);
    int dst_fd = open("file.txt.tmp", O_CREAT|O_RDWR);

    sendfile(dst_fd, src_fd, NULL, -1);
    pwrite(dst_fd, "Hello, world!", 13, 1234);

    fsync(dst_fd);
    rename("file.txt.tmp", "file.txt");

    close(src_fd);
    close(dst_fd);
}

Sobrescribiendo en lugar

Para sobrescribir un archivo completo, necesita abrir el archivo (sin truncarlo) y escribir datos no confidenciales. La cantidad de datos escritos debe ser igual al tamaño del archivo original, o de lo contrario se agregará innecesariamente. Tenga en cuenta que esto solo funciona suponiendo que el sistema de archivos no tenga ningún truco bajo la manga que resulte en que haya restos de datos por ahí.

Una implementación de C que sobrescribe un archivo completo con datos aleatorios:

void overwrite(void)
{
    struct stat sb;

    int src_fd = open("/dev/urandom", O_RDONLY);
    int dst_fd = open("file.txt", O_WRONLY);

    fstat(dst_fd, &sb);
    sendfile(dst_fd, src_fd, NULL, sb.st_size);
    fsync(dst_fd);

    close(src_fd);
    close(dst_fd);
}