Capítulo – 15
Programación para limpiaparabrisas de datos
Introducción
Ya hemos comentado que cuando eliminamos cualquier archivo del disco, la información no se borra por completo del disco, sino que se marca como disponible para que se escriban nuevos datos sobre él.
Cuando formateamos una unidad, toda la información de los archivos y directorios de la unidad, como las FAT y las entradas del directorio raíz, se borran, pero el área de datos permanece sin cambios y no se borra nada del área de datos del disco. Los datos que se eliminan o formatean con el sistema operativo permanecen en el área de datos tal como están y se pueden recuperar con algunos esfuerzos de recuperación de datos y software de recuperación de datos.
Por lo tanto, la necesidad de eliminar por completo los datos de una unidad conduce al requisito de un programa de este tipo que borre los datos del disco por completo. Para hacer esto, no es suficiente simplemente eliminar los archivos o simplemente formatear la unidad, sino que los datos en el disco deben ser sobrescritos por otros datos.
Los programas que se utilizan para borrar completamente los datos del disco se conocen como programas de borrado de datos. Estos programas escriben caracteres aleatorios en el área de datos para sobrescribir los datos y borrar toda la información previamente guardada en el disco.
Cuando los datos se vuelven completamente irrecuperables
Para borrar los datos, el área de datos del disco debe sobrescribirse con otros datos, pero el problema no termina aquí. Para complicar aún más las cosas, la tendencia de las unidades magnéticas a recordar los datos que se han sobrescrito requiere que los datos también se sobrescriban varias veces mediante secuencias aleatorias de datos para que no se puedan recuperar incluso con herramientas sofisticadas de recuperación de datos.
Es así porque las tecnologías que pueden recuperar datos incluso después del uso de algunos borradores de datos simples están disponibles hoy.
Algunos productos de borrado de datos realizan ceros binarios y unos binarios sobrescribiendo los datos. Escribir una serie de ceros binarios y unos binarios logra el efecto de sobrescritura más profundo ya que estos valores son los valores magnéticos mínimo y máximo respectivamente.
Aunque esta es la teoría de un programa de borrado de datos ideal, en general, la sobrescritura de datos con caracteres ASCII aleatorios es suficiente. La razón para decirlo es que la recuperación mediante herramientas y tecnología de recuperación sofisticadas no se puede utilizar para recuperar los datos de ninguna organización para la recuperación de datos de rutina porque estas tecnologías son muy costosas y cuestan millones incluso para una sola recuperación. No solo esto, sino que estas tecnologías solo están disponibles en unos pocos países del mundo.
Discutiremos solo la simple sobrescritura de datos para borrar los datos del disco. Sin embargo, puede modificar aún más los mismos programas para escribir los caracteres aleatorios solo con un poco de esfuerzo. Los datos borrados por esta idea tampoco pueden ser recuperados por ningún software de recuperación de datos.
Por qué la eliminación de datos es tan importante
Cuando discutimos las técnicas de recuperación de datos, le aseguramos al usuario que los datos se pueden recuperar con algunos esfuerzos generales o específicos de recuperación de datos. Pero la recuperación de datos no siempre es una función deseada y esperada por todos.
Puede haber muchas personas u organizaciones que siempre estén dispuestas a borrar los datos de su disco de tal manera que no deban recuperarse de todos modos. En tales casos, es posible que se hayan almacenado previamente en el disco datos muy confidenciales, que si caen en las manos equivocadas pueden dañar a la organización o al usuario al hacer un mal uso de la información.
Como sabemos, la necesidad de más y más espacio en los discos duros aumenta día a día. Como resultado de esto, las unidades antiguas de pequeña capacidad se reemplazan por nuevos discos de gran capacidad a gran escala cada año en casi todas las organizaciones. Si estos discos antiguos caen en malas manos, puede crear un problema muy serio para esa organización.
Según noticias publicadas por CNET News.com, el 16 de enero de 2003, los estudiantes del Instituto de Tecnología de Massachusetts, Simon Garfinkel y Abbi Shelat, han estado comprando discos duros viejos, en nombre de la investigación, de la Web y otros de segunda mano. sales para descubrir las enormes cantidades de información personal que la gente no se molesta en borrar.
Después de comprar 158 unidades por alrededor de USD 1000, lograron recopilar más de 5000 números de tarjetas de crédito, registros médicos, información financiera personal y corporativa detallada y varios gigabytes de correos electrónicos, códigos fuente y otra información.
Los dos estudiantes compilaron sus hallazgos en un informe titulado " Recuerdo de datos pasados: un estudio de saneamiento de disco" publicado en la edición de febrero de IEEE Security and Privacy.
Los puntos principales que han surgido de la investigación son que el mercado de discos duros de segunda mano está repleto de información personal, lo que facilita que un comprador malicioso asuma la identidad de otra persona.
Programa de escritura para borrador de datos no destructivo
El borrador de datos no destructivo es un tipo de programa de borrado de datos mediante el cual podemos borrar todo el “ espacio no asignado” del volumen del disco, sin dañar los datos almacenados en el disco, de ninguna manera.
El alcance de dicho borrador de datos es en los casos en los que desea borrar todo el espacio no asignado del volumen del disco mientras que los datos asignados almacenados en el volumen deben permanecer intactos. Este tipo de programa de borrado de datos también borra el área de datos de los archivos eliminados.
La codificación del programa para un tipo de no – programa de eliminación de datos destructiva se ha dado a continuación:
///// Programa para un limpiador de datos no destructivo \\\\\
#include <stdio.h>
unsigned int file_num=0; /* Provides File Number
During the Auto Creation
of Temporary Data files */
float status=0; /* How Much Disk space is
still Written */
static char dbuf[40000]; /* Data Buffer to write
Temporary Files with */
char file_extension[5]=".ptt";/* Unique Extensions for
Temporary Files */
char temp[5]; /* File Number converted to
String */
char filename[40]; /* Temporary File name */
void main()
{
unsigned int i=0;
clrscr();
while(i<40000)
{
dbuf[i] = ' ';
i++;
}
gotoxy(10,14);cprintf(" MB Still Written...");
while(1)
{
/* Lógica para crear archivos temporales automáticamente con un nombre único */
strcpy(filename,"TTPT");
itoa(file_num,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
file_num++;
write_to_temp(filename);
}
} //// End of Main \\\\
///// Función para escribir los datos en un archivo temporal \\\\\
write_to_temp(char *filename)
{
unsigned int i, count=1;
float buf_status=0;
FILE *tt;
if((tt=fopen(filename,"wb"))==NULL)
{
fclose(tt);
printf("\n Error occurred while creating temporary
file, ");
printf("\n Removing temporery Files After KEY BOARD
HIT");
getch();
remove_temp_file();/* Remove All temporary files */
}
while(1)
{
for(i=0;i<50;i++)
{
fprintf(tt,"%s",dbuf);
}
buf_status = (float)((40000*50*count)/512);
status= status+(40000*50);
count++;
gotoxy(10,14);
cprintf("%.0f",(float)(status/1000000));
if(kbhit())
{
fclose(tt);
printf("\n Removing Temporery Files, Please
Wait...");
remove_temp_file();
}
if(buf_status>=10000)
{
fclose(tt);
return;
}
}
}
/* Función para eliminar los archivos temporales automáticamente */
remove_temp_file()
{
int i=0;
for(i=0;i<=file_num;i++)
{
strcpy(filename,"TTPT");
itoa(i,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
remove(filename);
}
exit(1);
return 0;
}
Comentarios sobre la lógica y la codificación del programa:
En este programa básicamente seguimos los siguientes dos pasos para borrar el espacio no asignado del disco:
- Crear archivos de datos temporales automáticamente: primero, creamos archivos temporales con nombres únicos y tenemos algunos datos en ellos hasta que el volumen del disco esté lleno con estos archivos de datos temporales. Al hacer esto, toda el área de datos no asignados de la unidad lógica es ocupada por los datos de los archivos temporales y todos los datos no asignados se sobrescriben.
Para hacer esto, elegí los nombres de los archivos temporales en el formato TTPTxxxx.PTT, lo que significa que los primeros cuatro caracteres de los archivos temporales son TTPT y la extensión de los archivos es .PTT. Se hace así para proporcionar a los archivos temporales los nombres de archivo únicos.
He establecido el tamaño máximo del archivo temporal único, equivalente a aproximadamente 11.718 datos de sectores, sin embargo, puede definirlo según usted. Elegí el carácter espacial “ ” (carácter ASCII 32) para completar los datos en archivos temporales. Sin embargo, también se pueden usar caracteres aleatorios en lugar de espacios.
- Eliminar todos los archivos temporales: cuando la unidad lógica está llena de archivos temporales, indica que toda el área de datos no asignados ahora se sobrescribe. Ahora todos los archivos temporales creados por el programa se eliminan automáticamente. Y así se logra eliminar el espacio no asignado.
En la codificación del programa, el nombre de archivo de la matriz de caracteres almacena el nombre del archivo para generar archivos temporales automáticamente, con diferentes nombres.
La función write_to_temp(filename); llena el archivo temporal hasta 11,718 sectores (porque no hay ocurrencia de 10,000 sectores en el grupo específico de escritura del búfer) datos equivalentes con la ayuda del búfer de datos dbuf de 40,000 bytes. Se escriben 50 veces el búfer de datos a la vez para acelerar la escritura.
Los archivos temporales se crean hasta que el volumen del disco está lleno y se produce un error de creación de archivos. La función remove_temp_file() elimina todos los archivos temporales creados por el programa.
De esta manera, todo el espacio no asignado se elimina sin dañar los datos del volumen del disco.
Programa de escritura para Destructive Data Wiper:
Los programas de limpieza de datos destructivos son aquellos que escriben directamente en la superficie del disco. Este tipo de programas de borrado de datos funcionan en un nivel más bajo que el sistema de archivos y el sistema operativo, lo que significa que se borran todos los datos y otra información lógica, incluido el sistema operativo, los sistemas de archivos, la entrada del directorio y todo lo que está escrito en el disco.
Estos programas de borrado de datos borran directamente los sectores de la superficie del disco y borran todo lo escrito en él. Como se pierden todos los datos del disco, incluido el sistema operativo, estos programas se denominan programas de limpieza de datos destructivos.
Este tipo de programas de limpieza son los preferidos en tales casos, donde el usuario desea sobrescribir todo en el disco, incluido el sistema operativo y todos los datos en el disco.
Sin embargo, hay algunos beneficios más de este tipo de programas de limpieza de datos. Como estos programas de limpieza de datos destructivos funcionan completamente libres del sistema operativo y del sistema de archivos y escriben directamente en la superficie del disco, son razonablemente más rápidos que los limpiadores de datos no destructivos.
Además, si se crean sectores lógicos defectuosos en el disco debido al almacenamiento ilegal de algunos datos aleatorios, estos sectores lógicos defectuosos también se eliminan por completo con los datos del disco.
La codificación para un programa de limpieza de datos destructivo se ha dado a continuación. El programa ha sido escrito para admitir también discos de gran tamaño. El programa borra los datos del segundo disco duro físico conectado a la computadora.
///// Codificación para un programa de limpieza de datos destructivo \\\\\
#include<stdio.h>
#include<dos.h>
/* Estructura que utilizará la función getdrivegeometry mediante la extensión INT 13H, número de función 0x48. */
struct geometry
{
unsigned int size ; /* (call) size of Buffer */
unsigned int flags ; /* Information Flags */
unsigned long cyl ; /* Number of Physical Cylinders on
Drive */
unsigned long heads ;/* Number of Physical Heads on
Drive */
unsigned long spt ; /* Number of Physical Sectors Per
Track */
unsigned long sectors[2] ; /* Total Number of
Sectors on Drive */
unsigned int bps ; /* Bytes Per Sector */
} ;
/* Estructura del formato del paquete de dirección de disco, para ser utilizado por la función writeabsolutesectors */
struct diskaddrpacket
{
char packetsize ; /* Size of Packet,
generally 10H */
char reserved ; /* Reserved (0) */
int blockcount ; /* Number of Blocks to
Transfer */
char far *bufferaddress ; /* address to Transfer
Buffer */
unsigned long blocknumber[2] ; /* Starting Absolute
Block Number */
} ;
///// Función para obtener parámetros de la unidad \\\\\
unsigned long getdrivegeometry (int drive)
{
union REGS i, o ;
struct SREGS s ;
struct geometry g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
i.h.ah = 0x48 ; /* Function Number 0x48 of INT 13H
Extensions */
i.h.dl = drive; /* Drive Number */
i.x.si = FP_OFF ( (void far*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Invocar el número de función especificado de la extensión INT 13H con valores de registro de segmento */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n",
g.heads,g.spt,g.cyl);
/* Si falla la función de obtención de la geometría de la unidad, mostrar un mensaje de error y salir */
if(g.spt==0)
{
printf("\n Get Drive Geometry Function Fails....");
printf("\n Extensions Not Supported, Press any Key to
Exit...");
getch();
exit(1);
}
return *g.sectors; /* Return The Number of
Sectors on Drive */
}
void main()
{
unsigned long loop=0, Sectors_in_ HDD2=0;
unsigned char buffer[61440]; /* Data buffer of 61440
bytes Equivalent to
120 Sectors */
unsigned long i=0;
char choice;
clrscr();
/* Si total no. de discos duros conectados es menos de dos Mostrar mensaje de error y salir. */
if(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n You Must Have At least Two Hard Disks
Attached to your Computer To Run This");
printf("\n Program. This Program has been developed
to Wipe the Data of Second Hard Disk.");
printf("\n Press any Key to Exit... ");
getch();
exit(1);
}
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk =
%lu\n\n",
Sectors_in_HDD2);
///// Primero Confirmar, luego Continuar \\\\\
printf("\n It is A Data Wiping Program, and Writes on
the Surface of the Disk,");
printf("\n After running this program, Data can not
be recovered by any Software,");
printf("\n All The Data in Second Hard Disk will be
lost !!!");
printf("\n Press \'Y\' to Continue, Else any key to
Exit... ");
choice = getche();
switch(choice)
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
gotoxy(10,15);cprintf(" Initializing, Please Wait...");
for(i=0;i<61440;i++)
{
buffer[i]='\0';
}
gotoxy(10,15);cprintf(" ");
gotoxy(10,15);
printf("Currently Wiping Absolute Sector: ");
for(loop=0;loop<= Sectors_in_HDD2;loop=loop+120)
{
writeabsolutesectors (0x81, loop, 120, buffer);
gotoxy(44,15); printf("%ld",loop);
if(kbhit())
{
exit(0);
}
///// Mostrar mensaje cuando se complete \\\\\
printf("\n\n Data wiping is Now Completed, All the Data in
Second Hard Disk is now");
printf("\n Completely Erased, Press any Key to Exit...");
getch();
}
//// Función para escribir sector(es) absoluto(s) \\\\
int writeabsolutesectors ( int drive, unsigned long sectornumber, int numofsectors, void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* Packet Size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ;/* Number of Sectors to
be written */
/* para búfer de datos */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Sector number
to be written*/
pp.blocknumber[1] = 0 ; /* Block number = 0 */
i.h.ah = 0x43 ; /* Function Number */
i.h.al = 0x00 ; /* Write Flags */
i.h.dl = drive ; /* Physical Drive
number */
i.x.si = FP_OFF ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
/* Invocar la función especificada de INT 13H con valores de registro de segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; //failure
else
return 1 ; // success
}
Comentarios sobre la codificación:
La geometría de la estructura es utilizada por la función getdrivegeometry usando la extensión INT 13H, número de función 0x48 para obtener los diversos parámetros del disco.
La estructura diskaddrpacket es para el formato de paquete de dirección de disco, para ser utilizado por la función writeabsolutesectors.
La función getdrivegeometry (int drive) es obtener los parámetros de la unidad de la unidad física especificada en el disco. buffer [61440] es el buffer de datos de 61440 bytes, equivalente a 120 sectores.
(char) peekb(0x0040, 0x0075) se usa para encontrar la cantidad de discos duros conectados a la computadora, almacenados en la ubicación de la memoria representada por el segmento 0040H: desplazamiento 0075H. Si el número total de discos duros conectados es inferior a dos Mostrar mensaje de error y salir.
La función writeabsolutesectors (0x81, loop, 120, buffer) se usa para escribir los datos del búfer de datos en 120 sectores a la vez, comenzando desde el número de sector absoluto especificado por el ciclo.
Elegí ‘\0’ (carácter NULL, código ASCII 0) para escribir en los sectores para sobrescribir los datos. Sin embargo, puede usar caracteres aleatorios para sobrescribir los datos.
Para obtener una descripción detallada de las funciones writeabsolutesectors y getdrivegeometry, consulte los capítulos anteriores de este libro.
Borrado del área de datos de un archivo específico
Discutimos acerca de los programas de borrado de datos que borran los datos del espacio no asignado del disco o borran todo el disco. Pero si el usuario está dispuesto a borrar los datos cada vez que los borra, puede llevar tiempo borrar todo el espacio no asignado del disco.
Necesitamos este tipo de programas de borrado de datos para borrar el área de datos que solo ocupa ese archivo en particular. Para hacer esto, recibimos la ayuda de las entradas del directorio FAT y Root, para encontrar el área de datos ocupada por esos archivos en particular
Incluso en el caso de un disquete, si los datos no están fragmentados, solo podemos hacerlo con la ayuda de la información del directorio raíz. La siguiente tabla muestra la información almacenada por una entrada del directorio raíz con 32 bytes, para cualquier archivo:
Como vemos en la tabla de contenido de la entrada del directorio raíz, somos capaces de encontrar el grupo inicial y final de los archivos. El primer byte del nombre del archivo también puede contener información importante sobre el archivo. La información proporcionada por este byte puede ser una de las siguientes:
Probemos esta información para borrar los datos de cualquier archivo almacenado en 1.44Mb, 3 ½ disquete de una pulgada, con la ayuda de la información del directorio raíz. Suponiendo que los datos en el disquete no estén fragmentados, el programa dado a continuación borra los datos del archivo especificado de su área de datos:
/* Programa para borrar el área de datos del archivo especificado en el disquete */
#include<stdio.h>
#include<dos.h>
///// Estructura para leer 32 bytes de entrada de archivo en el directorio raíz \\\\\
struct root
{
unsigned char filename[8]; /* File name Entry of
8 Bytes */
unsigned char extension[3]; /* Extension of File of
3 Bytes */
unsigned char attribute; /* File Attribute Byte */
unsigned char reserved[10]; /* Reserved Bytes 10 */
unsigned int time; /* Time, 2 Bytes */
unsigned int date; /* Date, 2 Bytes */
unsigned int starting_cluster;/* Starting Cluster of File,
2 Bytes */
unsigned long file_size; /* File Size in Bytes,
4 Bytes */
};
/* Debe tomarse esto para leer todas las entradas del directorio raíz */
//struct root entry[224];
/* Estructura para leer las 16 entradas de archivo en un sector del directorio raíz */
struct one_root_sector
{
struct root entry[16];
};
struct one_root_sector one;
void main()
{
int result, i, num_sectors,j;
char wipe_buf[512]; /* Data Buffer to be used to wipe
out the data Area of file */
clrscr();
result= absread(0x00, 1, 19, &one); /* Read Absolute Sector
19 (First Sector of Root Directory) */
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
/* Mostrar información de archivos después de leer desde el directorio raíz */
printf(" FILE NO. FILENAME EXTENSION STARTING CLUSTER
FILESIZE \n\n");
for(i=1;i<16;i++)
{
printf("\n %5d %8.8s %3.3s %5u %10lu ",
i, one.entry[i].filename, one.entry[i].extension,
one.entry[i].starting_cluster, one.entry[i].file_size);
}
//// Obtenga la entrada del usuario para eliminar el archivo \\\\
printf("\n\n Enter The File Number, you Want to Delete and
Wipe out Completely ");
scanf("%d", &i);
if(i<1 || i>15)
{
printf(" \"%d\" is an Invalid Choice..., Press any
Key to Exit...", i);
getch();
exit(1);
}
///// Primero confirmar, luego continuar \\\\\\
printf("\n You are About to wipe-out,
The File \"%.8s.%s\"",
one.entry[i].filename,
one.entry[i].extension);
printf("\n Do you Want to Continue...(Y/N) ");
switch(getche())
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
///// Calcular el tamaño del archivo en sectores \\\\\
num_sectors = one.entry[i].file_size/512;
if((one.entry[i].file_size%512)>0)
{
num_sectors = num_sectors+1;
}
/* Búfer de datos de 512 bytes con 512 caracteres NULL */
for(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Sector inicial del archivo \\\\\
j= one.entry[i].starting_cluster+31;
/* Borre el área de datos hasta que finalicen los sectores del archivo */
while(j!=(one.entry[i].starting_cluster +
num_sectors+31) )
{
if((abswrite(0x00, 1, j, &wipe_buf))!=0)
{
printf("\n Error Writing on Disk Sectors");
getch();
exit(0);
}
j++;
}
printf("\n\n File \"%.8s.%.3s\" Deleted !!!" ,
one.entry[i].filename,
one.entry[i].extension);
one.entry[i].attribute = 0; /* Set the File Attribute
to 0 */
one.entry[i].time = 0; /* Wipe The Time information
of File */
one.entry[i].date = 0; /* Wipe The Date information
of File */
one.entry[i].starting_cluster = 0; /* Set the Starting cluster to 0
*/
one.entry[i].file_size = 0; /* Set the file Size to 0 */
one.entry[i].filename[0]=0xE5; /* Give the Deleted
file Status to the File */
///// Escriba la información anterior en el directorio raíz \\\\\\
result= abswrite(0x00, 1, 19, &one);
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
}
Comentarios sobre la lógica y la codificación del programa:
La estructura raíz se utiliza para leer 32 bytes de la entrada de archivo en el directorio raíz y la estructura one_root_sector lee las 16 entradas de archivo en un sector del directorio raíz.
Si desea leer todos los sectores de la información del directorio raíz, debe tomarlo como entrada raíz de estructura[224]; sin embargo, he escrito el programa para analizar las 16 entradas de un solo sector del directorio raíz.
El Sector de Inicio del Archivo se ha calculado de la siguiente manera:
j= una.entrada[i].starting_cluster+31;
Se hace así porque el área de datos de 1,44 MB, 3 ½ disquete de pulgadas comienza después de los primeros 32 sectores del disquete. Y en el disquete de capacidad especificada, un clúster es de un sector.
La siguiente tabla muestra el mapa lógico de 1.44MB, 3½ disquete de pulgadas:
La salida del programa se muestra de la siguiente manera:
Aquí eliminamos y limpiamos los datos del archivo PARTBOOT.C. Cuando vemos el contenido del disquete con el comando DIR, el archivo PARTBOOT.C no se muestra allí. Cuando ejecutamos más el programa, la entrada del archivo eliminado se muestra de la siguiente manera:
Aquí, el carácter “” (0xE5), representa que el archivo ha sido eliminado. (consulte la tabla para el primer carácter del nombre del archivo).
Si desea escribir el mismo programa para la unidad de disco duro, también debe usar la FAT con el directorio raíz para obtener la información del área de datos de cualquier archivo.
Es así porque la tasa de datos fragmentados en las unidades de disco duro aumenta con el tiempo a medida que se eliminan los archivos más antiguos y se crean nuevos archivos. Entonces no es necesario que todos los grupos de datos de cualquier archivo en la unidad permanezcan uno tras otro continuamente en el área de datos. Al acceder a FAT, puede acceder a todos esos clústeres.
Página modificada el: 18/01/2022
Home