Borrado seguro de archivos

Introducción

Este articulo se hizo con fines educativos, así que para los que usen la documentación aportada, como es el caso del código de ejemplo, para fines que no son la prevención del robo de datos borrados, no me hago responsable en ningún caso de nada de lo que hagáis o de lo que borréis...Pues una vez borrado es casi imposible de recuperar, y según que método uses, es imposible ya que queda seriamente dañado, así que cada uno es responsable de sus actos...

Teoría sobre el disco magnético y el borrado seguro

El concepto general que se debe de tener en cuenta para borrar un archivo de forma segura de un disco magnético, es que los archivos, son simplemente un conjunto de ceros y unos, y eso es lo que realmente se graba en el disco magnético, y por lo tanto, para borrarlo, hay que sobrescribir el archivo para que no se recupere el original, ya que si solo lo borramos, el archivo aún se podría recuperar si se accede a la "Master File Table" (ya explicaré en otro artículo en que consiste y tal...). Esta tarea la realizamos escribiendo una serie de patrones de ceros y unos, equivalentes al peso total del archivo. Para ello es realmente imprescindible alternar los patrones de bits que escribiremos, y mientras más veces sobrescribamos el mismo archivo, con distintos patrones de bits mejor, ya que así haremos más difícil la recuperación de los datos a través de técnicas forenses. Esto es debido, que al sobrescribir muchas veces un mismo archivo, alternando los patrones de bits, lo que hacemos es erosionar la superficie del disco duro con distintos patrones, lo que da como resultado, que cuando extraigan el disco duro e intentar recuperar los datos con dichas técnicas forenses, se encuentren con el problema de que no saben ni donde empieza ni donde acaba el archivo, además de que no saben que patrones conforman el archivo original, ya que si lo hemos hecho bien, la superficie, al estar suficientemente erosionada en la misma posición, no se puede distinguir el primer patrón de bits que conforman el archivo original, de los otros que hemos escrito aleatoriamente. También como es lógico, si se accede a la MFT ( Master File Table ) para recuperarlo y lo recuperan, se encontrarán con un archivo que concuerda con el último patrón de bits escritos, que por supuesto no tienen nada que ver con el original.
Pongo como ejemplo una hoja de papel, en la que escribimos "hola alberto", después escribimos encima "Adeu umberto", así sucesivamente cambiando las palabras, llegará un momento en que solo se distinguirá lo último que hemos escrito, que no tiene nada que ver con lo original que era "hola alberto".

Existen muchos estándares de borrado ( quiero decir que esos estándares nos suelen especificar los bits y las veces que sobrescribiremos el archivo con dicho patrón ).
Por ejemplo: US Air Force 5020 es el método de borrado que usa la fuerza aérea de estados unidos ( si mal no recuerdo... ). Este estándar de borrado en concreto, nos dice que el archivo debe ser sobrescrito 3 veces, cada vez con un patrón de bits distintos. En dicho caso nos especifica que el 1º paso tiene que ser 00000000 (&H0), el 2º 11111111 (&HFF) y por último el que queramos nosotros, como por ejemplo este: 10101010 (&HAA).

De estándares así hay muchos ( encontrarlos no es tarea fácil aviso ) , y aunque en este articulo no los escriba, ya veréis que el archivo adjunto a este documento hay 13 estándares, entre ellos el tan famoso Peter Gutmann, o el de Bruce Schneier ( de profesión criptólogo ).

Nota:
En este articulo solo explicaré el estándar sencillo de un paso, sobrescrito todo con 11111111 (&HFF)

Código de demostración:

En este código de ejemplo, usaremos tan solo el espacio de nombres System.IO ( para abrir el archivo y sobrescribir el archivo ).
Lo primero que haremos es crear una función que la llamaremos Shred, al cual le pasaremos un parámetro del tipo String que contendrá la URL del archivo a borrar. La función haremos que retorne un parámetro del tipo Boolean ( que usaremos para ver si ha ocurrido un error o no ).
La cosa más o menos quedaría así:

Private Function Shred(ByVal Archivo As String) As Boolean
End Function

A continuación tenemos que declarar una variable del tipo FileStream, ya que dicho tipo de Stream nos permite grabar un buffer que contendrá los bytes que escribiremos en el archivo, sobrescribiendo por lo tanto los que ya están presentes. Además de una variable del tipo FileInfo, que será la que nos indique el ancho del archivo.
Para que os hagáis una idea, la cosa quedaría más o menos así:

Private Function Shred(ByVal Archivo As String) As Boolean
   Dim Archivo As FileInfo = New FileInfo(Archivo)
   Dim Escribe As FileStream = New FileStream(Archivo, FileMode.Open, FileAccess.Write, FileShare.None)
End Function

El siguiente paso, consiste en declarar una variable, la cual contendrá el array de bytes a escribir, que sustituirán
el actual contenido del archivo. Una vez declarada dicha variable, tenemos que redimensionar el array para que coincida con el total de bytes
del archivo, después rellenarlos con los bytes que formarán el nuevo contenido. En nuestro caso será (&HFF).
Después, lo que haremos será volcar dicho buffer al archivo, sobrescribiendo el contenido anterior, por el actual que es todo de 11111111.
Por último, lo que haremos será borrar el archivo. La cosa más o menos quedará así:

Private Function Shred(ByVal Ruta As String) As Boolean
   Dim Archivo As FileInfo = New FileInfo(Ruta)
   Dim Escribe As FileStream = New FileStream(Ruta, FileMode.Open, FileAccess.Write, FileShare.None)
   Dim ByteArray() As Byte = Nothing
   ReDim ByteArray(CInt(Archivo.Length - 1))
   'Redimensionamos el Array para que contenga la misma longitud que el archivo
   For I As Long = 0 To Archivo.Length - 1
       ByteArray(CInt(I)) = &HFF
   Next I
   'Rellenamos el Array con la cadena 11111111 que será lo que substituirá el contenido del archivo
   Try
      FileSystem.SetAttr(Ruta, FileAttribute.Normal)
      'Por si el archivo esta con la propiedad de "Solo Lectura", 
      'lo cambiamos a normal para que así podamos sobreescribirlo
      Escribe.Seek(0, SeekOrigin.Begin)
      'Indicamos que escribiremos a partir del 0
      Escribe.Write(ByteArray, 0, ByteArray.Length)
      Escribe.Flush()
      'Volcamos el Buffer al archivo
      Escribe.Close()
      My.Computer.FileSystem.DeleteFile(Ruta)
      'Cerramos el archivo y a continuación lo borramos 
      '(aunque aun estará presente en la MFT, pero con el contenido dañado)
      Return True
  Catch ex As Exception
      Return False
  End Try
End Function

Bien, ahora ya tenemos la función hecha, ahora para llamarla y aprovechar el que nos diga si hay un error o no al borrar el archivo, una de las posibilidades sería hacerlo en un botón
con un select case. Más o menos quedaría así:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
   Select Case Shred("Escribe Aqui La Ruta Del Archivo Que Deseas Borrar")
      Case True
         MsgBox("El archivo se borró con éxito")
      Case False
         MsgBox("Error")
   End Select
End Sub

Conclusión.

Como habéis podido observar, nos es tan complicado hacer este tipo de software, con unos sencillos pasos ya conseguimos borrar un archivo de nuestro PC con más seguridad que la
que nos ofrece windows de serie... Aunque si lo que queréis es un software ya hecho, bastante completo y además gratis, os invito a que os descarguéis de mi web el programa Secure Delete,
que es capaz de borrar toda la lista de archivos que indiquemos a la vez, además, podemos establecer cuantos archivos se borrarán a la vez ( hecho con los semáforos de los threads).

El código que adjunto en este documento, es una liberación del código de mi programa Secure Delete, un poco Lite, aunque la clase es extraída del original y solo se ha modificado para
adaptarlo a dicho formulario.

Espacios de nombres usados en el código de este artículo:

System.IO