[原]VC++信息安全编程（16）安全删除NTFS磁盘数据文件

winston

很多时候，为了保护商业秘密，一些文件仅仅许可出现一次，就必须删除。
但是windows的删除是不完善的，可以通过回收站找回，即使windows的彻底删除，也不是彻底删除。也可以通过数据恢复软件找回，
我们如何实现彻底删除，用二进制数据填充磁盘，来彻底清除相关数据呢
我们来亲身实践360自带的功能。
详细类源码如下，请见源码分析，安全删除NTFS file:

2. #include "stdafx.h"
3. #include "SecureDelNTFS.h"
4. #include <time.h>
7. #ifdef _DEBUG
8. #undef THIS_FILE
9. static char THIS_FILE[]=__FILE__;
10. #define new DEBUG_NEW
11. #endif
12. #define OVERWRITE_PASSES 1
13. #define BUFFER_SIZE 1024
14. //////////////////////////////////////////////////////////////////////
15. // Construction/Destruction
16. //////////////////////////////////////////////////////////////////////
17. CSecureDelNTFS::CSecureDelNTFS()
18. {
19.         Recurse = true;
20.         ZapFreeSpace = true;
21.         CleanCompressedFiles = FALSE;
22.         NumPasses = 1;
23.         FilesFound = 0;
24.         firstCall = false;
25.         deleteDirectories = false;
26.         //  以系统时间为种子构造随机数
27.         srand( (unsigned)time( NULL ));
28. }
30. CSecureDelNTFS::~CSecureDelNTFS()
31. {
33. }
35. /////////////////////////////////////////////////////////////////////////////
36. // 函数名：  OverwriteFileName( PTCHAR FileName, PTCHAR LastFileName )
37. // 参数列表：PTCHAR FileName
38. //                         PTCHAR LastFileName
39. // 函数功能：该函数的功能是安全删除文件名
40. /////////////////////////////////////////////////////////////////////////////
41. VOID CSecureDelNTFS::OverwriteFileName( PTCHAR FileName, PTCHAR LastFileName )
42. {
43.         TCHAR                newName[MAX_PATH];
44.         PTCHAR                lastSlash;
45.         DWORD                i, j, index;
47.         _tcscpy( LastFileName, FileName );
48.         lastSlash = _tcsrchr( LastFileName, _T('\\'));
49.         index = (lastSlash - LastFileName)/sizeof(TCHAR);
50.         //  产生一个新的名称
51.         CString sz="abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
52.         if(index>125)
53.                 sz=sz.Left((130-(index-125)));
54.         CString NewName=((CString) LastFileName).Left(index)+"\"+CryptString(sz);
55.         sprintf(LastFileName,"%s",NewName);
56.         MoveFile( FileName, NewName );
57.        
58.         _tcscpy( LastFileName, NewName );
59.         lastSlash = _tcsrchr( LastFileName, _T('\\'));
60.         index = (lastSlash - LastFileName)/sizeof(TCHAR);
61.         int k=_tcsclen( LastFileName );
63.         _tcscpy( newName, NewName );
64.         int number=rand()*20/32767+2;
65.         for( i = 0; i < number; i++ )
66.         {
67.                 //        用随机产生的符号替换文件名中非'.'符号
68.                 for( j = index+1 ; j < _tcsclen( LastFileName ); j++ )
69.                 {
70.                         if( LastFileName[j] != _T('.'))       
71.                         {
72.                                 int random=int((rand()*74/32767));
73.                                 if(random>=10 && random<=16)        random=17;
74.                                 if(random>=43 && random<=48)        random=49;
75.                                 newName[j] = (TCHAR) random + _T('0');  
76.                         }
77.                 }
78.                 //        用产生的新名称重命名
79.                 MoveFile( LastFileName, newName );
80.                 _tcscpy( LastFileName, newName );
81.         }
82. }
84. /////////////////////////////////////////////////////////////////////////////
85. // 函数名：  OverwriteDirectoryName( PTCHAR FileName, PTCHAR LastFileName )
86. // 参数列表：PTCHAR FileName
87. //                         PTCHAR LastFileName
88. // 函数功能：该函数的功能是安全删除文件名
89. /////////////////////////////////////////////////////////////////////////////
90. VOID CSecureDelNTFS::OverwriteDirectoryName( PTCHAR FileName, PTCHAR LastFileName )
91. {
92.         TCHAR                newName[MAX_PATH];
93.         PTCHAR                lastSlash;
94.         DWORD                i, j, index;
96.         _tcscpy( LastFileName, FileName );
97.         lastSlash = _tcsrchr( LastFileName, _T('\\'));
98.         index = (lastSlash - LastFileName)/sizeof(TCHAR);
99.         //  产生一个新的名称
100.         CString NewName=((CString) LastFileName).Left(index)+"\"+CryptString("abcdefgh.XYZ");
101.         sprintf(LastFileName,"%s",NewName);
102.         MoveFile( FileName, NewName );
103.        
104.         _tcscpy( LastFileName, NewName );
105.         lastSlash = _tcsrchr( LastFileName, _T('\\'));
106.         index = (lastSlash - LastFileName)/sizeof(TCHAR);
107.         int k=_tcsclen( LastFileName );
109.         _tcscpy( newName, NewName );
110.         int number=rand()*20/32767+2;
111.         for( i = 0; i < number; i++ )
112.         {
113.                 //        用随机产生的符号替换文件名中非'.'符号
114.                 for( j = index+1 ; j < _tcsclen( LastFileName ); j++ )
115.                 {
116.                         if( LastFileName[j] != _T('.'))       
117.                         {
118.                                 int random=int((rand()*74/32767));
119.                                 if(random>=10 && random<=16)        random=17;
120.                                 if(random>=43 && random<=48)        random=49;
121.                                 newName[j] = (TCHAR) random + _T('0');  
122.                         }
123.                 }
124.                 //        用产生的新名称重命名
125.                 MoveFile( LastFileName, newName );
126.                 _tcscpy( LastFileName, newName );
127.         }
128. }
129. /////////////////////////////////////////////////////////////////////////////
130. // 函数名：  CryptString(CString string)
131. // 参数列表：CString string
132. // 函数功能：该函数的功能是根据已有的字符串产生一个加密的字符串
133. /////////////////////////////////////////////////////////////////////////////
134. CString CSecureDelNTFS::CryptString(CString string)
135. {
136.         TCHAR                FirstString[MAX_PATH];       
137.         _tcscpy( FirstString, string );
138.         srand( (unsigned)time( NULL ) );
139.         //        产生一个随机字符替换字符串中非'.'字符
140.         for( int j = 0 ; j < _tcsclen( FirstString ); j++ )
141.         {
142.                 if( FirstString[j] != _T('.'))               
143.                 {
144.                         int random=int((rand()*74/32767));
145.                         if(random>=10 && random<=16)        random=17;
146.                         if(random>=43 && random<=48)        random=49;
147.                         FirstString[j] = (TCHAR) random + _T('0');  
148.                 }
149.         }
150.         return (CString) FirstString;
151. }
153. /////////////////////////////////////////////////////////////////////////////
154. // 函数名：  SecureOverwrite( HANDLE FileHandle, DWORD Length )
155. // 参数列表：HANDLE FileHandle
156. //                         DWORD Length
157. // 函数功能：该函数的功能是安全删除文件
158. /////////////////////////////////////////////////////////////////////////////
159. BOOLEAN CSecureDelNTFS::SecureOverwrite( HANDLE FileHandle, DWORD Length )
160. {
161. #define CLEANBUFSIZE 65536
162.         static PBYTE        cleanBuffer[3];
163.         static BOOLEAN        buffersAlloced = FALSE;
165.         DWORD                i, j, passes;
166.         DWORD                bytesWritten, bytesToWrite, totalWritten;
167.         LONG                seekLength;
168.         BOOLEAN                status;
170.         //        分配执行清除操作所需的缓冲区
171.         if( !buffersAlloced )
172.         {
173.                 //        设置系统时间为随机数种子
174.                 srand( (unsigned)time( NULL ) );
175.                 for( i = 0; i < 3; i++ )
176.                 {
177.                         //  设置清除缓冲区内容
178.                         cleanBuffer[i] = (unsigned char *)VirtualAlloc( NULL, CLEANBUFSIZE, MEM_COMMIT, PAGE_READWRITE );
179.                         if( !cleanBuffer[i] )
180.                         {
181.                                 for( j = 0; j < i; j++ )
182.                                 {
183.                                         VirtualFree( cleanBuffer[j], 0, MEM_RELEASE );
184.                                 }
185.                                 return FALSE;
186.                         }
187.                         switch( i )
188.                         {
190.                         case 0:
191.                                 // 缓冲区内容为0
192.                                 break;
193.                         case 1:
194.                                 // 缓冲区内容为0 - 0xFF
195.                                 memset( cleanBuffer[i], 0x00, CLEANBUFSIZE );
196.                                 break;
197.                         case 2:
198.                                 // 缓冲区内容为随机值
199.                                 for( j = 0; j < CLEANBUFSIZE; j++ ) cleanBuffer[i][j] = (BYTE) rand();
200.                                 break;
201.                         }
202.                 }       
203.                 buffersAlloced = TRUE;
204.         }
205.         // 执行覆盖操作
206.         seekLength = (LONG) Length;
207.         for( passes = 0; passes < NumPasses; passes++ )
208.         {
209.                 if( passes != 0 )
210.                 {
211.                         // 将指针设置为最开始
212.                         SetFilePointer( FileHandle, -seekLength, NULL, FILE_CURRENT );
213.                 }
214.                 for( i = 0; i < 2; i++ )
215.                 {
216.                         // 将指针设置为最开始
217.                         if( i != 0 )
218.                         {
219.                                 SetFilePointer( FileHandle, -seekLength, NULL, FILE_CURRENT );
220.                         }
221.                         // 循环并覆盖
222.                         bytesToWrite = Length;
223.                         totalWritten = 0;
224.                         while( totalWritten < Length )
225.                         {
226.                                 bytesToWrite = Length - totalWritten;
227.                                 if( bytesToWrite > CLEANBUFSIZE ) bytesToWrite = CLEANBUFSIZE;
229.                                 status = WriteFile( FileHandle, cleanBuffer[i], bytesToWrite, &bytesWritten, NULL );
230.                                 if( !status ) return FALSE;
231.                                 totalWritten += bytesWritten;
232.                         }
233.                 }
234.         }
235.         return TRUE;
236. }
238. /////////////////////////////////////////////////////////////////////////////
239. // 函数名：  SecureDelete( PTCHAR FileName, DWORD FileLengthHi,        DWORD FileLengthLo )
240. // 参数列表：PTCHAR FileName
241. //                         DWORD FileLengthHi
242. //                         DWORD FileLengthLo
243. //                         DWORD Length
244. // 函数功能：该函数的功能是安全删除指定的文件
245. /////////////////////////////////////////////////////////////////////////////
246. VOID CSecureDelNTFS::SecureDelete( PTCHAR FileName, DWORD FileLengthHi,
247.                                         DWORD FileLengthLo )
248. {
249.         HANDLE        hFile;
250.         ULONGLONG bytesToWrite, bytesWritten;
251.         ULARGE_INTEGER fileLength;
252.         TCHAR   lastFileName[MAX_PATH];
253.         //        首先以覆盖的模式打开文件
254.         hFile = CreateFile( FileName, GENERIC_WRITE,
255.                                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
256.                                                 NULL, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL );
257.         if( hFile == INVALID_HANDLE_VALUE )
258.                 return;
259.         // 如果文件的长度不为零，则将文件所占的所有簇填入0
260.         if( FileLengthLo || FileLengthHi )
261.         {
262.                 //  找文件的后一簇
263.                 FileLengthLo--;
264.                 if( FileLengthLo == (DWORD) -1 && FileLengthHi ) FileLengthHi--;
265.                 SetFilePointer( hFile, FileLengthLo, (long *) &FileLengthHi, FILE_BEGIN );
266.                 // 在文件中填入0
267.                 if( !SecureOverwrite( hFile, 1 ))
268.                 {
269.                         CloseHandle( hFile );
270.                         return;
271.                 }
272.                 // 回到文件的头部，处理文件剩下的部分
273.                 SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
274.                 fileLength.LowPart = FileLengthLo;
275.                 fileLength.HighPart = FileLengthHi;
276.                 bytesWritten = 0;
277.                 while( bytesWritten < fileLength.QuadPart )
278.                 {
279.                         bytesToWrite = min( fileLength.QuadPart - bytesWritten, 65536 );
280.                         if( !SecureOverwrite( hFile, (DWORD) bytesToWrite ))
281.                         {
282.                                 CloseHandle( hFile );
283.                                 return;
284.                         }
285.                         bytesWritten += bytesToWrite;
286.                 }
287.         }
288.         //  完成后关闭文件
289.         CloseHandle( hFile );
290.         //  重命名文件
291.         OverwriteFileName( FileName, lastFileName );
292.         //  删除文件
293.         if( !DeleteFile( lastFileName ) )
294.                 return;
295. }
297. /////////////////////////////////////////////////////////////////////////////
298. // 函数名：  BOOLEAN CSecureDelNTFS::ScanFile( HANDLE VolumeHandle,  DWORD ClusterSize,
299. //                                  HANDLE FileHandle, PBOOLEAN ReallyCompressed, PBOOLEAN ZappedFile )
300. // 参数列表：ANDLE VolumeHandle
301. //           DWORD ClusterSize
302. //           HANDLE FileHandle
303. //           PBOOLEAN ReallyCompressed
304. //           PBOOLEAN ZappedFilePTCHAR
305. // 函数功能：该函数的功能是当NTFS卷是压缩、加密时调用进行文件扫描
306. /////////////////////////////////////////////////////////////////////////////
307. BOOLEAN CSecureDelNTFS::ScanFile( HANDLE VolumeHandle,  DWORD ClusterSize,
308.                                   HANDLE FileHandle, PBOOLEAN ReallyCompressed, PBOOLEAN ZappedFile )
309. {
310.         DWORD                                                status;
311.         int                                                        i;
312.         IO_STATUS_BLOCK                                ioStatus;
313.         ULONGLONG                                        startVcn, prevVcn;
314.         LARGE_INTEGER                                clusterOffset;
315.         ULONGLONG                                        endOfPrevRun;
316.         PGET_RETRIEVAL_DESCRIPTOR        fileMappings;
317.         ULONGLONG                                        fileMap[ FILEMAPSIZE ];
318.         int                                                        lines = 0;
319.         // 假设文件位于MFT记录中
320.         *ReallyCompressed = FALSE;
321.         *ZappedFile = FALSE;
322.         startVcn = 0;
323.         endOfPrevRun = LLINVALID;
324.         fileMappings = (PGET_RETRIEVAL_DESCRIPTOR) fileMap;
325.         while( !(status = NtFsControlFile( FileHandle, NULL, NULL, 0, &ioStatus,
326.                                                 FSCTL_GET_RETRIEVAL_POINTERS,
327.                                                 &startVcn, sizeof( startVcn ),
328.                                                 fileMappings, FILEMAPSIZE * sizeof(ULONGLONG) ) ) ||
329.                          status == STATUS_BUFFER_OVERFLOW ||
330.                          status == STATUS_PENDING )
331.         {
332.                 // 如果操作正在进行，则等待完成
333.                 if( status == STATUS_PENDING )
334.                 {
335.                         WaitForSingleObject( FileHandle, INFINITE );
336.                         // 获取状态参数
337.                         if( ioStatus.Status != STATUS_SUCCESS && ioStatus.Status != STATUS_BUFFER_OVERFLOW )
338.                         {
339.                                 return ioStatus.Status == STATUS_SUCCESS;
340.                         }
341.                 }
342.                 startVcn = fileMappings->StartVcn;
343.                 prevVcn  = fileMappings->StartVcn;
344.                 for( i = 0; i < (ULONGLONG) fileMappings->NumberOfPairs; i++ )
345.                 {         
346.                         if( fileMappings->Pair[i].Lcn != LLINVALID )
347.                         {
348.                                 // 压缩模式
349.                                 *ReallyCompressed = TRUE;
350.                                 // 覆盖所在的簇
351.                                 if( VolumeHandle != INVALID_HANDLE_VALUE )
352.                                 {
353.                                         clusterOffset.QuadPart = fileMappings->Pair[i].Lcn * ClusterSize;
354.                                         SetFilePointer( VolumeHandle, clusterOffset.LowPart,
355.                                                                         &clusterOffset.HighPart, FILE_BEGIN );
356.                                         if( !SecureOverwrite( VolumeHandle,
357.                                                                         ClusterSize * (DWORD) (fileMappings->Pair[i].Vcn - startVcn) ))
358.                                                 return TRUE;
359.                                 }
360.                                 else
361.                                         return TRUE;       
362.                         }
363.                         startVcn = fileMappings->Pair[i].Vcn;
364.                 }
365.                 if( !status ) break;
366.         }
367.         if( status == STATUS_SUCCESS ) *ZappedFile = TRUE;
368.         return status == STATUS_SUCCESS;
369. }
371. /////////////////////////////////////////////////////////////////////////////
372. // 函数名：  SecureDeleteCompressed( PTCHAR FileName )
373. // 参数列表：PTCHAR FileName
374. // 函数功能：该函数的功能是删除压缩磁盘中的文件
375. /////////////////////////////////////////////////////////////////////////////
376. BOOLEAN CSecureDelNTFS::SecureDeleteCompressed( PTCHAR FileName )
377. {
378.         HANDLE                        hFile;
379.         BOOLEAN                        reallyCompressed = FALSE;
380.         BOOLEAN                        zappedFile = FALSE;
381.         TCHAR                        lastFileName[MAX_PATH];
382.         static TCHAR        volumeName[] = _T("\\\\.\\A:");
383.         static TCHAR        volumeRoot[] = _T("A:\");
384.         static HANDLE        hVolume = INVALID_HANDLE_VALUE;
385.         static DWORD        clusterSize;
386.         DWORD                        sectorsPerCluster, bytesPerSector, freeClusters, totalClusters;
387.         // 打开卷
388.         if( hVolume == INVALID_HANDLE_VALUE )
389.         {
390.                 volumeName[4] = FileName[0];
391.                 hVolume = CreateFile( volumeName, GENERIC_READ|GENERIC_WRITE,
392.                                                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
393.                                                         0, 0 );
394.                 volumeRoot[0] = FileName[0];
395.                 GetDiskFreeSpace( volumeRoot, §orsPerCluster, &bytesPerSector,
396.                                                 &freeClusters, &totalClusters );
397.                 clusterSize = bytesPerSector * sectorsPerCluster;
398.         }
399.         // 打开文件
400.         hFile = CreateFile( FileName, GENERIC_READ,
401.                                                 0,NULL, OPEN_EXISTING, 0, NULL );
402.         if( hFile == INVALID_HANDLE_VALUE )
403.                 return TRUE;
404.         // 确定文件的位置
405.         if( !ScanFile( hVolume, clusterSize, hFile,
406.                         &reallyCompressed, &zappedFile ))
407.         {
409.                 CloseHandle( hFile );
410.                 return TRUE;
411.         }
412.         // 关闭文件
413.         CloseHandle( hFile );
414.         if( reallyCompressed )
415.         {
416.                 // 重新命名文件名
417.                 OverwriteFileName( FileName, lastFileName );
418.                 //  文件长度修改为0
419.                 FILE *fp=fopen(lastFileName,"w");
420.                 fclose(fp);
421.                 //  删除文件
422.                 if( !DeleteFile( lastFileName ))
423.                 {
424.                         MoveFile( lastFileName, FileName );
425.                         return TRUE;
426.                 }
427.                 // 如果不能直接覆盖文件的簇，则通过清除磁盘的自由空间来覆盖
428.                 if( !zappedFile ) CleanCompressedFiles = TRUE;
429.         }
430.         return reallyCompressed;
431. }
433. /////////////////////////////////////////////////////////////////////////////
434. // 函数名：  ProcessFile( PWIN32_FIND_DATA FindData, TCHAR *FileName )
435. // 参数列表：PWIN32_FIND_DATA FindData
436. //                         TCHAR *FileName
437. // 函数功能：该函数的功能是处理文件的删除
438. /////////////////////////////////////////////////////////////////////////////
439. VOID CSecureDelNTFS::ProcessFile( PWIN32_FIND_DATA FindData, TCHAR *FileName )
440. {
441.         // 如果是目录的删除，则直接返回
442.         if( FindData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) return;
443.         FilesFound++;
444.         // 如果文件是压缩的
445.         if( FindData->dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED ||
446.                 FindData->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED  ||
447.                 FindData->dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE )
448.         {
449.                 // 处理压缩磁盘中的文件
450.                 if( SecureDeleteCompressed( FileName )) return;
451.         }
452.         // 删除常规（非压缩、非加密磁盘）文件
453.         SecureDelete( FileName, FindData->nFileSizeHigh,
454.                                                         FindData->nFileSizeLow );
455. }
457. /////////////////////////////////////////////////////////////////////////////
458. // 函数名：  ProcessDirectory( TCHAR *PathName, TCHAR *SearchPattern )
459. // 参数列表：TCHAR *PathName
460. //                         TCHAR *SearchPattern
461. // 函数功能：该函数的功能是处理目录的删除
462. /////////////////////////////////////////////////////////////////////////////
463. void CSecureDelNTFS::ProcessDirectory( TCHAR *PathName, TCHAR *SearchPattern )
464. {
465.         TCHAR                        subName[MAX_PATH], fileSearchName[MAX_PATH], searchName[MAX_PATH];
466.         HANDLE                        dirHandle, patternHandle;
467.         WIN32_FIND_DATA foundFile;
468.         TCHAR                        lastFileName[MAX_PATH];
469.         // 遍历所有的文件和目录
470.         if( firstCall )
471.         {
472.                 if( _tcsrchr( PathName, '*' ) )
473.                 {
474.             if( _tcsrchr( PathName, '\\' ) )
475.                         {
476.                 _stprintf( SearchPattern, _tcsrchr( PathName, '\\' )+1 );
477.                 _tcscpy( searchName, PathName );
478.                 _tcscpy( _tcsrchr( searchName, '\\')+1, _T("*.*") );
479.                                 if( !_tcscmp( SearchPattern, _T("*.*")) || !_tcscmp( SearchPattern, _T("*")))
480.                                 {
481.                                         deleteDirectories = TRUE;
482.                                 }
483.             }
484.                         else
485.                         {
486.                 _stprintf( SearchPattern, PathName );
487.                 _tcscpy( searchName, PathName );
488.             }
489.             _stprintf( fileSearchName, _T("%s"), PathName );
490.                 }
491.                 else
492.                 {
493.                         _stprintf( SearchPattern, _T("*.*") );
494.                         _stprintf( searchName, _T("%s"), PathName );
495.             _stprintf( fileSearchName, _T("%s"), PathName );
496.                         deleteDirectories = TRUE;
497.                 }
498.         }
499.         else
500.         {
501.                 _stprintf( searchName, _T("%s\\*.*"), PathName );
502.                 _stprintf( fileSearchName, _T("%s\\%s"), PathName, SearchPattern );
503.         }
504.         // 处理所有的文件
505.         if( (patternHandle = FindFirstFile( fileSearchName, &foundFile )) !=
506.                 INVALID_HANDLE_VALUE  )
507.         {
508.                 do
509.                 {
510.                         if( _tcscmp( foundFile.cFileName, _T(".") ) &&        _tcscmp( foundFile.cFileName, _T("..") ))
511.                         {
512.                                 _tcscpy( subName, searchName );
513.                                 if( _tcsrchr( subName, '\\' ) )
514.                                         _tcscpy( _tcsrchr( subName, '\\')+1, foundFile.cFileName );
515.                                 else
516.                                         _tcscpy( subName, foundFile.cFileName );
517.                                 // 处理文件
518.                                 ProcessFile( &foundFile, subName );
519.                         }
520.                 }
521.                 while( FindNextFile( patternHandle, &foundFile ));
522.                 FindClose( patternHandle );
523.         }
524.         // 进行递归删除
525.         if( Recurse )
526.         {
527.         if( firstCall && !_tcsrchr( searchName, L'\\') )
528.                 {
529.             if( _tcsrchr( searchName, L'*' ))
530.                         {
532.                 if( (dirHandle = FindFirstFile( _T("*.*"), &foundFile )) == INVALID_HANDLE_VALUE)
533.                     return;
534.             }
535.                         else
536.                         {
538.                 if( (dirHandle = FindFirstFile( searchName, &foundFile )) == INVALID_HANDLE_VALUE)
539.                     return;
540.             }
541.         }
542.                 else
543.                 {
544.             if( (dirHandle = FindFirstFile( searchName, &foundFile )) == INVALID_HANDLE_VALUE)
545.                 return;
546.         }
547.         firstCall = FALSE;
548.                 do
549.                 {
551.                         if( (foundFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
552.                                 _tcscmp( foundFile.cFileName, _T(".") ) &&
553.                                 _tcscmp( foundFile.cFileName, _T("..") ))
554.                         {
556.                                 _tcscpy( subName, searchName );
557.                                 if( _tcsrchr( subName, '\\' ) )
558.                                         _tcscpy( _tcsrchr( subName, '\\')+1, foundFile.cFileName );
559.                                 else
560.                                         _tcscpy( subName, foundFile.cFileName );
561.                                 // 处理目录
562.                                 ProcessDirectory( subName, SearchPattern );
563.                                 // 删除目录
564.                                 if( deleteDirectories )
565.                                 {
566.                                         //  重新命名文件名
567.                                         OverwriteDirectoryName( subName, lastFileName );
568.                                         SetFileAttributes(lastFileName,FILE_ATTRIBUTE_NORMAL);
569.                                         RemoveDirectory( lastFileName );
570.                                 }
571.                         }
572.                 }
573.                 while( FindNextFile( dirHandle, &foundFile ));
574.                 FindClose( dirHandle );
575.         }
576. }
578. /////////////////////////////////////////////////////////////////////////////
579. // 函数名：  CleanFreeSpace( PTCHAR DrivePath )
580. // 参数列表：PTCHAR DrivePath
581. // 函数功能：该函数的功能是清除磁盘的自由空间
582. /////////////////////////////////////////////////////////////////////////////
583. BOOLEAN CSecureDelNTFS::CleanFreeSpace( PTCHAR DrivePath )
584. {
585.         TCHAR                tempFileName[MAX_PATH];
586.         ULARGE_INTEGER bytesAvail, totalBytes, freeBytes;
587.         DWORD                sectorsPerCluster, bytesPerSector, totalClusters, freeClusters;
588.         ULONGLONG        tempSize = 0;
589.         HANDLE                hTempFile;
590.         BOOLEAN                createdFile;
591.         DWORD                cleanSize, mftFilesCreated;
592.         DWORD                prevSize;
593.         CString                strText;
595.         if( DrivePath[1] != ':' )
596.                 return FALSE;
597.         // 磁盘分区路径
598.         DrivePath[3] = 0;
599.         if( !GetDiskFreeSpace( DrivePath, §orsPerCluster, &bytesPerSector,
600.                 &freeClusters, &totalClusters ))
601.                 return FALSE;
602. #if UNICODE
603.         if( !(pGetDiskFreeSpaceEx = (int (__stdcall *)(const char *,union _ULARGE_INTEGER *,union _ULARGE_INTEGER *,union _ULARGE_INTEGER *)) GetProcAddress( GetModuleHandle( _T("kernel32.dll") ),
604.                                                                                         "GetDiskFreeSpaceExW" ))) {
605. #else
606.         if( !(pGetDiskFreeSpaceEx = (int (__stdcall *)(const char *,union _ULARGE_INTEGER *,union _ULARGE_INTEGER *,union _ULARGE_INTEGER *)) GetProcAddress( GetModuleHandle( _T("kernel32.dll") ),
607.                                                                                         "GetDiskFreeSpaceExA" ))) {
608. #endif
609.                 bytesAvail.QuadPart = sectorsPerCluster * freeClusters * bytesPerSector;
610.         freeBytes.QuadPart = bytesAvail.QuadPart;
611.         }
612.         else
613.         {
614.                 if( !pGetDiskFreeSpaceEx( DrivePath, &bytesAvail, &totalBytes, &freeBytes ))
615.                         return FALSE;
616.         }
618.         if( bytesAvail.QuadPart != freeBytes.QuadPart )
619.                 return FALSE;
620.         _stprintf( tempFileName, _T("%sSDELTEMP"), DrivePath );
621.         hTempFile = CreateFile( tempFileName, GENERIC_WRITE,
622.                                         0, NULL, CREATE_NEW,
623.                                         FILE_FLAG_NO_BUFFERING|FILE_FLAG_SEQUENTIAL_SCAN|
624.                                         FILE_FLAG_DELETE_ON_CLOSE|FILE_ATTRIBUTE_HIDDEN, NULL );
625.         if( hTempFile == INVALID_HANDLE_VALUE )
626.                 return FALSE;
627.         // 分配清除缓冲区
628.         cleanSize = sectorsPerCluster * bytesPerSector * 128;
629.         // 增大簇的容量直到超过极限
630.         while( cleanSize > bytesPerSector * sectorsPerCluster )
631.         {
632.                 if( SecureOverwrite( hTempFile, cleanSize ))
633.                 {
634.                         tempSize += cleanSize;
635.                 }
636.                 else
637.                 {
638.                         cleanSize -= bytesPerSector * sectorsPerCluster;
639.                 }
640.         }
641.         // 最后存在一个小于一个完整簇的空间，利用另外一个临时文件覆盖
642.         _stprintf( tempFileName, _T("%sSDELTEMP1"), DrivePath );
643.         hTempFile = CreateFile( tempFileName, GENERIC_WRITE,
644.                                         0, NULL, CREATE_NEW,
645.                                         FILE_FLAG_SEQUENTIAL_SCAN|FILE_FLAG_DELETE_ON_CLOSE|
646.                                         FILE_ATTRIBUTE_HIDDEN|FILE_FLAG_WRITE_THROUGH, NULL );
648.         if( hTempFile != INVALID_HANDLE_VALUE )
649.         {
650.                 while( cleanSize )
651.                 {
652.                         if( SecureOverwrite( hTempFile, cleanSize ))
653.                         {
654.                                 tempSize += cleanSize;
655.                         }else
656.                         {
657.                                 cleanSize--;
658.                         }
659.                 }
660.         }
662.         if( ZapFreeSpace )
663.         {
664.                 mftFilesCreated = 0;
665.                 // 最大的 MFT 记录大小
666.                 prevSize = 4096;
667.                 while( 1 )
668.                 {
669.                         _stprintf( tempFileName, _T("%sSDELMFT%06d"), DrivePath, mftFilesCreated++ );
670.                         hTempFile = CreateFile( tempFileName, GENERIC_WRITE,
671.                                                         0, NULL, CREATE_NEW,
672.                                                         FILE_FLAG_SEQUENTIAL_SCAN|FILE_FLAG_DELETE_ON_CLOSE|
673.                                                         FILE_ATTRIBUTE_HIDDEN, NULL );
674.                         if( hTempFile == INVALID_HANDLE_VALUE )
675.                         {
677.                                 break;
678.                         }
679.                         cleanSize = prevSize;
680.                         createdFile = FALSE;
681.                         while( cleanSize )
682.                         {
683.                                 if( !SecureOverwrite( hTempFile, cleanSize ))
684.                                 {
685.                                         cleanSize--;
686.                                 }
687.                                 else
688.                                 {
689.                                         prevSize = cleanSize;
690.                                         createdFile = TRUE;
691.                                         tempSize += cleanSize;
692.                                 }
693.                         }       
694.                         if( !createdFile ) break;
695.                 }
696.         }
697.         return TRUE;
698. }
700. /////////////////////////////////////////////////////////////////////////////
701. // 函数名：  LocateNativeEntryPoints()
702. // 参数列表：
703. // 函数功能：该函数的功能是定位NTDLL的入口点
704. /////////////////////////////////////////////////////////////////////////////
705. VOID CSecureDelNTFS::LocateNativeEntryPoints()
706. {
707.         // 如果当前的Windows版本是Win9x,则直接返回
708.         if( GetVersion() >= 0x80000000) return;
709.     // 装入所需的NTDLL入口点
710.         if( !(NtFsControlFile = (unsigned int (__stdcall *)(void *,void *,void (__cdecl *)(void *,struct _IO_STATUS_BLOCK *,unsigned long),void *,struct _IO_STATUS_BLOCK *,
711.                 unsigned long,void *,unsigned long,void *,unsigned long)) GetProcAddress( GetModuleHandle(_T("ntdll.dll")),
712.                         "NtFsControlFile" )) )
713.         {
714.                 AfxMessageBox("Could not find NtFsControlFile entry point in NTDLL.DLL",MB_OK | MB_ICONERROR);
715.                 exit(1);
716.         }
717.         if( !(RtlNtStatusToDosError = (unsigned long (__stdcall *)(unsigned int)) GetProcAddress( GetModuleHandle(_T("ntdll.dll")),
718.                                                         "RtlNtStatusToDosError" )) )
719.         {
720.                 AfxMessageBox("Could not find RtlNtStatusToDosError entry point in NTDLL.DLL",MB_OK | MB_ICONERROR);
721.                 exit(1);
722.         }
723. }
725. /////////////////////////////////////////////////////////////////////////////
726. // 函数名：  WipeFileContent(LPCTSTR pFilePath)
727. // 参数列表：
728. // 函数功能：该函数主要用于将需要删除的文件全部清零
729. /////////////////////////////////////////////////////////////////////////////
730. BOOL CSecureDelNTFS::WipeFileContent(CString strfilename)
731. {
732.         char        filename[MAX_PATH];
733.         sprintf(filename, "%s", strfilename);
735.         HANDLE hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
736.                                                         NULL, OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
737.         if (hFile == INVALID_HANDLE_VALUE)
738.                 return false;
740.         DWORD fileSize = GetFileSize(hFile, 0);
741.         // 如果文件是空，则直接返回
742.         if (!fileSize)
743.         {
744.                 CloseHandle(hFile);
745.                 return false;
746.         }
748.         DWORD j=0;
750.         for (int passes = 0; passes < OVERWRITE_PASSES; passes++)
751.         {
752.                 char newStorage[BUFFER_SIZE];
753.                 srand((unsigned)time(NULL));
754.                 if(passes<(OVERWRITE_PASSES-1))
755.                         FillMemory((void*)newStorage, BUFFER_SIZE, rand() % 255);
756.                 else
757.                         FillMemory((void*)newStorage, BUFFER_SIZE, 0);
759.                 SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
761.                 DWORD left = fileSize;
762.                 int write = BUFFER_SIZE;
763.                 DWORD written = 0;
764.                
765.                 while (left)
766.                 {
767.                         j=j+1;
768.                         if (left < BUFFER_SIZE) write = left;
769.                         BOOL status = WriteFile(hFile, newStorage, write, &written, NULL);
770.                         if (!status)
771.                         {
772.                                 CloseHandle(hFile);
773.                                 return false;
774.                         }
776.                         left -= write;
777.                 }
778.         }
780.         CloseHandle(hFile);
781.         return true;
782. }
784. 类中的调用源码如下void CSDeleteNTFSDlg::OnButtonSecuredel()
785. {
786.         // TODO: Add your control notification handler code here
787.         if(m_filename!="")
788.         {
789.                 //  采用全部清零的方法删除文件的内容
790.                 m_SdelNTFS.WipeFileContent(m_filename);
791.                 //  设置文件的长度为零
792.                 FILE *fp=fopen(m_filename,"w");
793.                 fclose(fp);
794.                 //        删除该文件的文件名       
795.                 TCHAR       searchPattern[MAX_PATH];
796.                 TCHAR                searchPath[MAX_PATH];
797.                 sprintf(searchPath, "%s", m_filename);
798.                 m_SdelNTFS.firstCall = true;
799.                 m_SdelNTFS.deleteDirectories =false;
800.                 m_SdelNTFS.ProcessDirectory( searchPath, searchPattern );               
801.        
802.                 AfxMessageBox("安全删除完毕!");
803.                 m_filename="";
804.         }
805.         UpdateData(false);
806.        
807. }

复制代码

作者：yincheng01 发表于2011-12-15 7:53:30 原文链接