19 respuestas en este tema

[escafandra]

Hace unas semanas comentaba con seoane que tras la publicación de dos artículos suyos sobre la lectura directa de discos FAT32, escribí un código en C/C++ añadiendo mas funcionalidad y compatible con FAT16 . No lo compatibilicé con FAT12 por el desuso actual de ese sistema de archivos. A Domingo le agradó mi interés en el tema y me animó a publicarlo. Así que quedé con seoane en impulsar un poco el tema, organizar y publicar el código, pero mis quehaceres me obligaron a posponerlo. Este tipo de código puede resultar peligroso para una unidad USB, así que me he tomado tiempo en realizar pruebas con distintos tipos de Pendrives pequeños
y grandes de hasta 32GB.

Como el tema que abrió seoane data de hace casi 2 meses, este mensaje se me alarga un poco y se centra en C/C++, me ha parecido oportuno abrir un nuevo tema y no continuar con el previo.

El código que presento lee directamente los dispositivos sin usar Streams, es compatible con FAT16 y 32, interpreta  nombres largos de archivo, realiza imágenes de los dispositivos, las lee y es capaz de extraer archivos o carpetas, tanto de un disco como de un archivo de imagen. Estas últimas características pueden ser de utilidad a la hora de realizar copias de seguridad de las unidades con fines restauradores y para extraer el contenido de las mismas sin necesidad de restaurar una unidad.

El código está escrito en C/C++ en forma de API, no es OOP pero se podría escribir una clase con escasos cambios.

Acompaño una aplicación escrita en BCB6 que muestra el uso de la API y hace amigable este asunto, en un entorno gráfico con un TreeView, unos Memo y un ListView que representa un explorador gráfico. El programa detecta automáticamente la inserción de unidades USB y las coloca en un árbol, cuyo primer nivel es la unidad física y en el segundo, muestra la unidad lógica. La aplicación se podría complicar bastante mas...

Como curiosidad añadida, si recordáis el artículo de seoane en el que hablaba de cómo bloquear el acceso a un archivo autorun.inf, la APP de ejemplo usa la API que comento, para tratar los atributos de archivo FAT16/32 a bajo  nivel realizando la tarea descrita en cualquier archivo o carpeta del disco. También podemos jugar con los atributos de directorio y archivo convirtiendo lo uno en lo otro y haciendo inaccesible los contenidos para Windows. En fin, es cuestión de jugar y experimentar.

He de advertir prudencia a la hora de restaurar imágenes de los pendrives, si equivocamos la unidad la machacaremos con la imagen convirtiéndola en otro pendrive... El programa avisará varias veces antes de escribir encima de una unidad de disco.

La API es fácil de usar. Primeramente debemos inicializar con la función OpenDisk que abre el disco físico o unidad lógica en cuestión. Precisa de un parámetro especial, un puntero a un tipo que he llamado ID_VOL y que  almacenará el MBR, BMB, FAT y algunos datos mas de la unidad abierta. Este parámetro se precisará para el resto de las API y representa la unidad que hemos abierto. Al finalizar siempre deberemos llamar a CloseDisk con el consabido parámetro. El código está bastante documentado.

Un ejemplo simple en una aplicación de consola:

cpp

// Inicializamos y abrimos la unidad K:
ID_VOL IdV;
int Status = OpenDisk("\\\\.\\K:", &IdV, 0, false);
 
// Leemos el Root Directory
ListDir(&IdV, "");
// Leemos el Contenido de una carpeta: "K:\Mi Carpeta"
ListDir(&IdV, "Mi Carpeta");
 
// Cambiando atributos
ModifyAttr(&IdV, "Autorun.inf", ATTR_DEVICE, ATTR_DEVICE);
 
// Terminamos...
CloseDisk(&IdV);

Como la unidad abierta está representada por ID_VOL, se omite "K:\". Así, si damos una ruta como "Mi Carpeta" se entiende que es del directorio raíz; sin embargo "Mi Carpeta\archivo" entiende que archivo está en “Mi Carpeta” y que ésta se encuentra en el directorio raíz.

Una curiosidad final: el programa que presento es capaz de "trucar" una memoria USB de forma que parezca de un tamaño mucho mas grande del real. Hice una prueba volcando una imagen de un pendrive de 16 GB a a otro viejo de 500 Mb, imaginaros el resultado  . Claro, esto como experimento o broma puede estar bien pero ese pendrive está un poco corrupto... ya lo restauraré.

Subo imágenes de la aplicación, el código fuente para BCB6 y el binario compilado.

Espero que el código y el programa sean de utilidad y sirvan de base para desarrollos futuros. Perdonarme si os aburre tanto C, si tengo mas tiempo procuraré migrar, al menos la API, a delphi, pero no prometo nada. Quizás algún valiente se atreva a hincarle el diente.



Saludos.


PD/ He adaptado el proyecto para que pueda ser compilado con bcb6pe.
Los platinos recordarán el hilo que inició cHackAll

 

PD2/ Por algún motivo desaparecieron los enlaces del código de NaviFat. Los adjunto con la última versión que guardo: 27-6-2012.

Archivos adjuntos

•  3666_2d66dca84c0444d551dda772139c466fa7f1b579.png   49,34KB   10 descargas
•  3664_7190d0d668fc0f0fc8815965b4bb5143c8ccfba7.png   81,02KB   12 descargas
•  Navifat.rar   37,33KB   4 descargas
•  NaviFat_bin.rar   279,66KB   6 descargas

[seoane]

  Excelente !!!

Un trabajo magnifico, me descubro ante ti maestro.

Tengo que revisarlo a fondo, pero por lo de pronto ya me has resuelto una duda que tenia desde hace tiempo, como relacionar la letra de la unidad con el disco físico.

Gracias por compartirlo.

[escafandra]

Me alegra que te guste. Cuando sacaste el tema me resultó interesante sobre todo porque me recordó viejos tiempos lidiando con disquetes y algún disco duro con el DOS y el "debug"... Pero también me pareció un tema de actualidad, asi que quise darle un empujoncito  .

...Un trabajo magnifico, me descubro ante ti maestro.

Bueno, aunque posiblemente aparezca alguna cosilla que arreglar a mi me gusta como ha quedado. Por cierto que un maestro me califique de maestro es todo un halago, amigo.

...me has resuelto una duda que tenia desde hace tiempo, como relacionar la letra de la unidad con el disco físico.

Bueno, esa duda me la planteé cuando quise colocar las unidades en un árbol y fue la revisión de la API de Windows (msdn.microsoft.com) la que me dio la solución.

Ya ves que no eres el único interesado en cosas raras.


Saludos.

[seoane]

Ya ves que no eres el único interesado en cosas raras.

Es lo que tiene internet, que nunca falta un roto para un descosido 

[seoane]

Portar todo esto a Delphi es un monton de trabajo, pero podemos ir portando algunas funciones.

Como esta:

delphi

uses
  Windows, SysUtils;
 
const
  IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS = (ULONG('V') shl 16);
 
type
  DISK_EXTENT = record
    DiskNumber: DWORD;
    StartingOffset: LARGE_INTEGER;
    ExtentLength: LARGE_INTEGER;
  end;
 
  VOLUME_DISK_EXTENTS = record
    NumberOfDiskExtents: DWORD;
    Extents: array[0..1] of DISK_EXTENT;
  end;
 
function GetPhysicalDrive(Volume: Char): Integer;
var
  H: THandle;
  Vde: VOLUME_DISK_EXTENTS;
  BytesReturned: Cardinal;
begin
  Result:= -1;
  H:= CreateFile(PAnsiChar('\\.\' + Volume + ':'),0,0,nil, OPEN_EXISTING, 0, 0);
  if H <> INVALID_HANDLE_VALUE then
  begin
    if DeviceIoControl(H, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, nil, 0,
      @Vde, SizeOf(Vde), BytesReturned, nil) then
    begin
      Result:= Vde.Extents[0].DiskNumber;
    end;
    CloseHandle(h);
  end;
end;
 
// Por ejemplo
Writeln(GetPhysicalDrive('C'));

[seoane]

Otra función mas 

delphi

uses
  Windows, SysUtils;
 
const
  FILE_DEVICE_FILE_SYSTEM = 9;
  FSCTL_LOCK_VOLUME = (FILE_DEVICE_FILE_SYSTEM shl 16) or (6 shl 2);
  FSCTL_DISMOUNT_VOLUME = (FILE_DEVICE_FILE_SYSTEM shl 16) or (8 shl 2);
 
function LockAndDismount(H: THandle; Force: Boolean): Boolean; overload;
var
  Returned: Cardinal;
begin
  Result:= FALSE;
  if DeviceIoControl(H,FSCTL_LOCK_VOLUME, nil, 0, nil, 0, Returned, nil)
    or Force then
      Result:= DeviceIoControl(H,FSCTL_DISMOUNT_VOLUME, nil, 0, nil, 0,
        Returned, nil);
end;
 
function LockAndDismount(Volume: Char; Force: Boolean): THandle; overload;
begin
  Result:= FileOpen('\\.\' + Volume + ':',fmOpenRead or fmShareDenyWrite);
  if Result <> INVALID_HANDLE_VALUE then
  begin
    if not LockAndDismount(Result,Force) then
    begin
      CloseHandle(Result);
      Result:= INVALID_HANDLE_VALUE;
    end;
  end;
end;
 
// Por ejemplo
var
  H: THandle;
begin
  // Bloqueamos y desmontamos G
  H:= LockAndDismount('G',FALSE);
  if H <> INVALID_HANDLE_VALUE then
  begin
    Writeln('OK');
    // Desbloqueamos G
    CloseHandle(H);
  end else
  begin
    Writeln('ERROR');
  end;
end.

[escafandra]

Caramba seoane te has propuesto migrarlo todo, comenzando por las llamadas DeviceIoControl.

¿No crees que es mejor simplificar las constantes a sus valores finales?

delphi

FSCTL_DISMOUNT_VOLUME                = $00090020;
FSCTL_LOCK_VOLUME                    = $00090018;
IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS = $00560000;

Al fin y al cabo en WinIoCtl.h son constantes también.


Veo, como me dijiste en su momento, que retomas el tema con interés  .


Saludos.

[escafandra]

delphi

function LockAndDismount(H: THandle; Force: Boolean): Boolean;

Eres muy respetuoso, yo desmonto directamente no me ando con juegos a la hora de hacer o restaurar una copia de seguridad...     


Saludos.

[seoane]

Eres muy respetuoso, yo desmonto directamente no me ando con juegos a la hora de hacer o restaurar una copia de seguridad... 

... y el que quiera seguridad que se haga un seguro de vida 

[seoane]

Veo, como me dijiste en su momento, que retomas el tema con interés  .

Pues si y no 

Ahora lo que me anda rondando la cabeza son dos cosas: Android ( y aprender Java  ) y el Raspberry Pi que me compre en marzo y todavía no me ha llegado  ... precisamente pensando en este ultimo quería hacer una aplicación que me permita crear y restaurar imágenes de la tarjeta SD, y para eso me vienen fenomenal esas dos funciones.

... pero no descarto volver a lo de la fat mas adelante 

[escafandra]

¡¡AVISO!!

Por error he incluido una versión del archivo FileSystem.cpp que no es la definitiva y puede provocar errores el las imágenes y restauraciones de memorias de mas de 4GB. Lo malo es que el archivo definitivo lo borré por equivocación pensando que era el antiguo...   

Afortunadamente el cambio sólo afecta a una función así que lo he arreglado. No se si el binario compilaba la versión correcta o no, así que he retirado los archivos y los he vuelto a subir. 

Ahora son correctos, lo he probado con una memoria de 16GB.

Aconsejo que cuando hagáis una imagen la abráis con el programa y que la exploréis para ver que es correcta. En caso de error  aparecerán carpetas y archivos de nombres extrañísimos...

Tenéis los enlaces en el primer mensaje.



Saludos.

[escafandra]

He decidido pulir algunas cosas que no me terminaban de convencer y he modificado algo la API y la aplicación para:

- Incluir la lectura de particiones en los archivos de imagen de memorias FAT16 y FAT32 y visualización con el explorador de NaviFat.
- Volcado múltiple de archivos y carpetas de Memorias o Imágenes FAT16 y FAT32.
- Cambio múltiple de atributos de carpetas y/o archivos.
- Mejoras en la seguridad de copias de seguridad (imágenes) y restauración de las mismas.

He de advertir el hecho de que si se cambian los atributos de archivo a directorio, para el S.O. se tratará de una carpeta. Si creamos mas archivos o carpetas dentro se corrompe perdiendo la información del archivo original. El cambio de carpeta a archivo y posterior escritura conseguirá efectos similares. No se debe olvidar que el cambio de atributos de archivo a bajo nivel es sólo a efectos experimentales, sobre todo los dos casos comentados.

Como anécdota, yo ya le he sacado utilidad práctica al programa. Tengo un navegador GPS SUPRATECH TRITON que me corrompe la SD cuando se queda sin batería. La reinstalación de los programas en la SD me llevaba mas de una hora de copia de archivos. Con la realización de una imagen de la SD y su posterior restauración es cuestión de pocos minutos.

Espero que alguien mas que yo encuentre utilidad a esta aplicación.

Subo los fuentes y el binario en el primer mensaje de este tema.



Saludos.

[cadetill]

Cuando sea grande quiero ser como vosotros

[escafandra]

Pues he seguido experimentando el asunto de las copias de seguridad de memorias USB y he visto problemas para restaurar en unidades físicas en entorno Win 7, cosa que no ocurre con unidades lógicas en el mismo entorno. En Win XP ese problema no existe. En resumen Win 7 no deja escribir en cualquier sitio de una unidad física y así lo documenta Microsoft.

Para solventar este problema he decidido escribir un procedimiento que desmonta todas las unidades lógicas de una misma unidad física y también la misma unidad física es desmontada.



Este es el código para desmontar toda una unidad física que nos permite escribir libremente en ella en Vista y Win 7:

delphi

const
 FSCTL_DISMOUNT_VOLUME                = $00090020;
 FSCTL_LOCK_VOLUME                    = $00090018;
 IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS = $00560000;
 IOCTL_STORAGE_GET_DEVICE_NUMBER      = $002D1080;
 
 
// Encuentra el número de disco físico que corresponde a una letra de unidad
function GetPhysicalNumOfDrive(Volume: Char): integer;
var
  hFile: THandle;
  Vde: array [0..56] of BYTE;  //VOLUME_DISK_EXTENTS
  BytesReturned: Cardinal;
begin
  Result:= -1;
  hFile:= CreateFile(PAnsiChar('\\.\' + Volume + ':'), 0, 0, nil, OPEN_EXISTING, 0, 0);
  if hFile <> INVALID_HANDLE_VALUE then
  begin
    if DeviceIoControl(hFile, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, nil, 0, @Vde, SizeOf(Vde), BytesReturned, nil) then
      Result:= PBYTE(DWORD(@Vde)+8)^;
    CloseHandle(hFile);
  end;
end;
 
 
// Desmonta un disco físico desmontando tosas sus particiones y la misma unidad
procedure DisMountPhysicalDrive(hDevice: THANDLE; hVolumes: PDWORD; var MaxVolumes: DWORD);
var
  BytesReturned, LD, nVol: DWORD;
  Vol: array [0..6] of char;
  sdn: array [0..2] of DWORD; //STORAGE_DEVICE_NUMBER;
  GetLogicalDrives: function(): DWORD; stdcall;
begin
  lstrcpy(Vol, '\\.\A:');
  nVol:= 0;
  GetLogicalDrives:= GetProcAddress(GetModuleHandle('Kernel32.dll'), 'GetLogicalDrives');
 
  if(DeviceIoControl(hDevice, IOCTL_STORAGE_GET_DEVICE_NUMBER, nil, 0, @sdn, sizeof(sdn), BytesReturned, nil)) then
  begin
    // Si es una unidad física
    if (sdn[0] = 7) and (sdn[2] = 0) then
    begin
      LD:= GetLogicalDrives;
      repeat
        if (LD and 1) <> 0 then
        begin
          if GetPhysicalNumOfDrive(Vol[4]) = integer(sdn[1]) then
          begin
            inc(nVol);
            if hVolumes <> nil then
            begin
              hVolumes^:= CreateFile(Vol, GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH or FILE_FLAG_NO_BUFFERING, 0);
              DeviceIoControl(hVolumes^, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, BytesReturned, nil);
              DeviceIoControl(hVolumes^, FSCTL_DISMOUNT_VOLUME, nil, 0, nil, 0, BytesReturned, nil);
              inc(hVolumes);
            end;
          end;
        end;
        inc(Vol[4]); LD:= (LD shr 1);
      until (LD = 0) or ((hVolumes <> nil) and (nVol = MaxVolumes));
 
      // Desmonto la unidad física
      if hVolumes <> nil then
      begin
        DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, nil, 0, nil, 0, BytesReturned, nil);
        DeviceIoControl(hDevice, FSCTL_DISMOUNT_VOLUME, nil, 0, nil, 0, BytesReturned, nil);
      end;
    end;
  end;
  MaxVolumes:= nVol;
end;

Esta función precisa pasar un array de Handles con una dimensión igual o superior al número de unidades lógicas o particiones de la unidad de disco físico. Por necesidades propias, la unidad física la paso ya abierta pero es sencillo modificar el código para que el parámetro sea un nombre de unidad física "\\.\PhysicalDriveX".

Si el array de Handles es nulo, la función entiende que queremos saber el número necesario, lo calcula sin desmontar nada. Si devuelve 0 significa que hubo un error (no es una unidad física o el handle no era válido).

Un ejemplo de uso:

delphi

var
  hDevice: THANDLE;
  nVols: DWORD;
  hVols: array of THandle;
begin
  // Abrimos una unidad física.
  hDevice:= CreateFile('\\.\PhysicalDrive1', GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH or FILE_FLAG_NO_BUFFERING, 0);
 
  // Calculo el número de handles necesarios (particiones)
  DisMountPhysicalDrive(hDevice, nil, nVols);
  SetLength(hVols, nVols);
 
  // Desmontamos completamente la unidad
  DisMountPhysicalDrive(hDevice, @hVols[0], nVols);
  
 
  // Ahora podemos escribir y leer tranquilamente 
  // ................................................................
 
 
  // Una vez cerremos los Handles ¡¡Ya no está desmontada la unidad!!
 
  // Para que la unidad pueda ser usada de nuevo por el S.O. debemos liberarla
  repeat CloseHandle(hVols[nVols-1]); dec(nVols); until nVols = 0;
  CloseHandle(hDevice);
  SetLength(hVols, 0);
end;

La prueba de fuego la he hecho en Win 7 y con código similar en C/C++ recuperando una imagen de disco físico sobre un Pendrive. En delphi lo he probado pero sin escribir pero debe funcionar.

Un detalle curioso que me ha ocurrido en la versión delphi es que el AV me ha estado tocando las narices con la API "GetLogicalDrives" empeñándose en que estaba escribiendo un virus  , así que la he importado dinámicamente y a correr.

Bueno, espero que sea de utilidad. Seguro que a seoane le vale (o encuentra algún fallo pues ya digo que la prueba de fuego la hice en C/C++)



PD: No tratéis de desmontar la unidad del S.O. 

Saludos.

[escafandra]

Y como extracto del código anterior voy a escribir una función que puede ser útil para saber si un Handle de dispositivo representa una unidad de disco física o no:

delphi

const
 IOCTL_STORAGE_GET_DEVICE_NUMBER      = $002D1080;
 
 
// True si el dispositivo es un disco físico
function IsPhysicalDrive(hDevice: THANDLE): boolean;
var
  BytesReturned: DWORD;
  sdn: array [0..2] of DWORD; //STORAGE_DEVICE_NUMBER;
begin
  Result:= false;
  if(DeviceIoControl(hDevice, IOCTL_STORAGE_GET_DEVICE_NUMBER, nil, 0, @sdn, sizeof(sdn), BytesReturned, nil)) then
    Result:= (sdn[0] = 7) and (sdn[2] = 0);
end;

Ejemplo de uso:

delphi

var
  hDevice: THANDLE;
begin
  hDevice:= CreateFile('\\.\PhysicalDrive1', 0, 0, nil, OPEN_EXISTING, 0, 0);
  Result = IsPhysicalDrive(hDevice);
end;

Saludos.

[seoane]

Seguro que a seoane le vale (o encuentra algún fallo pues ya digo que la prueba de fuego la hice en C/C++)

Pues seguro que me da alguna idea. Ya había notado que había problemas para restaurar las copias de seguridad de los USB, así que este código me viene fenomenal.

PD: No tratéis de desmontar la unidad del S.O. 

Ya veo que tu ya probaste  ... yo probé a escribir sobre el MBR en XP y adivinen ... funciono   

[escafandra]

PD: No tratéis de desmontar la unidad del S.O. 

Ya veo que tu ya probaste  ... yo probé a escribir sobre el MBR en XP y adivinen ... funciono   

Pues si, lo he probado contra el disco "\\.\PhysicalDrive0"  donde está mi unidad C:\. No pude resistirme a la tentación de desmontarlo... Los programas abiertos dejaros de responder adecuadamente y Explorer.exe cayó de mala manera, pero no hubo desastres  .

La peor experiencia con este tipo de código fue probando una restauración de Pendrive. Tenía dos enchufados. Uno con el código recién compilado (estaba trabajando sobre el pendrive) y otro de pruebas. Había puesto en el programa mil y un avisos de advertencia contra incautos antes de proceder a la restauración. Yo, ansioso por probar el funcionamiento del recién compilado y flamante código, ejecuté velozmente y confundí el pendrive... 16Gb de código, y archivos fueron destruidos en pocos segundos, lo que tardé en desenchufarlo.... . Que desastre. Menos mal que tenía copia y perdí pocas cosas.


Saludos.

 

[egostar]

Ya ven porque los AV se quejan, ustedes si que le dan de patadas al API para que reaccione, que esperaban de los AV's

Saludos

[hectorlg2023]

Muy bueno el código, no se si todavía están activo, me gustaría que si se puede publiquen la unit integra, es que me da error en delphi7. Es para un proyecto de universidad y el código trae cosas que puedo utilizar. Saludos

[escafandra]

Muy bueno el código, no se si todavía están activo, me gustaría que si se puede publiquen la unit integra, es que me da error en delphi7. Es para un proyecto de universidad y el código trae cosas que puedo utilizar. Saludos

Bienvenido a delphiacces hectorlg2023

El código está escrito en Builder C++ en su versión BCB6 y puedes encontrarlo cpmpleto en el primer mensaje. En el hilo puedes ver algunos fragmentos traducidos a delphi, todos ellos compilan y funcionan, Es posible que tenga alguna modificación menor algo más moderna de ese código en mi HD, pero en C++. Nunca migré completamente ese código a delphi.


Saludos.