¿Estáis listos para un buen café? ¡Vamos allá!
Hace poco tiempo he retomado un trabajo pendiente. Un trabajo, de muchos, que he ido 'abandonando' por el camino. Concretamente, este trabajo trata sobre la eliminación de un cierto tipo de ficheros para, posteriormente, extraer el contenido de los mismos sin necesidad de recuperar esos ficheros.
Hace poco tiempo he retomado un trabajo pendiente. Un trabajo, de muchos, que he ido 'abandonando' por el camino. Concretamente, este trabajo trata sobre la eliminación de un cierto tipo de ficheros para, posteriormente, extraer el contenido de los mismos sin necesidad de recuperar esos ficheros.
Por el camino con este proyecto me he encontrado con dudas, inquietudes y algunas lagunas en la comprensión del cómo y del porqué de las cosas. Lagunas que he sentido la necesidad de cubrir con la curiosidad, la necesidad de saber cómo y porqué funcionan las cosas. Lagunas que he aclarado con esta investigación.
Uno de esos vacíos con los que me he topado tiene relación con una característica de la MFT: 'Fichero residente'.
Me he encontrado con muchos Blogs y artículos que mencionan esta característica de los sistemas de ficheros NTFS, afirmando que se trata de ficheros con un tamaño 'X', (cada publicación varía la cifra de esa 'X'), y con algunos artículos que afirman que los distintos atributos se encuentran siempre en una posición determinada, (cuando este hecho varía según se dé una cierta condición), todo ello sin una prueba fehaciente de ello. No he visto demasiado material documentado sobre ello. Me ha llamado mucho la atención este hecho, dada la importancia que tiene esta característica en este campo de DFIR. Dada la alta importancia, y valor, que tiene el análisis de la MFT en cualquier caso.
Por ello he creído oportuno, e interesante, publicar este material de investigación, dada la carencia documental que existe al respecto, y he decidido realizar mis propias pruebas.
En este campo de DFIR, todo tiene una explicación. Sólo hay que buscarla.
Si bien es cierto que esa explicación puede ser muy compleja de encontrar, recuerda que nos movemos entre '0' y '1', (en el caso que nos ocupa, entre bytes y valores hexadecimales).
Estoy de condiciones de arrojar un poco más de luz sobre este atributo de los ficheros residentes en la MFT. Por el camino, en la búsqueda de la información que necesitaba, acudí al Blog de Harlan Carvey, (http://windowsir.blogspot.com), que ha mencionado esta característica en varias ocasiones, en varios de sus artículos. Concretamente, uno de esos artículos de Harlan, publicado el 13 de noviembre de 2013, me llevó a otro artículo, escrito por Hal Pomeranz, bajo el título de "Resident $DATA Residue in NTFS MFT Entries". Y este ha sido mi punto de partida.
Considero interesante leer todo lo que caiga en nuestras manos y prestar atención a las referencias utilizadas porque, en muchas ocasiones, la información que buscamos puede encontrarse en esas referencias que se utilizan.
Recuerdo haber comentado algo, muy de pasada, sobre la MFT en el artículo que escribí en 'Follow the White Rabbit', con el título "¿Qué ha pasado? El ABC del MACB". Al igual que entonces, no voy a desgranar toda la estructura de la MFT y cómo se graban los ficheros en ella. Al final de este artículo te mencionaré algunos enlaces interesantes sobre este tema, por si deseas profundizar más en él.
Introducción
Antes de comenzar... creo conveniente explicar un mínimo sobre el cómo se graban los ficheros en la MFT. Vuelvo a decir que no voy a explicar todos y cada uno de los atributos que podemos encontrar en la MFT porque, para ello, necesitaría de varios extensos artículos. Así, que únicamente mencionaré aquellos que considero de interés para este caso que nos ocupa: Los ficheros residentes y los ficheros no residentes.
Todo en el sistema de ficheros NTFS es un fichero y todo lo que es un fichero se graba en la MFT.
¿Cuándo es un fichero residente? Un fichero es residente cuando toda su información, los datos íntegros del fichero, están alojados únicamente en la MFT. Es decir, que un fichero residente no ocupa espacio en disco, (obviando el propio que usa la MFT para grabar ese registro).
El tamaño asignado en la MFT para cada registro de archivo es de 1024 bytes. Esto quiere decir que si un sector tiene un tamaño de 512 bytes, el registro de un fichero en la MFT ocupará dos sectores. Es indiferente el tamaño de clúster que se le asigne al sistema o al dispositivo de que se trate. No guarda relación. Se trate de un clúster de 512 bytes, o de un clúster de 4096 bytes, la MFT asignará para cada registro 1024 bytes, (dos sectores).
Cosa distinta es si el fichero no es residente en la MFT porque, en ese caso, (donde el fichero sí ocupa un espacio en disco), la información de ese fichero ocupará el espacio asignado al clúster correspondiente. Es decir, si existe un fichero con un tamaño de, por ejemplo, 2000 bytes y el tamaño asignado al clúster es de 512 bytes, entonces ocupará ese clúster, (o clústeres), asignado, (2048 bytes, 4 sectores), mientras que si el tamaño asignado al clúster es de 4096 bytes, entonces ocupará ese clúster asignado, (4096 bytes, 8 sectores).
Tienes a tu disposición toda la explicación relativa a este tema en el sitio oficial de Microsoft.
Tienes a tu disposición toda la explicación relativa a este tema en el sitio oficial de Microsoft.
Los registros grabados en la MFT se representan en valores hexadecimales y cada valor hexadecimal, (cada desplazamiento), representa un byte.
Teniendo en cuenta todo lo anterior, cada registro contendrá un total de 1024 bytes o, lo que es lo mismo, 1024 valores hexadecimales, (aunque no tiene porqué estar todo el espacio ocupado, ni tienen porqué existir en ese registro todos los atributos). Es decir, que, aunque se asigne ese espacio a un registro, un registro grabado en la MFT no tiene porqué abarcar los 1024 bytes, aunque te mostraré ejemplos de ello.
El desplazamiento en bytes comienza desde el byte '0', como primer byte.
Un registro grabado en la MFT presenta una lista de atributos, conforme a lista que puedes consultar en el sitio oficial de Microsoft.
Ten en cuenta que, ni todos los atributos tienen porqué estar presentes en un registro, ni los registros tienen porqué presentar los mismos atributos.
Cada registro comienza con el valor '46494C45', (FILE), que tiene una longitud de 4 bytes. Esta es la cabecera para cada registro alojado en la MFT. Es decir, que el comienzo de cada registro ocupa los cuatro primeros bytes. (Bytes de '0 a 3').
Hasta el byte 151, (donde termina el atributo '$10'), todos los registros presentan el mismo tipo de atributos, (por supuesto, con distintos valores). Las diferencias, en lo relativo a los atributos, comienzan en el byte 152.
La información que nos va a indicar si un fichero es residente o no es residente se encuentra dentro del atributo '$DATA', que comienza con el valor '80000000', cuya ubicación varía, según los casos. Concretamente, se encuentra en el quinto byte, contado desde el final de la cabecera de este atributo. Si se trata de un fichero residente presentará un valor de '00', mientras que si se trata de un fichero no residente presentará un valor de '01'.
La MFT presenta al final de cada registro el valor 'FFFFFFFF', (ÿÿÿÿ), con una longitud de 4 bytes.
Después de esos últimos cuatro bytes que indican el final del registro de archivo, existen otros cuatro bytes.
Las cabeceras de cada uno de los atributos tiene una longitud de 4 bytes.
Mi intención era explicar la situación que se tiene que dar para que un fichero sea residente, o no. Pero en mi investigación me he encontrado con hasta seis situaciones distintas, seis condiciones. Por ello, voy a exponer en primer lugar las pruebas. (Confieso que a partir de este punto me ha dolido la cabeza por pensar en cómo estructurar el contenido).
El desplazamiento en bytes comienza desde el byte '0', como primer byte.
Un registro grabado en la MFT presenta una lista de atributos, conforme a lista que puedes consultar en el sitio oficial de Microsoft.
Ten en cuenta que, ni todos los atributos tienen porqué estar presentes en un registro, ni los registros tienen porqué presentar los mismos atributos.
Cada registro comienza con el valor '46494C45', (FILE), que tiene una longitud de 4 bytes. Esta es la cabecera para cada registro alojado en la MFT. Es decir, que el comienzo de cada registro ocupa los cuatro primeros bytes. (Bytes de '0 a 3').
Hasta el byte 151, (donde termina el atributo '$10'), todos los registros presentan el mismo tipo de atributos, (por supuesto, con distintos valores). Las diferencias, en lo relativo a los atributos, comienzan en el byte 152.
La información que nos va a indicar si un fichero es residente o no es residente se encuentra dentro del atributo '$DATA', que comienza con el valor '80000000', cuya ubicación varía, según los casos. Concretamente, se encuentra en el quinto byte, contado desde el final de la cabecera de este atributo. Si se trata de un fichero residente presentará un valor de '00', mientras que si se trata de un fichero no residente presentará un valor de '01'.
La MFT presenta al final de cada registro el valor 'FFFFFFFF', (ÿÿÿÿ), con una longitud de 4 bytes.
Después de esos últimos cuatro bytes que indican el final del registro de archivo, existen otros cuatro bytes.
Las cabeceras de cada uno de los atributos tiene una longitud de 4 bytes.
Mi intención era explicar la situación que se tiene que dar para que un fichero sea residente, o no. Pero en mi investigación me he encontrado con hasta seis situaciones distintas, seis condiciones. Por ello, voy a exponer en primer lugar las pruebas. (Confieso que a partir de este punto me ha dolido la cabeza por pensar en cómo estructurar el contenido).
Las pruebas
¿Por dónde comenzar las pruebas? Pues, la primera de ellas, por la creación de unos pocos de cientos de ficheros, siendo cada fichero creado de un byte más que el anterior y con nombres correlativos. Para ello, escribí un pequeño fichero batch, teniendo en cuenta que cada carácter alfanumérico representa un byte. Podría haber realizado esta operación con fsutil, asignando directamente el tamaño deseado, pero luego no podría editar esos ficheros generados, cosa que es necesaria para observar el comportamiento de un fichero residente.
El resultado de la ejecución de este pequeño fichero batch...
¡Oh, Dios mío!!Dónde me he metido! 😱😱😱😱😱😱😱😱😱😭 ¡Quiero llorar!
Es hora de tomar mucho café, (grandes dosis de café), hacer mucho trabajo manual y tener mucha paciencia, porque toca comprobar cada uno de los ficheros.
Tras realizar esta primera prueba que he mencionado anteriormente y después de invertir muchas horas para estudiar la situación de todos esos ficheros, he llegado a una conclusión.
¿Quieres saber cuándo un fichero es residente y cuándo no lo es?¿Estás listo para saber el tamaño exacto para que un fichero sea residente, o no lo sea? Pues la respuesta es... Depende 🤪🤪🤪
Depende de si se generan de forma automática o si son creados con un editor 'X'. Depende de si se le asigna un nombre corto o un nombre largo al fichero. Depende de si se encuentra deshabilitada la creación de nombres de archivo 8.3. Depende de varios factores.
Me explico. Lo explico. Porque unas pruebas me han llevado a otras, que me han llevado a otras, que me han llevado a otras, ...
He optado por elegir estas herramientas para contrastar datos, para validar resultados entre una y otra, y así evitar errores en la interpretación de los mismos. Considero que Active Disk Editor es una opción muy cómoda para realizar este estudio.
Esta es la primera prueba que he llevado a cabo, mediante la ejecución de ese fichero batch que he mencionado anteriormente. Ten en cuenta que estos ficheros han sido generados de forma automática, sin pasar por un editor de texto, y asignando un nombre de archivo largo. De todos los ficheros que han sido creados, me he quedado con dos de ellos.
Tras realizar esta primera prueba que he mencionado anteriormente y después de invertir muchas horas para estudiar la situación de todos esos ficheros, he llegado a una conclusión.
¿Quieres saber cuándo un fichero es residente y cuándo no lo es?¿Estás listo para saber el tamaño exacto para que un fichero sea residente, o no lo sea? Pues la respuesta es... Depende 🤪🤪🤪
Depende de si se generan de forma automática o si son creados con un editor 'X'. Depende de si se le asigna un nombre corto o un nombre largo al fichero. Depende de si se encuentra deshabilitada la creación de nombres de archivo 8.3. Depende de varios factores.
Me explico. Lo explico. Porque unas pruebas me han llevado a otras, que me han llevado a otras, que me han llevado a otras, ...
Entorno de pruebas
Las pruebas que he llevado a cabo han sido efectuadas en los siguientes sistemas y dispositivos:
- Windows 7, (versión 6.1.7601)
- Windows 7, (versión 6.1.7600)
- Windows 10, (versión 10.0.17763.404)
- Windows 10, (versión 10.0.18343.1)
- Windows 10, (versión versión 10.0.18890.1000)
- Dispositivo SanDisk Cruzer Blade 32GB, (con formato en NTFS)
Las herramientas que he elegido para determinar si un fichero es residente en la MFT, o no, y para estudiar ese tipo de ficheros, han sido:
- Explorador de Windows
- The Sleuth Kit
- Active Disk Editor
Las pruebas
Fichero residente de 592 bytes; Fichero no residente de 593 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
Esta es la primera prueba que he llevado a cabo, mediante la ejecución de ese fichero batch que he mencionado anteriormente. Ten en cuenta que estos ficheros han sido generados de forma automática, sin pasar por un editor de texto, y asignando un nombre de archivo largo. De todos los ficheros que han sido creados, me he quedado con dos de ellos.
Un fichero con un tamaño de 592 bytes y un fichero con un tamaño de 593 bytes.
El fichero de 592 bytes es un fichero residente en la MFT mientras que el fichero de 593 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 592 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 593 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 593 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
Resulta que el dispositivo USB que he utilizado para efectuar esta otra prueba fue formateado en otro sistema distinto a los que suelo utilizar. Y resulta que ese sistema en cuestión presentaba una modificación que no suelo usar.
¿La respuesta? En la modificación de un valor que se encuentra en la clave de la colmena del Registro:
Windows permite habilitar o deshabilitar la creación de nombres de archivo cortos, tanto en el propio volumen del sistema, como en volúmenes externos. Y resulta que la configuración se guarda en el dispositivo. Es decir, que si formateas un dispositivo USB en un sistema que presenta una determinada configuración, esa configuración se aplica a ese dispositivo, para siempre, hasta un nuevo formateo.
Esta configuración, además, no se aplica con carácter retroactivo. Es decir, que los ficheros del sistema que se encuentren grabados en su correspondiente MFT mantendrán toda esa información grabada y no se aplicarán los cambios hasta que no se reinicie el sistema, únicamente para los nuevos registros.
'Descubierto' esto, he procedido a ejecutar, de nuevo, ese fichero batch para crear otros cientos de ficheros dentro de ese dispositivo USB, (y de otro sistema que he modificado para este trabajo). Ten en cuenta que estos ficheros han sido generados de forma automática, sin pasar por un editor de texto, y asignando un nombre de archivo largo. De todos los ficheros que han sido creados, me he quedado con dos de ellos.
Fichero residente de 592 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Dos atributos '$30', ($FILE_NAME):
- El primer atributo '$30', que se corresponde al nombre de archivo corto, comienza en el byte 152 y tiene una longitud de 120 bytes, (hasta el byte 271).
- El segundo atributo '$30', que se corresponde al nombre de archivo largo, comienza en el byte 272 y tiene una longitud de 128 bytes, (hasta el byte 399).
- Un atributo '$80', ($DATA), que comienza en el byte 400 y tiene una longitud de 616 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 408, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 424 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790200'.
Fichero no residente de 593 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 414.
El atributo '$DATA', que comienza en el byte 400, presenta una longitud de 72 bytes, (hasta el byte 471).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 408), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 465, y el clúster que tiene asignado, que se trata del clúster 3.156.345, en el byte 466.
El final del registro se encuentra en el byte 472.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Si yo no fuera concienzudo y meticuloso, habría dejado aquí el asunto, porque ya tengo una respuesta. Pero me gusta verificar las pruebas que hago porque me gusta hablar sobre seguro, (dentro de lo posible). Así que he seguido ejecutando otro tipo de pruebas. Y he tomado estos ficheros como referencia para las restantes pruebas.
La siguiente prueba que he llevado a cabo ha sido sobre el dispositivo USB. Y es a partir de aquí donde he puesto en marcha mi cerebro a todo lo que da de sí. ¿Por qué? Porque cuando creé esos dos ficheros en ese dispositivo me llevé la sorpresa de que los dos ficheros eran ficheros residentes.
¿Qué he hecho mal?¿Qué ha fallado?¿En qué me he equivocado? En nada. Me he vuelto loco, literalmente, buscando una explicación, mirando todo tipo de configuraciones y estudiando un montón de opciones, hasta que he dado con la clave, (y nunca mejor dicho).
Fichero residente de 712 bytes; Fichero no residente de 713 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
Resulta que el dispositivo USB que he utilizado para efectuar esta otra prueba fue formateado en otro sistema distinto a los que suelo utilizar. Y resulta que ese sistema en cuestión presentaba una modificación que no suelo usar.
¿La respuesta? En la modificación de un valor que se encuentra en la clave de la colmena del Registro:
'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisable8dot3NameCreation'.
Windows permite habilitar o deshabilitar la creación de nombres de archivo cortos, tanto en el propio volumen del sistema, como en volúmenes externos. Y resulta que la configuración se guarda en el dispositivo. Es decir, que si formateas un dispositivo USB en un sistema que presenta una determinada configuración, esa configuración se aplica a ese dispositivo, para siempre, hasta un nuevo formateo.
Esta configuración, además, no se aplica con carácter retroactivo. Es decir, que los ficheros del sistema que se encuentren grabados en su correspondiente MFT mantendrán toda esa información grabada y no se aplicarán los cambios hasta que no se reinicie el sistema, únicamente para los nuevos registros.
'Descubierto' esto, he procedido a ejecutar, de nuevo, ese fichero batch para crear otros cientos de ficheros dentro de ese dispositivo USB, (y de otro sistema que he modificado para este trabajo). Ten en cuenta que estos ficheros han sido generados de forma automática, sin pasar por un editor de texto, y asignando un nombre de archivo largo. De todos los ficheros que han sido creados, me he quedado con dos de ellos.
Un fichero con un tamaño de 712 bytes y un fichero con un tamaño de 713 bytes.
El fichero de 712 bytes es un fichero residente en la MFT mientras que el fichero de 713 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 712 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 713 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 713 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
Así, he efectuado otra prueba. En esta ocasión he creado unos cuantos ficheros de texto, (muchos), manualmente, con distintos tamaños, asignando, como en los casos anteriores, un nombre de archivo largo, pero la creación ha sido mediante la edición en el bloc de notas de Windows. De todos los ficheros que he creado, me he quedado con dos de ellos.
Fichero residente de 712 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Un atributo '$30', ($FILE_NAME), que comienza en el byte 152 y tiene una longitud de 128 bytes, (hasta el byte 279), por lo que se corresponde al de nombre de archivo largo.
- Un atributo '$80', ($DATA), que comienza en el byte 280 y tiene una longitud de 736 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 288, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 304 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790200'.
Fichero no residente de 713 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 294.
El atributo '$DATA', que comienza en el byte 280, presenta una longitud de 72 bytes, (hasta el byte 351).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 288), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 345, y el clúster que tiene asignado, que se trata del clúster 3.150.984, en el byte 346.
El final del registro se encuentra en el byte 352.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Vista esta segunda prueba que he efectuado, la primera conclusión que saco de todo esto es que, cuando un atributo no está presente, en el registro de un fichero, el espacio que debiera ocupar ese atributo ausente es asignado al atributo '$DATA'.
¿Cómo he llegado a ese punto? En la prueba efectuada con el fichero residente de 592 bytes, la longitud del atributo '$DATA' es de 616 bytes, mientras que en esta prueba con el fichero residente de 712 bytes, la longitud del atributo '$DATA' es de 736. Así que si restamos '736 - 616' obtenemos un resultado de 120 bytes, que es, casualmente, la longitud del atributo ausente '$30', correspondiente al nombre de archivo corto.
Nuevamente, podría haber dejado esto aquí, porque ya tengo otra respuesta con una cierta lógica. Pero visto esto... me ha dado por pensar un poco más. Por ir un poco más allá. Así que cogí un papel y un lápiz y empecé a tomar notas para ver cómo y en qué condiciones puedo crear ficheros.
Fichero residente de 552 bytes; Fichero no residente de 553 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
Así, he efectuado otra prueba. En esta ocasión he creado unos cuantos ficheros de texto, (muchos), manualmente, con distintos tamaños, asignando, como en los casos anteriores, un nombre de archivo largo, pero la creación ha sido mediante la edición en el bloc de notas de Windows. De todos los ficheros que he creado, me he quedado con dos de ellos.
Un fichero con un tamaño de 552 bytes y un fichero con un tamaño de 553 bytes.
El fichero de 552 bytes es un fichero residente en la MFT mientras que el fichero de 553 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 552 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 553 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 553 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
Vuelvo a modificar el valor de la clave del Registro:
Ahora tan sólo creo dos ficheros, porque ya sé cómo jugar a esto.
Si partimos del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos...
592 bytes del fichero, sumado a los 120 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo corto), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 672 bytes. Es decir, que si genero dos ficheros de texto, de 672 bytes y de 673 bytes, manualmente, con el bloc de notas, y se encuentra inhabilitada la generación de nombres cortos en el registro de la MFT, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Fichero residente de 552 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Dos atributos '$30', ($FILE_NAME):
- El primer atributo '$30', que se corresponde al nombre de archivo corto, comienza en el byte 152 y tiene una longitud de 120 bytes, (hasta el byte 271).
- El segundo atributo '$30', que se corresponde al nombre de archivo largo, comienza en el byte 272 y tiene una longitud de 128 bytes, (hasta el byte 399).
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 400 y tiene una longitud de 40 bytes, (hasta el byte 439).
- Un atributo '$80', ($DATA), que comienza en el byte 440 y tiene una longitud de 676 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 448, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 464 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790F00'.
Fichero no residente de 553 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 454.
El atributo '$DATA', que comienza en el byte 440, presenta una longitud de 72 bytes, (hasta el byte 411).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 448), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 505, y el clúster que tiene asignado, que se trata del clúster 3.149.052, en el byte 506.
El final del registro se encuentra en el byte 512.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Ha aparecido un nuevo atributo en el campo de juego. Se trata del atributo '$40', que pertenece al '$OBJECT_ID'. Un detalle 'curioso' que aparezca este atributo sólo con la edición del fichero. ¿Por qué no se ha manifestado antes?
Con esta prueba estoy en condiciones de afirmar, sin miedo a equivocarme, que el espacio que debiera ocupar un atributo que se encuentra ausente es asignado al atributo '$DATA'.
Sigo con mis pruebas... Con las opciones que se me ocurren... Y...
Fichero residente de 672 bytes; Fichero no residente de 673 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
Vuelvo a modificar el valor de la clave del Registro:
'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisable8dot3NameCreation',para evitar la creación de los nombres de archivo cortos en los registros de los ficheros en la MFT y creo los mismos ficheros que antes, asignando un nombre de archivo largo y manualmente, mediante el bloc de notas.
Ahora tan sólo creo dos ficheros, porque ya sé cómo jugar a esto.
Si partimos del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos...
592 bytes del fichero, sumado a los 120 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo corto), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 672 bytes. Es decir, que si genero dos ficheros de texto, de 672 bytes y de 673 bytes, manualmente, con el bloc de notas, y se encuentra inhabilitada la generación de nombres cortos en el registro de la MFT, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Así que me quedo con un fichero con un tamaño de 672 bytes y un fichero con un tamaño de 673 bytes.
El fichero de 672 bytes es un fichero residente en la MFT mientras que el fichero de 673 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 672 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 673 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 673 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
En esta ocasión, he creado dos nuevos ficheros, con dos tamaños distintos, manualmente, mediante el bloc de notas, pero esta vez asignando un nombre de archivo corto. Concretamente, un nombre de 8 caracteres.
Si volvemos a partir del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos... y teniendo en cuenta que el atributo '$30', correspondiente al nombre de archivo corto, ocupa 120 bytes, mientras que el atributo '$30', correspondiente al nombre de archivo largo, ocupa 128 bytes, ...
592 bytes del fichero, sumado a los 128 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo largo), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 680 bytes. Es decir, que si genero dos ficheros de texto, de 680 bytes y de 681 bytes, manualmente, con el bloc de notas, y le asigno un nombre corto de archivo, en el registro de la MFT, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Fichero residente de 672 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Un atributo '$30', ($FILE_NAME), que comienza en el byte 152 y tiene una longitud de 128 bytes, (hasta el byte 279), por lo que se corresponde al de nombre de archivo largo.
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 280 y tiene una longitud de 40 bytes, (hasta el byte 319).
- Un atributo '$80', ($DATA), que comienza en el byte 320 y tiene una longitud de 696 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 328, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 344 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790200'.
Fichero no residente de 673 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 334.
El atributo '$DATA', que comienza en el byte 320, presenta una longitud de 72 bytes, (hasta el byte 391).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 328), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 385, y el clúster que tiene asignado, que se trata del clúster 3.156.283, en el byte 386.
El final del registro se encuentra en el byte 392.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Mmmmm. Me resulta muy curioso cómo funciona la grabación de los ficheros en la MFT. Se me ocurren algunas cosas más para probar...
Fichero residente de 680 bytes; Fichero no residente de 681 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
En esta ocasión, he creado dos nuevos ficheros, con dos tamaños distintos, manualmente, mediante el bloc de notas, pero esta vez asignando un nombre de archivo corto. Concretamente, un nombre de 8 caracteres.
Si volvemos a partir del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos... y teniendo en cuenta que el atributo '$30', correspondiente al nombre de archivo corto, ocupa 120 bytes, mientras que el atributo '$30', correspondiente al nombre de archivo largo, ocupa 128 bytes, ...
592 bytes del fichero, sumado a los 128 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo largo), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 680 bytes. Es decir, que si genero dos ficheros de texto, de 680 bytes y de 681 bytes, manualmente, con el bloc de notas, y le asigno un nombre corto de archivo, en el registro de la MFT, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Así que me quedo con un fichero con un tamaño de 680 bytes y un fichero con un tamaño de 681 bytes.
El fichero de 680 bytes es un fichero residente en la MFT mientras que el fichero de 681 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 680 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 681 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 681 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
En esta ocasión, he creado dos nuevo ficheros, con dos tamaños distintos, manualmente, mediante el bloc de notas, pero esta vez asignando un nombre de archivo corto. Concretamente, un nombre de 1 sólo carácter alfanumérico.
Si volvemos a partir del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos... y teniendo en cuenta que el atributo '$30', correspondiente al nombre de archivo corto, ocupa 120 bytes, mientras que el atributo '$30', correspondiente al nombre de archivo largo, ocupa 128 bytes, ...
592 bytes del fichero, sumado a los 128 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo largo), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 680 bytes. Es decir, que en este caso, si genero dos ficheros de texto, de 680 bytes y de 681 bytes, manualmente, con el bloc de notas, y le asigno un nombre corto de archivo, en el registro de la MFT, y teóricamente, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Pero eso sería teóricamente. Porque el atributo '$30' tiene un tamaño máximo, pero también tiene un tamaño mínimo.
En este caso en particular, en el que sólo he usado un carácter alfanumérico para nombrar un fichero...
Creo que me falta por mostrar qué ocurre con un fichero con un nombre corto asignado y con una creación automática. Para ello, usé el mismo fichero batch que en pruebas anteriores para crear un par de ficheros. Pero en esta ocasión se encuentra deshabilitada la generación de nombres de archivo corto, cambiando el valor de la clave del Registro que he mencionado antes.
Siguiendo con la misma dinámica que en el ejemplo anterior, un fichero nombrado como 'A.txt', podrá ser residente con un tamaño máximo de 720 bytes, mientras que un fichero nombrado como 'File728.txt' podrá ser residente con un tamaño máximo de 728 bytes. Esto ocurre porque tenemos que sumar los 40 bytes correspondientes al atributo '$40' que no nos vamos a encontrar en ese registro.
Fichero residente de 680 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Un atributo '$30', ($FILE_NAME), que comienza en el byte 152 y tiene una longitud de 120 bytes, (hasta el byte 271), por lo que se corresponde al de nombre de archivo corto.
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 280 y tiene una longitud de 40 bytes, (hasta el byte 311).
- Un atributo '$80', ($DATA), que comienza en el byte 312 y tiene una longitud de 704 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 320, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 336 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82799E00'.
Fichero no residente de 681 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 326.
El atributo '$DATA', que comienza en el byte 312, presenta una longitud de 72 bytes, (hasta el byte 383).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 320), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 377, y el clúster que tiene asignado, que se trata del clúster 3.148.935, en el byte 378.
El final del registro se encuentra en el byte 384.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Tal y como acabamos de comprobar, cuando asignamos un nombre de archivo corto a un fichero, únicamente se va a grabar en el registro correspondiente la información correspondiente al atributo '$30', de nombre de archivo corto. ¿Por qué? Porque el sistema no precisa de más información para completar la información de ese fichero. Por eso prescinde de los 128 bytes que le corresponden al atributo '$30', de nombre de archivo largo.
Ahora... Me pregunto si...
¿Qué ocurre en caso de que le asigne un nombre más corto, aún?
Fichero residente de 696 bytes; Fichero no residente de 697 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
En esta ocasión, he creado dos nuevo ficheros, con dos tamaños distintos, manualmente, mediante el bloc de notas, pero esta vez asignando un nombre de archivo corto. Concretamente, un nombre de 1 sólo carácter alfanumérico.
Si volvemos a partir del primero de los ejemplos, como fichero de referencia, donde el fichero de 592 bytes era un fichero residente, que ha sido creado de forma automática y sin deshabilitar la generación de nombres de archivo cortos... y teniendo en cuenta que el atributo '$30', correspondiente al nombre de archivo corto, ocupa 120 bytes, mientras que el atributo '$30', correspondiente al nombre de archivo largo, ocupa 128 bytes, ...
592 bytes del fichero, sumado a los 128 bytes que ocuparía el atributo '$30', (correspondiente al nombre de archivo largo), y restado de 40 bytes, que va a ocupar el atributo '$40'... tenemos un resultado de 680 bytes. Es decir, que en este caso, si genero dos ficheros de texto, de 680 bytes y de 681 bytes, manualmente, con el bloc de notas, y le asigno un nombre corto de archivo, en el registro de la MFT, y teóricamente, el primero de esos ficheros debe ser residente, pero el segundo no debe ser residente.
Pero eso sería teóricamente. Porque el atributo '$30' tiene un tamaño máximo, pero también tiene un tamaño mínimo.
En este caso en particular, en el que sólo he usado un carácter alfanumérico para nombrar un fichero...
Me quedo con un fichero con un tamaño de 696 bytes y un fichero con un tamaño de 697 bytes. (16 bytes más que en el caso anterior).
El fichero de 696 bytes es un fichero residente en la MFT mientras que el fichero de 697 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 696 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 697 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 697 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
Fichero residente de 696 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Un atributo '$30', ($FILE_NAME), que comienza en el byte 152 y tiene una longitud de 104 bytes, (hasta el byte 255), por lo que se corresponde al de nombre de archivo corto.
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 256 y tiene una longitud de 40 bytes, (hasta el byte 295).
- Un atributo '$80', ($DATA), que comienza en el byte 296 y tiene una longitud de 720 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 304, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 320 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790400'.
Fichero no residente de 697 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 310.
El atributo '$DATA', que comienza en el byte 296, presenta una longitud de 72 bytes, (hasta el byte 367).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 304), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 361, y el clúster que tiene asignado, que se trata del clúster 3.148.938, en el byte 362.
El final del registro se encuentra en el byte 384.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Mmmmm... Muy curioso. Voy a tratar de explicarlo de manera sencilla.
Como decía un poco más arriba, el atributo '$30', correspondiente al nombre de archivo corto, tiene un tamaño máximo de 120 bytes, pero también tiene un tamaño mínimo que, en caso de no estar ocupado, el sistema llena de '00'. Para ver esta diferencia he creado otro fichero idéntico, pero he asignado un nombre de tres dígitos. Así que vamos a comparar tres nombres cortos de fichero: El fichero nombrado como 'File0680.txt', el fichero nombrado como 'A.txt' y el fichero nombrado como '696.txt'.
En la imagen anterior, tal y como puedes apreciar, (espero), se encuentra el atributo '$30', relativo al nombre de archivo corto. Dentro de este atributo se encuentra al final, resaltado, el nombre de archivo corto, que comienza en el byte 92 dentro de este atributo. El nombre de fichero es la última información que se graba en este atributo.
El fichero nombrado como 'File696.txt', que comienza en la misma posición, (byte 92 dentro del propio atributo), está compuesto por 12 caracteres unicode, que pasa a tener 24 caracteres ASCII, porque después de cada carácter se asigna el valor '00', (que corresponde a un '.'). Es decir, que el nombre de este fichero tiene una longitud de 24 bytes. Pero, si te fijas en la imagen, el sistema asigna seis valores hexadecimales más, con valores de '00'. Así que tenemos un total de 30 bytes.
El fichero nombrado como 'A.txt', siguiendo la misma estructura que el fichero anterior, se compone de 5 caracteres unicode, que pasa a tener 10 caracteres ASCII. Pero el sistema marca a '00' los cuatro últimos bytes. Es decir, que el nombre de este fichero tiene una longitud de 14 bytes.
Ocurre exactamente lo mismo con el fichero '696.txt', que se compone de 7 caracteres unicode, que pasa a tener 14 caracteres ASCII, pero en este caso el sistema no marca los últimos bytes a '00'. Así que este fichero tiene también una longitud de 14 bytes.
Así que, si se restan los 30 bytes del fichero nombrado como 'File696' a los 14 bytes de los ficheros nombrados como 'A.txt' y '696.txt', la diferencia es de 16 bytes. La diferencia de tamaño entre el caso anterior y este.
Según estas pruebas, el tamaño mínimo que se reserva para el nombre de archivo corto, dentro del atributo '$30', es de 14 bytes. ¿Por qué ocurre esto? Para verlo de manera gráfica he creado algunos ficheros, nombrados como 'A', 'AA', 'AAA', ... hasta un total de ocho.
La información del nombre de archivo comienza en el byte 92, dentro del propio atributo, que coincide con el tercer byte del primer octeto. El sistema no finaliza la información del atributo hasta que no completa un octeto. Así que el sistema, cuando el nombre de un fichero comienza un octeto, pero no lo termina, asigna valores a '00' hasta el final de ese octeto.
Así que, con la creación de ficheros manualmente y dependiendo de la longitud del nombre de archivo corto, la diferencia entre un fichero residente y otro no va a estar en un byte, si no en ocho bytes. Por ejemplo, mientras que un fichero nombrado como 'A.txt' es residente con un tamaño máximo de 696 bytes, un fichero nombrado como 'AAAA.txt' será residente con un tamaño máximo de 688 bytes.
Para terminar con las posibles formas de crear ficheros y ver sus respectivos tamaños para determinar así en qué momento pueden ser ficheros residentes...
Fichero residente de 728 bytes; Fichero no residente de 729 bytes
El fichero de la izquierda corresponde a un fichero residente. El fichero de la derecha corresponde a un fichero no residente.
Creo que me falta por mostrar qué ocurre con un fichero con un nombre corto asignado y con una creación automática. Para ello, usé el mismo fichero batch que en pruebas anteriores para crear un par de ficheros. Pero en esta ocasión se encuentra deshabilitada la generación de nombres de archivo corto, cambiando el valor de la clave del Registro que he mencionado antes.
Siguiendo con la misma dinámica que en el ejemplo anterior, un fichero nombrado como 'A.txt', podrá ser residente con un tamaño máximo de 720 bytes, mientras que un fichero nombrado como 'File728.txt' podrá ser residente con un tamaño máximo de 728 bytes. Esto ocurre porque tenemos que sumar los 40 bytes correspondientes al atributo '$40' que no nos vamos a encontrar en ese registro.
Así que, para este ejemplo, me quedo con un fichero con un tamaño de 728 bytes y un fichero con un tamaño de 729 bytes.
El fichero de 728 bytes es un fichero residente en la MFT mientras que el fichero de 729 bytes no está residente en la MFT.
Tal y como puedes apreciar en la imagen anterior, el fichero con un tamaño de 728 bytes no ocupa espacio en disco, mientras que el fichero con un tamaño de 729 bytes sí ocupa espacio en disco. Concretamente, el fichero con un tamaño de 729 bytes, ocupa en disco 4096 bytes, que es el tamaño asignado al clúster, (8 sectores).
Fichero residente de 728 bytes
En este caso, encontramos los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Un atributo '$30', ($FILE_NAME), que comienza en el byte 152 y tiene una longitud de 112 bytes, (hasta el byte 263).
- Un atributo '$80', ($DATA), que comienza en el byte 264 y tiene una longitud de 752 bytes, (hasta el byte 1015).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 272, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '00', que indica que es residente.
- En el byte 2884 se encuentra el comienzo del contenido del fichero, (21 bytes después del final de la cabecera de este atributo).
- El final del registro del fichero se encuentra en el byte 1016.
- Los últimos cuatro bytes del registro presentan el valor '82790800'.
Fichero no residente de 729 bytes
En este caso nos encontramos con los mismos tipos de atributos que en el caso anterior, con alguna diferencia. Esta diferencia comienza a partir del byte 278.
El atributo '$DATA', que comienza en el byte 264, presenta una longitud de 72 bytes, (hasta el byte 351).
La información que nos indica si un fichero es residente, o no, se encuentra en el mismo byte que en el caso anterior, (byte 272), que presente un valor de '01' y que indica que se trata de un fichero no residente.
Como este fichero sí ocupa espacio en disco, tiene un clúster asignado. Y el registro muestra que el número de clústeres que usa ese fichero es uno, en el byte 329, y el clúster que tiene asignado, que se trata del clúster 3.187.319, en el byte 330.
El final del registro se encuentra en el byte 336.
Los últimos cuatro bytes del registro presentan el valor '82794711'.
Estas son las pruebas que se me han ocurrido llevar a cabo, en cuanto a la creación de ficheros, asignando distintas longitudes de nombres, generándolos de manera distinta y con habilitación y deshabilitación de nombre de archivo corto.
Otra vez, podría haber dejado aquí este asunto, pero necesito saber cómo se comporta un fichero residente, cuando es editado, cuando es modificado.
Comportamiento de un fichero residente
Para llevar a cabo esta prueba he optado por tomar el fichero que usado como referencia para todas las demás, el fichero nombrado como '00Fichero592.txt', y editarlo, añadiendo en él la palabra 'Marcos'. Así, que el fichero pasa de tener un tamaño de 592 bytes, a tener un tamaño de 598 bytes. Por lo que deja de ser un fichero residente.
Tras su edición en Windows 7, el fichero pasa a tener los siguientes atributos::
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Dos atributos '$30', ($FILE_NAME):
- El primer atributo '$30', que se corresponde al nombre de archivo corto, comienza en el byte 152 y tiene una longitud de 120 bytes, (hasta el byte 271).
- El segundo atributo '$30', que se corresponde al nombre de archivo largo, comienza en el byte 272 y tiene una longitud de 128 bytes, (hasta el byte 399).
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 400 y tiene una longitud de 40 bytes, (hasta el byte 439).
- Un atributo '$80', ($DATA), que comienza en el byte 440 y tiene una longitud de 72 bytes, (hasta el byte 511).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 448, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '01', que indica que es un fichero no residente.
- El número de clústeres que usa el fichero se encuentra en el byte 505.
- El clúster que tiene asignado el fichero se encuentra en el byte 506
- El final del registro del fichero se encuentra en el byte 512.
- Los últimos cuatro bytes del registro presentan el valor '82794711'.
La sorpresa viene después del supuesto final del registro del fichero, porque el contenido que existía antes en ese registro se puede encontrar de igual manera cuando el fichero deja de ser un fichero residente.
Además de encontrarse parte de la información del fichero en ese registro, también se encuentra en el clúster asignado, correspondiendo a este caso al clúster 32.664.
Vuelvo a editar ese mismo fichero, eliminando la palabra añadida 'Marcos', para que vuelva a su tamaño original de 592 bytes. El resultado es que ese fichero no vuelve a ser un fichero residente, aunque su contenido se muestra en ese registro.
Y la información, actualizada, también se muestra en el mismo clúster que tenía asignado cuando ha dejado de ser un fichero residente.
Es decir, que en un sistema Windows 7, cuando se modifica un fichero residente para que deje de serlo, la información se grabará a un nuevo clúster, pero también mantendrá parte de esa información en el propio registro del fichero, manteniendo siempre ese clúster asignado.
Realizo la misma operación sobre Windows 10, y tras su edición, con un tamaño de 598 bytes, el fichero pasa a tener los siguientes atributos:
- Un atributo '$10', ($TANDARD_INFORMATION), que comienza en el byte 56 y tiene una longitud de 96 bytes, (hasta el byte 151).
- Dos atributos '$30', ($FILE_NAME):
- El primer atributo '$30', que se corresponde al nombre de archivo corto, comienza en el byte 152 y tiene una longitud de 120 bytes, (hasta el byte 271).
- El segundo atributo '$30', que se corresponde al nombre de archivo largo, comienza en el byte 272 y tiene una longitud de 128 bytes, (hasta el byte 399).
- Un atributo '$40', ($OBJECT_ID), que comienza en el byte 400 y tiene una longitud de 40 bytes, (hasta el byte 439).
- Un atributo '$80', ($DATA), que comienza en el byte 440 y tiene una longitud de 72 bytes, (hasta el byte 511).
- La información que nos indica si es un fichero residente, o no, se encuentra en el byte 448, (el quinto byte desde que termina la cabecera de este atributo), y presenta un valor de '01', que indica que es un fichero no residente.
- El número de clústeres que usa el fichero se encuentra en el byte 505.
- El clúster que tiene asignado el fichero se encuentra en el byte 506
- El final del registro del fichero se encuentra en el byte 512.
- Los últimos cuatro bytes del registro presentan el valor '82794711'.
Después del final del registro del fichero, la información que se encontraba antes residente, deja de estarlo, porque pasa en su totalidad al clúster asignado en el momento que supera el tamaño máximo para un fichero residente.
Vuelvo a editar ese mismo fichero, eliminando la palabra añadida para que vuelva a tener el tamaño de 592 bytes, y presenta exactamente la misma información, a excepción de un nuevo clúster donde se almacena la información del fichero. Si en el ejemplo anterior el sistema asignaba a ese fichero que había dejado de ser residente el clúster 3.264.719, ahora le ha asignado el clúster 50.179, siguiendo sin ser un fichero residente, a pesar de tener el tamaño adecuado para serlo.
Es decir, que con cada edición de un fichero residente, en un sistema Windows 10, un clúster nuevo va a ser asignado a la información de ese fichero. Y esa información permanecerá ahí hasta que se sobreescriba por otro registro, en caso de encontrarse sin asignar ese clúster.
Ya vamos terminando con este pequeño trabajo...
Conclusiones
¿Existe un tamaño único para que un fichero sea residente en la MFT o no lo sea? No. No existe un tamaño único para que se dé esa condición, porque depende de varios factores.
El espacio que no es usado por atributos que no están presente en el registro del archivo se asigna al atributo '$DATA'. Así que, por ejemplo, si tenemos un registro sin un atributo '$40', que tiene una longitud de 40 bytes, esos 40 bytes son asignados al atributo '$DATA', por lo que el fichero tiene 40 bytes más para que pueda ser un fichero residente.
El primer factor que influye en el tamaño para que un fichero pueda ser residente, o no, es su forma de creación. Si se crea en el sistema o dispositivo un fichero, de forma automática, tendrá más espacio para que se pueda tratar de un fichero residente que si creamos el fichero mediante una edición en el sistema.
Si el sistema se encuentra configurado para que no se generen los nombres de archivo corto, (8.3), en el registro del fichero, ese fichero dispondrá de 120 bytes más, (que son asignados al atributo '$DATA'), para que se pueda tratar de un fichero residente en la MFT.
La deshabilitación o habilitación de nombres de archivo cortos, (8.3), no se aplican con carácter retroactivo. Es decir, que si en la MFT se encuentran grabados 'X' ficheros con 'X' atributos, el sistema mantendrá esa información hasta el reinicio oportuno y aplicará los cambios, únicamente a los nuevos registros.
Si se formatea en NTFS un dispositivo externo, (o cualquier otro volumen), ese dispositivo guardará la misma configuración que ese sistema, hasta un nuevo formateo.
En todas mis pruebas, al final del registro de un archivo no residente en la MFT, después del valor 'FFFFFFFF', he obtenido el mismo valor '82794711', variando los dos últimos valores en caso de tratarse de ficheros residentes.
En el caso de que se asigne un nombre corto a un fichero, (hasta 8 caracteres), el tamaño máximo para que un fichero sea residente, o no, dependerá de los octetos que ocupe la longitud del nombre, porque el sistema, cuando tiene un nombre que comienza un octeto pero no lo termina, lo graba a '00' hasta el final de ese octeto. Un fichero nombrado con un sólo carácter será residente con el mismo tamaño que un fichero nombrado con tres caracteres, por esa razón.
Sé que, seguramente, no habrás leído todo el contenido del texto y sé que te gustan las tablas para una mejor comprensión. Así que te dejo una pequeña tabla con los datos que he obtenido en mis pruebas.
En la tabla,
- Entiéndase por creación automática, todo fichero creado que no ha sido editado directamente por el usuario.
- Entiéndase por nombre largo, todo fichero cuyo nombre se compone de más de 8 caracteres.
- Entiéndase por edición, todo fichero que es creado por el propio usuario, haciendo uso de algún editor.
- Entiéndase por nombre corto, todo fichero cuyo nombre se compone de 8 caracteres, o menos.
- Entiéndase por 'Sin 8.3', todo fichero que ha sido creado, teniendo deshabilitada la característica de creación de nombre de archivo corto, desde el Registro.
Primeramente te muestro los resultados de mis pruebas, en los concerniente a los nombres de archivo largo, con el tamaño máximo para que se pueda tratar de un fichero residente y con el tamaño para que deje de tener esa condición.
Ahora te muestro otra tabla más, con los resultados obtenidos de la generación de nombres de archivo corto, puesto que depende de la longitud del nombre del fichero, éste podrá ser residente con un tamaño u otro. Igual que en la tabla anterior, te muestro el tamaño máximo para que un fichero pueda ser residente en la MFT y el tamaño para que deje de ser residente, con la longitud del nombre de archivo, puesto que depende de ello para que se dé una condición u otra.
Para terminar, te dejo a continuación unos enlaces de interés y referencias.
Enlaces de interés y referencias
NTFS_CHEAT_SHEETS (PDF)
Si deseas hacer tú mismo algunas pruebas, puedes:
- Descargar de aquí el fichero para crear archivos de 592 bytes y de 593 bytes, con nombre largo de archivo.
- Descargar de aquí el fichero para crear archivos de 712 bytes y de 713 bytes, con nombre largo de archivo, teniendo deshabilitada la generación de nombres de archivo corto, (8.3)
- Descarga de aquí el fichero para crear archivos de 728 bytes y de 729 bytes, con nombre corto de archivo, (7 caracteres).
- Hacer tus propias pruebas 😉😉
Espero que esta información le resulte útil a alguien. Eso es todo,
Entradas
No hay comentarios:
Publicar un comentario