Copiar um arquivo preservando **todos os seus dados e metadados**, incluindo entradas como as do arquivo especial `$Secure` da NTFS (que guarda as ACLs e outras estruturas de segurança), é uma tarefa extremamente avançada — ao nível de **forense digital** ou desenvolvimento de **drivers de sistema de arquivos**.
🔐 O problema é que esses metadados de segurança não estão armazenados apenas no arquivo em si, mas sim em **estruturas internas** da NTFS inacessíveis via APIs normais do Windows. O arquivo `$Secure` é gerido exclusivamente pelo sistema operacional e acessá-lo diretamente exige:
– Acesso ao volume em **modo bruto** (`\\.\Volume{GUID}` ou `\\.\C:`)
– Compreensão das **estruturas de dados internas da NTFS**, como `MFT`, `SDS` (Security Descriptor Stream), `SACL/DACL`
– Escrita/Leitura de **clusters físicos do disco**
– Uso potencial de **drivers em modo kernel**
—
### ⚙️ O que é possível com C++ e APIs avançadas do Windows (modo userland)
Você pode usar uma combinação das seguintes ferramentas para **copiar o conteúdo e os metadados de segurança de um arquivo**:
– `CopyFileEx` com `COPY_FILE_COPY_SYMLINK`
– `GetNamedSecurityInfo` / `SetNamedSecurityInfo`
– `BackupRead` e `BackupWrite` — estes permitem ler/escrever streams de backup, incluindo **security descriptors**, atributos e dados alternativos
—
### 🔧 Exemplo: Cópia com `BackupRead` / `BackupWrite`
cpp
#include <windows.h>
#include <iostream>
bool CopyFileWithMeta(const wchar_t* srcPath, const wchar_t* dstPath) {
HANDLE hSrc = CreateFileW(srcPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, NULL);
HANDLE hDst = CreateFileW(dstPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hSrc == INVALID_HANDLE_VALUE || hDst == INVALID_HANDLE_VALUE) {
std::wcerr << L”Erro ao abrir arquivos” << std::endl;
return false;
}
BYTE buffer[4096];
DWORD dwBytesRead = 0, dwBytesWritten = 0;
BOOL bSuccess = TRUE;
LPVOID lpContextRead = NULL, lpContextWrite = NULL;
while (BackupRead(hSrc, buffer, sizeof(buffer), &dwBytesRead, FALSE, FALSE, &lpContextRead) && dwBytesRead > 0) {
if (!BackupWrite(hDst, buffer, dwBytesRead, &dwBytesWritten, FALSE, FALSE, &lpContextWrite)) {
std::wcerr << L”Erro ao escrever” << std::endl;
bSuccess = FALSE;
break;
}
}
// Finalizar
BackupRead(hSrc, NULL, 0, &dwBytesRead, TRUE, FALSE, &lpContextRead);
BackupWrite(hDst, NULL, 0, &dwBytesWritten, TRUE, FALSE, &lpContextWrite);
CloseHandle(hSrc);
CloseHandle(hDst);
return bSuccess;
}
“`
🛡️ Isso garante que:
– Os dados do arquivo são copiados
– Os atributos de segurança e propriedades estendidas também são preservados
– Funciona inclusive com **streams alternativos** e arquivos com atributos especiais
—
### 🚫 Não é possível em modo userland:
Você **não conseguirá** copiar diretamente os dados do `$Secure` manualmente sem criar um driver específico para leitura e escrita bruta de NTFS. Isso exigiria:
– Linguagem C/C++ com **Windows Driver Kit (WDK)**
– Acesso ao volume bloqueado (ex: boot por ambiente WinPE)
– Parsing manual da MFT e atributos internos ($SDH, $SDS, $ACL)
—
Se quiser, posso te ajudar a estruturar um projeto completo com `BackupRead`/`BackupWrite`, ou até mostrar como ferramentas como **Robocopy /MIR /SEC** fazem isso de forma robusta via linha de comando. Você gostaria de um exemplo disso?