Hola, este es mi primer artículo y espero que no sea el último, espero poder ser lo suficientemente claro redactando para que me de a entender.

El otro día fui al cine a ver la película ‘The Core’ (el núcleo) y en una de las escenas pasa que la policía va al departamento de un hacker y éste al verlos por la mirilla se pone a destruir discos, unos en el horno de microondas, en el tostador y otros con una descarga electromagnética. Y una idea loca se quedó en mi cabeza.

Muy probablemente todos tenemos información en nuestros equipo que no queremos que nadie mas vea (cartas de amor, pornografía, código fuente, listas de passwords, etc), la cual en el mejor de los casos la guardamos encriptada y la llave la ponemos en un lugar seguro, pero que pasa?, pues que existe en método por medio del cual al información puede ser vista, la idea de esa escena de la película era hacer irrecuperable la información (eliminar la evidencia) y eso, eso es de lo que trata este documento.

En lo personal he borrado mucha información por error (yo solo uso windows, así que no se si este proyecto funcione en otro sistema operativo pero me imagino que si) y la he podido recuperar afortunadamente, y eso me alarma, porque ¿qué pasa con la información que verdaderamente quiero eliminar?. Cuando uno pulsa la tecla delete en nuestro explorador de windows, los archivos eliminados no se van del todo, ni siquiera cuando hacemos uso del Shift+Del , en el primer caso se va a la papelera de reciclaje y en el segundo caso desaparece el nombre del archivo de nuestro disco duro pero no desaparece la información que contenía el archivo.

Hace ya algunos años existió un sistema operativo llamado MS-DOS, un sistema operativo sin ventanas y sin ratón, el cual tenia una comando llamado DEL y otro llamado UNDELETE, cuando se eliminaba un archivo con el comando DEL existía la opción de recuperar el archivo con el comando UNDELETE, el inconveniente era que el comando no recuperaba el nombre del archivo en su totalidad, había que indicarle cual era el primer carácter del nombre del archivo.

Para entender un poco mas esto de los archivos veamos como se almacenan los archivos en el disco duro. Básicamente el disco lleva un sistema de archivos, un lugar en donde se almacenan los datos relevantes de los archivos, como son el nombre y donde se encuentra físicamente. Y luego existe otro lugar donde son almacenados los archivos en si, por ejemplo :

Supongamos que tenemos un archivo llamado ‘password.txt’ que contiene el texto : ‘ABC’ en el sistema de archivos tendíamos :

Nombre = Password.txt
Dirección = 123
Longitud = 3

De la dirección 123 a la 125 (Que es la longitud del archivo) tenemos

ABC

Bueno básicamente sería así, supongo que dependiendo del sistema de archivos cambiaría la forma de almacenar la información pero yo me la imagino así y es mas fácil de comprender.

Al parecer cuando el viejo MS-DOS borraba un archivo solo le quitaba la primera letra del archivo y con el comando inverso se podía recuperar la información siempre y cuando otro archivo creado posteriormente no haya ocupado el espacio o parte del espacio que el archivo eliminado estaba ocupando. De tal manera que si un archivo ocupaba la dirección 124 a la 128 era imposible recuperar el archivo y su contenido original, en el mejor de los casos se podía recuperar parte del archivo.

Ok, retomando el tema de la película, la idea de pasarle un campo electromagnético a los discos duros era hacer irrecuperable la información cambiando el orden de los bits, de todos los bits de los discos duros y mi idea del PEV es simular lo que haría un campo electromagnético pero un poco mas controlado y pues manos a la obra.

Construyendo el PEV

Para fines didácticos tomaremos como ejemplo ficticio el archivo que en teoría es en extremo comprometedor e inculpador :

Nombre : passISPPatito24032003.sql
Dirección : 1A5ECh
Longitud : 400h (1KB)

Lo primero y mas importante es cambiar los datos almacenados en el archivo que nos interesa. Supongamos que el archivo passISPPatito24032003.sql está lleno de cadenas SQL como la siguiente :

INSERT INTO userData VALUES (id,usrAcount,usrPassword);

El archivo está lleno de usuarios y passwords válidos para un ISP llamado Patito, es información altamente comprometedora pero útil a la vez. PEV debe de cambiar el contenido del archivo lo antes posible, la totalidad del archivo, a mi me gusta llenarlo de 0s, de tal manera que al final del proceso tendremos un archivo llamado passISPPatito24032003.sql que comienza en la dirección 1A5EC con una longitud de 1KB lleno de 0s

Nota : en lo particular uso delphi, así que pido una disculpa a los amantes del C.

La función la llame ‘blanquear’, y básicamente lo que debe de hacer dicha función es:
• Abrir el archivo
• Cambiar cada uno de los bytes por el byte de relleno (en este caso 0)
• Cerrar el archivo

Fácil ¿no?, bueno, pero por si las dudas aquí les doy mi versión de cómo se puede realizar este proceso.

function blanquear(archivo: String): Boolean;
Const
_BLOQUE = 2048; //El tamaño del bloque a guardar
_FILL_CHAR = #0; //El carácter de relleno
var
f : File; //El archivo
tamanoArchivo, //El tamaño del archivo
acumulado, //El avance del almacenamiento
escritos, //Los bytes escritos
tamanoBloque, //El tamaño del bloque a guardar
n : Cardinal; //El tipo Cardinal solo soporta
//4,294,967,295 así que no funcionará
//para archivos de mayor tamaño
Buf: array[1.._BLOQUE] of Char; //El bloque a guardar
begin
try
tamanoArchivo := tamanoDe(archivo);
AssignFile(f, archivo); //Asigno el archivo a abrir
Reset(f,1); //Abre el archivo
n := 0;
for n := 1 to _BLOQUE do
buf[n] := _FILL_CHAR; //Se llena el bloque
acumulado := 0;
repeat
//unas validaciones para ver cuanto se va a almacenar
if acumulado = tamanoArchivo then
tamanoBloque := 0
else if _BLOQUE > tamanoArchivo then begin
tamanoBloque := tamanoArchivo;
acumulado := tamanoArchivo;
else if (acumulado + _BLOQUE) > tamanoArchivo then begin
tamanoBloque := tamanoArchivo - acumulado;
acumulado := tamanoArchivo;
end else begin
tamanoBloque := _BLOQUE;
inc(acumulado, _BLOQUE);
end;
//Se realiza el remplazo de la información
BlockWrite(F, Buf, tamanoBloque, escritos);
until (tamanoBloque = 0) or (escritos <> tamanoBloque);
CloseFile(f); // Se cierra el archivo y tan tan.
result := True;
except
result := False
end;
end;

La función ‘tamanoDe’ sólo extrae el tamaño del archivo dado.

function tamanoDe(archivo: String): cardinal;
var
hf : HFile;
FindData : TWin32FindData;
begin
result := 1;
Hf := windows.FindFirstFile(PChar(archivo),FindData);
if (INVALID_HANDLE_VALUE <> Hf) then begin
result := (FindData.nFileSizeHigh * MAXDWORD) +
FindData.nFileSizeLow;
Windows.FindClose(Hf);
end;
end;

Creo que es importante hacer este proceso de ‘blanquado’ lo más rápido posible; así como está el código corriendo en un equipo a 800MHZ con un HD ATA66 se tardó en blanquear un archivo de 12MB en 117 milésimas de segundo, nada mal, eso creo. Recuerdo haber leído un artículo en donde se decía que aun después de haber sobre escrito el archivo 6 veces era todavía posible recuperar la información, si tu paranoia es mucha, pues bien puedes hacer el proceso de blanqueado repetitivo (en un ciclo for o while), solo recuerda llenarlo con un carácter diferente cada vez que ejecutes el proceso.

Lo segundo mas comprometedor es el nombre del archivo y la longitud del mismo, ya que es mucha casualidad que tengamos un archivo que se llame igual al que existe en el ISP y que para empeorarla tiene la misma longitud aunque el contenido sea diferente, así que hagamos otras dos funciones: ‘ajustarTamano’ y ‘renombrar’, estas dos funciones solo hacen que el archivo mida cero bytes y que el nombre sea otro, estas si que están fáciles pero ahí les va el código:

function ajustarTamano(archivo: String): Boolean;
var
f : File;
begin
try
AssignFile(f, archivo);
Rewrite(f,1);
CloseFile(f);
result := True;
except
result := False
end;
end;

function renombrar(archivo: String): Boolean;
var
nuevoNombre : LongInt;
nuevaExtencion : Byte;
begin
try
nuevoNombre := Random($FFFFFF);
nuevaExtencion := Random($FF);
renombrarFile(archivo, ExtractFilePath(archivo) +
IntToHex(nuevoNombre,8) +
'.' + IntToStr(nuevaExtencion));
result := True;
except
result := False;
end;
end;

Renombro el archivo con una función Random, así que hay que inicializar el motor aleatorio con la procedimiento Randomize previamente.

Al final de este procedimiento me quedará un archivo mas o menos así:

Nombre : 00315183.182
Dirección : 1A5ECh
Longitud : 0h

Ya por último solo hay que borrar el archivo 00315183.182 y ya, la evidencia se fue al caño, bueno, eso digo yo, por cierto, si hay alguien que después de hacer estos procesos al pie de la letra aún puede recuperar el contenido del archivo háganmelo saber.

Bueno, eso es todo, lo que resta es que ustedes le pongan un poco de creatividad a sus aplicaciones y que hagan un programita que se pueda correr fácilmente, seleccionar los archivos que queremos destruir y destruirlos. Yo hice uno que se incorpora al explorador de windows, así que solo selecciono los archivos, pulso el botón derecho del ratón y le digo que destruya los archivos seleccionados, también pueden hacer uno que lea una lista de archivos desde un archivo de texto que previamente alimentamos con los archivos que queremos destruir y así en caso de emergencia solo basta correr la aplicación que lee dicho archivo y destruye los archivos. Saludos, espero que sea de utilidad este documento, cualquier comentario quedo a sus ordenes.