开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
SDEL.C
资源名称：sdelsrc.zip　[点击查看]
上传用户：lw2005ff
上传日期：2007-01-07
资源大小：35k
文件大小：31k
源码类别：

系统编程

开发平台：

Visual C++

SDEL.C：源码内容
  1. //--------------------------------------------------------------------
  2. //
  3. // SDelete - Secure Delete
  4. // Copyright (C) 1999 Mark Russinovich
  5. // Systems Internals - http://www.sysinternals.com
  6. //
  7. // This program implements a secure delete function for 
  8. // Windows NT/2K. It even works on WinNT compressed, encrypted 
  9. // and sparse files.
  10. //
  11. // This program is copyrighted. You may not use the source, or 
  12. // derived version of the source, in a secure delete application.
  13. // You may use the source or techniques herein in applications
  14. // with a purpose other than secure delete.
  15. //
  16. //--------------------------------------------------------------------
  17. #include <windows.h>
  18. #include <tchar.h>
  19. #include <stdio.h>
  20. #include <time.h>
  21. #include "defrag.h"
  24. //--------------------------------------------------------------------
  25. //                         D E F I N E S
  26. //--------------------------------------------------------------------
  28. //
  29. // Invalid longlong number
  30. //
  31. #define LLINVALID ((ULONGLONG) -1)
  33. //
  34. // Size of the buffer we read file mapping information into.
  35. // The buffer is big enough to hold the 16 bytes that 
  36. // come back at the head of the buffer (the number of entries 
  37. // and the starting virtual cluster), as well as 512 pairs
  38. // of [virtual cluster, logical cluster] pairs.
  39. //
  40. #define FILEMAPSIZE (16384+2)
  43. //--------------------------------------------------------------------
  44. //                        G L O B A L S
  45. //--------------------------------------------------------------------
  47. //
  48. // Global variables
  49. //
  50. BOOLEAN Silent = FALSE;
  51. BOOLEAN Recurse = FALSE;
  52. BOOLEAN ZapFreeSpace = FALSE;
  53. BOOLEAN CleanCompressedFiles = FALSE;
  54. DWORD NumPasses = 1;
  55. DWORD FilesFound = 0;
  58. BOOL (__stdcall *pGetDiskFreeSpaceEx)(
  59.   LPCTSTR lpDirectoryName,                 // pointer to the directory name
  60.   PULARGE_INTEGER lpFreeBytesAvailableToCaller, // receives the number of bytes on
  61. // disk available to the caller
  62.   PULARGE_INTEGER lpTotalNumberOfBytes,    // receives the number of bytes on disk
  63.   PULARGE_INTEGER lpTotalNumberOfFreeBytes // receives the free bytes on disk
  64. );
  65.  
  68. //----------------------------------------------------------------------
  69. //
  70. // PrintNtError
  71. //
  72. // Formats an error message for the last native error.
  73. //
  74. //----------------------------------------------------------------------
  75. void PrintNtError( NTSTATUS status )
  76. {
  77. TCHAR *errMsg;
  79. FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  80. NULL, RtlNtStatusToDosError( status ), 
  81. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
  82. (LPTSTR) &errMsg, 0, NULL );
  83. _tprintf(_T("%sn"), errMsg );
  84. LocalFree( errMsg );
  85. }
  88. //--------------------------------------------------------------------
  89. //
  90. // PrintWin32Error
  91. // 
  92. // Translates a Win32 error into a text equivalent
  93. //
  94. //--------------------------------------------------------------------
  95. void PrintWin32Error( DWORD ErrorCode )
  96. {
  97. LPVOID lpMsgBuf;
  99. FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  100. NULL, ErrorCode, 
  101. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  102. (LPTSTR) &lpMsgBuf, 0, NULL );
  103. _tprintf(_T("%sn"), lpMsgBuf );
  104. LocalFree( lpMsgBuf );
  105. }
  108. //--------------------------------------------------------------------
  109. //
  110. // OverwriteFileName
  111. //
  112. // Securely deletes a file's original name by renaming it several
  113. // times. This works by changing each non-'.' character in the file's
  114. // name to successive alphabetic characters, thus overwriting the
  115. // name 26 times.
  116. //
  117. //--------------------------------------------------------------------
  118. VOID OverwriteFileName( PTCHAR FileName, PTCHAR LastFileName )
  119. {
  120. TCHAR newName[MAX_PATH];
  121. PTCHAR lastSlash;
  122. DWORD i, j, index;
  124. _tcscpy( LastFileName, FileName );
  125. lastSlash = _tcsrchr( LastFileName, _T('\'));
  126. index = (lastSlash - LastFileName)/sizeof(TCHAR);
  128. //
  129. // Loop through each letter in the English alphabet
  130. //
  131. _tcscpy( newName, FileName );
  132. for( i = 0; i < 26; i++ ) {
  134. //
  135. // Replace each non-'.' character with the same letter
  136. //
  137. for( j = index+1 ; j < _tcsclen( FileName ); j++ ) {
  139. if( FileName[j] != _T('.')) newName[j] = (TCHAR) i + _T('A');
  140. }
  142. //
  143. // Got a new name so rename
  144. //
  145. if( !MoveFile( LastFileName, newName )) {
  147. //
  148. // Bail on error
  149. //
  150. return;
  151. }
  153. _tcscpy( LastFileName, newName );
  154. }
  155. }
  158. //--------------------------------------------------------------------
  159. //
  160. // SecureOverwrite
  161. //
  162. // This function implements a secure santize of rigid (removable 
  163. // and fixed) disk media as per the Department of Defense clearing 
  164. // and sanitizing standard: DOD 5220.22-M
  165. // 
  166. // The standard states that hard disk media is sanatized by 
  167. // overwriting with a character, then the character's complement,
  168. // and then a random character. Note that the standard specicically
  169. // states that this method is not suitable for TOP SECRET information.
  170. // TOP SECRET data sanatizing is only achievable by a Type 1 or 2 
  171. // degauss of the disk, or by disintegrating, incinerating, 
  172. // pulverizing, shreding, or melting the disk.
  173. //
  174. //--------------------------------------------------------------------
  175. BOOLEAN SecureOverwrite( HANDLE FileHandle, DWORD Length )
  176. {
  177. #define CLEANBUFSIZE 65536
  178. static PBYTE cleanBuffer[3];
  179. static BOOLEAN buffersAlloced = FALSE;
  181. DWORD i, j, passes;
  182. DWORD bytesWritten, bytesToWrite, totalWritten;
  183. LONG seekLength;
  184. BOOLEAN status;
  186. //
  187. // Allocate our cleaning buffers if necessary (we just let program
  188. // exit free the buffers).
  189. //
  190. if( !buffersAlloced ) {
  192. //
  193. // Seed the random number generator
  194. //
  195. srand( (unsigned)time( NULL ) );
  197. for( i = 0; i < 3; i++ ) {
  199. cleanBuffer[i] = VirtualAlloc( NULL, CLEANBUFSIZE, MEM_COMMIT, PAGE_READWRITE );
  200. if( !cleanBuffer[i] ) {
  202. for( j = 0; j < i; j++ ) {
  204. VirtualFree( cleanBuffer[j], 0, MEM_RELEASE );
  205. }
  206. return FALSE;
  207. }
  209. //
  210. // Fill each buffer with a different signature
  211. //
  212. switch( i ) {
  214. case 0:
  215. // do nothing - buffer is zero-filled by Windows
  216. break;
  217. case 1:
  218. // fill with complement of 0 - 0xFF
  219. memset( cleanBuffer[i], 0xFF, CLEANBUFSIZE );
  220. break;
  221. case 2:
  222. // fill with a random value
  223. for( j = 0; j < CLEANBUFSIZE; j++ ) cleanBuffer[i][j] = (BYTE) rand();
  224. break;
  225. }
  226. }
  227. buffersAlloced = TRUE;
  228. }
  230. //
  231. // Do the overwrite
  232. //
  233. seekLength = (LONG) Length;
  234. for( passes = 0; passes < NumPasses; passes++ ) {
  236. if( passes != 0 ) {
  238. SetFilePointer( FileHandle, -seekLength, NULL, FILE_CURRENT );
  239. }
  241. for( i = 0; i < 3; i++ ) {
  243. //
  244. // Move back to the start of where we're overwriting
  245. //
  246. if( i != 0 ) {
  248. SetFilePointer( FileHandle, -seekLength, NULL, FILE_CURRENT );
  249. }
  251. //
  252. // Loop and overwrite
  253. //
  254. bytesToWrite = Length;
  255. totalWritten = 0;
  256. while( totalWritten < Length ) {
  258. bytesToWrite = Length - totalWritten;
  259. if( bytesToWrite > CLEANBUFSIZE ) bytesToWrite = CLEANBUFSIZE;
  261. status = WriteFile( FileHandle, cleanBuffer[i], bytesToWrite, &bytesWritten, NULL );
  262. if( !status ) return FALSE;
  264. //
  265. // Note: no need to flush since the file is opened with write-through or 
  266. // no cache buffering
  267. //
  269. totalWritten += bytesWritten;
  270. }
  271. }
  272. }
  273. return TRUE;
  274. }
  277. //--------------------------------------------------------------------
  278. //
  279. // SecureDelete
  280. //
  281. // Performs a secure delete on the specified file.
  282. //
  283. //--------------------------------------------------------------------
  284. VOID SecureDelete( PTCHAR FileName, DWORD FileLengthHi,
  285. DWORD FileLengthLo ) 
  286. {
  287. HANDLE hFile;
  288. ULONGLONG bytesToWrite, bytesWritten;
  289. ULARGE_INTEGER fileLength;
  290. TCHAR   lastFileName[MAX_PATH];
  292. //
  293. // First, open the file in overwrite mode
  294. //
  295. hFile = CreateFile( FileName, GENERIC_WRITE, 
  296. FILE_SHARE_READ|FILE_SHARE_WRITE,
  297. NULL, CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL );
  298. if( hFile == INVALID_HANDLE_VALUE ) {
  300. _tprintf( _T("nError opening %s for delete: "), FileName );
  301. PrintWin32Error( GetLastError());
  302. return;
  303. }
  305. //
  306. // If the file has a non-zero length, fill it with 0's first in order
  307. // to preserve is cluster allocation.
  308. //
  309. if( FileLengthLo || FileLengthHi ) {
  311. //
  312. // Seek to the last byte of the file
  313. //
  314. FileLengthLo--;
  315. if( FileLengthLo == (DWORD) -1 && FileLengthHi ) FileLengthHi--;
  316. SetFilePointer( hFile, FileLengthLo, &FileLengthHi, FILE_BEGIN );
  318. //
  319. // Write one zero byte, which causes the file system to fill the entire
  320. // file's on-disk contents with 0.
  321. //
  322. if( !SecureOverwrite( hFile, 1 )) {
  324. _tprintf( _T("nError overwriting %s: "), FileName );
  325. PrintWin32Error( GetLastError() );
  326. CloseHandle( hFile );
  327. return;
  328. }
  330. //
  331. // Now go back to the start of the file and overwrite the rest of the
  332. // file.
  333. //
  334. SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
  335. fileLength.LowPart = FileLengthLo;
  336. fileLength.HighPart = FileLengthHi;
  337. bytesWritten = 0;
  338. while( bytesWritten < fileLength.QuadPart ) {
  340. bytesToWrite = min( fileLength.QuadPart - bytesWritten, 65536 );
  341. if( !SecureOverwrite( hFile, (DWORD) bytesToWrite )) {
  343. _tprintf( _T("nError overwriting %s: "), FileName );
  344. PrintWin32Error( GetLastError() );
  345. CloseHandle( hFile );
  346. return;
  347. }
  348. bytesWritten += bytesToWrite;
  349. }
  350. }
  352. //
  353. // Done!
  354. //
  355. CloseHandle( hFile );
  357. //
  358. // Rename the file a few times
  359. //
  360. OverwriteFileName( FileName, lastFileName );
  362. //
  363. // Now we can delete the file
  364. //
  365. if( !DeleteFile( lastFileName ) ) {
  367. _tprintf( _T("nError deleting %s: "), FileName );
  368. PrintWin32Error( GetLastError() );
  370. //
  371. // Rename back to original name so as not to confuse the user
  372. //
  373. if( !MoveFile( lastFileName, FileName )) {
  375. _tprintf( _T("nError renaming file back to original name. File is left as %sn"),
  376. lastFileName );
  377. }
  378. return;
  379. }
  381. if( !Silent ) _tprintf( _T("deleted.n"));
  382. }
  386. //--------------------------------------------------------------------
  387. //
  388. // ScanFile
  389. //
  390. // This is only invoked for compressed, encrypted or sparse files, 
  391. // which exists only on NTFS drives (WinNT/2K). Thus, we can use
  392. // the defrag API to zap the clusters belonging to the file 
  393. // Determines if the the file is non-resident (outside the MFT), and 
  394. // if so and we were able to open the volume for write access, we zap 
  395. // the clusters.
  396. //
  397. //--------------------------------------------------------------------
  398. BOOLEAN ScanFile( HANDLE VolumeHandle,
  399.   DWORD ClusterSize,
  400.   HANDLE FileHandle, 
  401.   PBOOLEAN ReallyCompressed,
  402.   PBOOLEAN ZappedFile )
  403. {
  404. DWORD status;
  405. int i;
  406. IO_STATUS_BLOCK ioStatus;
  407. ULONGLONG startVcn, prevVcn;
  408. LARGE_INTEGER clusterOffset;
  409. ULONGLONG endOfPrevRun;
  410. PGET_RETRIEVAL_DESCRIPTOR fileMappings;
  411. ULONGLONG fileMap[ FILEMAPSIZE ];
  412. int lines = 0;
  414. //
  415. // Assume file is in an MFT record.
  416. //
  417. *ReallyCompressed = FALSE;
  418. *ZappedFile = FALSE;
  420. startVcn = 0;
  421. endOfPrevRun = LLINVALID;
  422. fileMappings = (PGET_RETRIEVAL_DESCRIPTOR) fileMap;
  423. while( !(status = NtFsControlFile( FileHandle, NULL, NULL, 0, &ioStatus,
  424. FSCTL_GET_RETRIEVAL_POINTERS,
  425. &startVcn, sizeof( startVcn ),
  426. fileMappings, FILEMAPSIZE * sizeof(ULONGLONG) ) ) ||
  427.  status == STATUS_BUFFER_OVERFLOW ||
  428.  status == STATUS_PENDING ) {
  430. // 
  431. // If the operation is pending, wait for it to finish
  432. //
  433. if( status == STATUS_PENDING ) {
  435. WaitForSingleObject( FileHandle, INFINITE ); 
  437. //
  438. // Get the status from the status block
  439. //
  440. if( ioStatus.Status != STATUS_SUCCESS && 
  441. ioStatus.Status != STATUS_BUFFER_OVERFLOW ) {
  443. return ioStatus.Status == STATUS_SUCCESS;
  444. }
  445. }
  447. //
  448. // Loop through the buffer of number/cluster pairs, printing them
  449. // out.
  450. //
  451. startVcn = fileMappings->StartVcn;
  452. prevVcn  = fileMappings->StartVcn;
  453. for( i = 0; i < (ULONGLONG) fileMappings->NumberOfPairs; i++ ) {  
  455. //
  456. // On NT 4.0, a compressed virtual run (0-filled) is 
  457. // identified with a cluster offset of -1
  458. //
  459. if( fileMappings->Pair[i].Lcn != LLINVALID ) {
  461. //
  462. // Its compressed and outside the zone
  463. //
  464. *ReallyCompressed = TRUE;
  466. //
  467. // Overwrite the clusters if we were able to open the volume
  468. // for write access.
  469. //
  470. if( VolumeHandle != INVALID_HANDLE_VALUE ) {
  473. clusterOffset.QuadPart = fileMappings->Pair[i].Lcn * ClusterSize;
  474. SetFilePointer( VolumeHandle, clusterOffset.LowPart,
  475. &clusterOffset.HighPart, FILE_BEGIN );
  476. if( !SecureOverwrite( VolumeHandle,
  477. ClusterSize * (DWORD) (fileMappings->Pair[i].Vcn - startVcn) )) {
  479. //
  480. // Couldn't zap the clusters, so we'll have to clean the free space
  481. //
  482. return TRUE;
  483. }
  485. } else {
  487. return TRUE;
  488. }
  489. }
  490. startVcn = fileMappings->Pair[i].Vcn;
  491. }
  493. //
  494. // If the buffer wasn't overflowed, then we're done
  495. //
  496. if( !status ) break;
  497. }
  499. //
  500. // Return now if there were any errors
  501. //
  502. if( status && status != STATUS_INVALID_PARAMETER && !Silent ) {
  504. printf("Scanning file: ");
  505. PrintNtError( status );
  506. }
  508. // 
  509. // If we made through with no errors we've overwritten all the file's
  510. // clusters.
  511. //
  512. if( status == STATUS_SUCCESS ) *ZappedFile = TRUE;
  513. return status == STATUS_SUCCESS;
  514. }
  517. //--------------------------------------------------------------------
  518. //
  519. // SecureDeleteCompressed
  520. //
  521. // More complicated than a regular file - we actually try to use
  522. // direct disk access to overwrite the clusters that are used by a 
  523. // compressed file. The function returns FALSE if the file is
  524. // not really compressed (it is stored as resident data in the MFT).
  525. //
  526. //--------------------------------------------------------------------
  527. BOOLEAN SecureDeleteCompressed( PTCHAR FileName ) 
  528. {
  529. HANDLE hFile;
  530. BOOLEAN reallyCompressed = FALSE;
  531. BOOLEAN zappedFile = FALSE;
  532. TCHAR lastFileName[MAX_PATH];
  533. static TCHAR volumeName[] = _T("\\.\A:");
  534. static TCHAR volumeRoot[] = _T("A:\");
  535. static HANDLE hVolume = INVALID_HANDLE_VALUE;
  536. static DWORD clusterSize;
  537. DWORD sectorsPerCluster, bytesPerSector, freeClusters, totalClusters;
  539. //
  540. // If we haven't opened the volume, attempt it now
  541. //
  542. if( hVolume == INVALID_HANDLE_VALUE ) {
  544. volumeName[4] = FileName[0];
  545. hVolume = CreateFile( volumeName, GENERIC_READ|GENERIC_WRITE,
  546. FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
  547. 0, 0 );
  549. volumeRoot[0] = FileName[0];
  550. GetDiskFreeSpace( volumeRoot, &sectorsPerCluster, &bytesPerSector,
  551. &freeClusters, &totalClusters );
  553. clusterSize = bytesPerSector * sectorsPerCluster;
  554. }
  556. //
  557. // Open the file exclusively
  558. //
  559. hFile = CreateFile( FileName, GENERIC_READ, 
  560. 0,NULL, OPEN_EXISTING, 0, NULL );
  561. if( hFile == INVALID_HANDLE_VALUE ) {
  563. _tprintf( _T("nError opening %s for compressed file scan: "), FileName );
  564. PrintWin32Error( GetLastError());
  565. return TRUE;
  566. }
  568. //
  569. // Scan the location of the file
  570. //
  571. if( !ScanFile( hVolume, clusterSize, hFile, 
  572. &reallyCompressed, &zappedFile )) {
  574. CloseHandle( hFile );
  575. return TRUE;
  576. }
  578. // 
  579. // Done with the file handle
  580. //
  581. CloseHandle( hFile );
  583. //
  584. // If the file is really compressed (it is non-resident),
  585. // we can delete it now.
  586. //
  587. if( reallyCompressed ) {
  589. //
  590. // Rename the file a few times
  591. //
  592. CloseHandle( hFile );
  594. OverwriteFileName( FileName, lastFileName );
  596. if( !DeleteFile( lastFileName )) {
  598. //
  599. // Rename back to the original name on error so as
  600. // not to confuse the user
  601. //
  602. _tprintf( _T("nError deleting %s: "), FileName );
  603. PrintWin32Error( GetLastError() );
  604. if( !MoveFile( lastFileName, FileName )) {
  606. _tprintf( _T("nError renaming file back to original name. File is left as %sn"),
  607. lastFileName );
  608. }
  609. return TRUE;
  610. }
  612. //
  613. // If we couldn't directly overwrite the file's clusters, we'll
  614. // have to clean free space to overwrite them indirectly
  615. //
  616. if( !zappedFile ) CleanCompressedFiles = TRUE;
  618. if( !Silent ) _tprintf( _T("deleted.n"));
  619. }
  621. //
  622. // Return TRUE if the file had clusters outside the MFT
  623. //
  624. return reallyCompressed;
  625. }
  628. //--------------------------------------------------------------------
  629. //
  630. // ProcessFile
  631. //
  632. // Performs a secure delete on the specified file.
  633. //
  634. //--------------------------------------------------------------------
  635. VOID ProcessFile( PWIN32_FIND_DATA FindData, TCHAR *FileName )
  636. {
  637. //
  638. // Directories are deleted by ProcessDirectory
  639. //
  640. if( FindData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) return;
  642. //
  643. // Got a matching file
  644. //
  645. FilesFound++;
  647. //
  648. // Print which file we're working on
  649. //
  650. if( !Silent ) {
  652. _tprintf( _T("%s..."), FileName );
  653. fflush( stdout );
  654. }
  656. //
  657. // If the file is compressed, we have to go a different path
  658. //
  659. if( FindData->dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED ||
  660. FindData->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED  ||
  661. FindData->dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE ) {
  663. //
  664. // We need to determine where the compressed file is located 
  665. // physically on disk.
  666. //
  667. if( SecureDeleteCompressed( FileName )) return;
  668. } 
  670. // 
  671. // Regular path, non-compressed/encrypted/sparse file or one of those
  672. // types of files with their data resident in an MFT record: perform a 
  673. // simple secure delete
  674. //
  675. SecureDelete( FileName, FindData->nFileSizeHigh,
  676. FindData->nFileSizeLow );
  677. }
  680. //--------------------------------------------------------------------
  681. //
  682. // ProcessDirectory
  683. // 
  684. // Recursive routine that passes files to the delete function.
  685. //
  686. //--------------------------------------------------------------------
  687. void ProcessDirectory( TCHAR *PathName, TCHAR *SearchPattern )
  688. {
  689. TCHAR subName[MAX_PATH], fileSearchName[MAX_PATH], searchName[MAX_PATH];
  690. HANDLE dirHandle, patternHandle;
  691. static BOOLEAN firstCall = TRUE;
  692. static BOOLEAN  deleteDirectories = FALSE;
  693. WIN32_FIND_DATA foundFile;
  695. //
  696. // Scan the files and/or directories if this is a directory
  697. //
  698. if( firstCall ) {
  700. if( _tcsrchr( PathName, '*' ) ) {
  702.             if( _tcsrchr( PathName, '\' ) ) {
  704.                 _stprintf( SearchPattern, _tcsrchr( PathName, '\' )+1 );
  705.                 _tcscpy( searchName, PathName );
  706.                 _tcscpy( _tcsrchr( searchName, '\')+1, _T("*.*") );
  707. if( !_tcscmp( SearchPattern, _T("*.*")) ||
  708. !_tcscmp( SearchPattern, _T("*"))) {
  710. deleteDirectories = TRUE;
  711. }
  713.             } else {
  714.                 
  715.                 _stprintf( SearchPattern, PathName );
  716.                 _tcscpy( searchName, PathName );
  717.             }
  718.             _stprintf( fileSearchName, _T("%s"), PathName );
  720. } else {
  722. _stprintf( SearchPattern, _T("*.*") );
  723. _stprintf( searchName, _T("%s"), PathName );
  724.             _stprintf( fileSearchName, _T("%s"), PathName );
  725. deleteDirectories = TRUE;
  726. }
  728. } else {
  730. _stprintf( searchName, _T("%s\*.*"), PathName );
  731. _stprintf( fileSearchName, _T("%s\%s"), PathName, SearchPattern );
  732. }
  734. //
  735. // Process all the files, according to the search pattern
  736. //
  737. if( (patternHandle = FindFirstFile( fileSearchName, &foundFile )) != 
  738. INVALID_HANDLE_VALUE  ) {
  740. do {
  742. if( _tcscmp( foundFile.cFileName, _T(".") ) &&
  743. _tcscmp( foundFile.cFileName, _T("..") )) {
  745. _tcscpy( subName, searchName );
  746. if( _tcsrchr( subName, '\' ) ) 
  747. _tcscpy( _tcsrchr( subName, '\')+1, foundFile.cFileName );
  748. else
  749. _tcscpy( subName, foundFile.cFileName );
  751. //
  752. // Do this file/directory
  753. //
  754. ProcessFile( &foundFile, subName );
  755. }
  756. } while( FindNextFile( patternHandle, &foundFile ));
  757. FindClose( patternHandle );
  758. }
  760. //
  761. // Now recurse if we're supposed to
  762. //
  763. if( Recurse ) {
  765.         if( firstCall && !_tcsrchr( searchName, L'\') ) {
  767.             if( _tcsrchr( searchName, L'*' )) {
  769.                 if( (dirHandle = FindFirstFile( _T("*.*"), &foundFile )) == 
  770.                     INVALID_HANDLE_VALUE  ) {
  772.                     //
  773.                     // Nothing to process
  774.                     //
  775.                     return;
  776.                 }
  777.             } else {
  779.                 if( (dirHandle = FindFirstFile( searchName, &foundFile )) == 
  780.                     INVALID_HANDLE_VALUE  ) {
  782.                     //
  783.                     // Nothing to process
  784.                     //
  785.                     return;
  786.                 }
  787.             }
  788.         } else {
  790.             if( (dirHandle = FindFirstFile( searchName, &foundFile )) == 
  791.                 INVALID_HANDLE_VALUE  ) {
  793.                 //
  794.                 // Nothing to process
  795.                 //
  796.                 return;
  797.             }
  798.         }
  799.         firstCall = FALSE;
  801. do {
  803. if( (foundFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
  804. _tcscmp( foundFile.cFileName, _T(".") ) &&
  805. _tcscmp( foundFile.cFileName, _T("..") )) {
  807. _tcscpy( subName, searchName );
  808. if( _tcsrchr( subName, '\' ) ) 
  809. _tcscpy( _tcsrchr( subName, '\')+1, foundFile.cFileName );
  810. else
  811. _tcscpy( subName, foundFile.cFileName );
  813. //
  814. // Go into this directory
  815. //
  816. ProcessDirectory( subName, SearchPattern );
  818. //
  819. // Delete the directory if we're supposed to
  820. //
  821. if( deleteDirectories ) {
  823. if( !RemoveDirectory( subName )) {
  825. _tprintf( _T("nError deleting %s: "), subName );
  826. PrintWin32Error( GetLastError() );
  827. }
  828. }
  829. }
  831. } while( FindNextFile( dirHandle, &foundFile ));
  832. FindClose( dirHandle );
  833. }
  834. }
  837. //--------------------------------------------------------------------
  838. //
  839. // CleanFreeSpace
  840. //
  841. // This function overwrites all free-space data areas on a disk, 
  842. // including free space in the MFT. Note that it does not overwrite 
  843. // freespace filename information.
  844. //
  845. //--------------------------------------------------------------------
  846. BOOLEAN CleanFreeSpace( PTCHAR DrivePath )
  847. {
  848. TCHAR tempFileName[MAX_PATH];
  849. ULARGE_INTEGER bytesAvail, totalBytes, freeBytes;
  850. DWORD sectorsPerCluster, bytesPerSector, totalClusters, freeClusters;
  851. ULONGLONG tempSize = 0;
  852. TCHAR progress[] = _T("|/-\|/-\");
  853. HANDLE hTempFile;
  854. BOOLEAN createdFile;
  855. DWORD percent, cleanSize, mftFilesCreated;
  856. DWORD prevSize, prevPercent = 0;
  858. if( DrivePath[1] != ':' ) {
  860. _tprintf( _T("Cannot clean free space for UNC drivenn"));
  861. return FALSE;
  862. }
  864. //
  865. // Drive letter - move to one past slash
  866. //
  867. DrivePath[3] = 0;
  869. if( CleanCompressedFiles ) {
  871. _tprintf(_T("Cleaning free space to securely delete compressed files: 0%%"));
  872. } else {
  874. _tprintf(_T("Cleaning free space on %s: 0%%"), DrivePath );
  875. }
  876. fflush( stdout );
  878. if( !GetDiskFreeSpace( DrivePath, &sectorsPerCluster, &bytesPerSector,
  879. &freeClusters, &totalClusters )) {
  881. _tprintf( _T("Could not determine disk cluster size: "));
  882. PrintWin32Error( GetLastError());
  883. return FALSE;
  884. }
  886. #if UNICODE
  887. if( !(pGetDiskFreeSpaceEx = (PVOID) GetProcAddress( GetModuleHandle( _T("kernel32.dll") ),
  888. "GetFreeDiskSpaceExW" ))) {
  889. #else
  890. if( !(pGetDiskFreeSpaceEx = (PVOID) GetProcAddress( GetModuleHandle( _T("kernel32.dll") ),
  891. "GetDiskFreeSpaceExA" ))) {
  892. #endif
  894. bytesAvail.QuadPart = sectorsPerCluster * freeClusters * bytesPerSector;
  896. } else {
  898. if( !pGetDiskFreeSpaceEx( DrivePath, &bytesAvail, &totalBytes, &freeBytes )) {
  900. _tprintf( _T("Could not determine amount of free space: "));
  901. PrintWin32Error( GetLastError());
  902. return FALSE;
  903. }
  904. }
  906. //
  907. // If the user doesn't have access to all the free space, we can't perform a full clean
  908. //
  909. if( bytesAvail.QuadPart != freeBytes.QuadPart ) {
  911. _tprintf(_T("Your disk quota prevents you from cleaning free space on this drive.nn"));
  912. return FALSE;
  913. }
  915. _stprintf( tempFileName, _T("%sSDELTEMP"), DrivePath );
  916. hTempFile = CreateFile( tempFileName, GENERIC_WRITE, 
  917. 0, NULL, CREATE_NEW, 
  918. FILE_FLAG_NO_BUFFERING|FILE_FLAG_SEQUENTIAL_SCAN|
  919. FILE_FLAG_DELETE_ON_CLOSE|FILE_ATTRIBUTE_HIDDEN, NULL );
  921. if( hTempFile == INVALID_HANDLE_VALUE ) {
  923. _tprintf( _T("Could not create free-space cleanup file: "));
  924. PrintWin32Error( GetLastError());
  925. return FALSE;
  926. }
  928. //
  929. // Allcate a buffer that is a cluster in size
  930. //
  931. cleanSize = sectorsPerCluster * bytesPerSector * 128;
  933. //
  934. // Grow the file by cluster size chunks until we fail
  935. //
  936. while( cleanSize > bytesPerSector * sectorsPerCluster ) {
  938. if( SecureOverwrite( hTempFile, cleanSize )) {
  940. tempSize += cleanSize;
  942. percent = (DWORD) ((tempSize * 100)/ freeBytes.QuadPart );
  944. if( percent != prevPercent ) {
  945. if( CleanCompressedFiles ) {
  947. _tprintf(_T("rCleaning free space to securely delete compressed files: %d%%"),
  948. percent );
  949. } else {
  951. _tprintf(_T("rCleaning free space on %s: %d%%"), DrivePath, percent );
  952. }
  953. prevPercent = percent;
  954. }
  955. } else {
  957. cleanSize -= bytesPerSector * sectorsPerCluster;
  958. }
  959. }
  961. //
  962. // There's less than a full cluster (outside the MFT if this is NTFS) free. 
  963. // Let's allocate another file to take care of it.
  964. //
  965. _stprintf( tempFileName, _T("%sSDELTEMP1"), DrivePath );
  966. hTempFile = CreateFile( tempFileName, GENERIC_WRITE, 
  967. 0, NULL, CREATE_NEW, 
  968. FILE_FLAG_SEQUENTIAL_SCAN|FILE_FLAG_DELETE_ON_CLOSE|
  969. FILE_ATTRIBUTE_HIDDEN|FILE_FLAG_WRITE_THROUGH, NULL );
  971. if( hTempFile != INVALID_HANDLE_VALUE ) {
  973. while( cleanSize ) {
  975. if( !SecureOverwrite( hTempFile, cleanSize )) {
  977. cleanSize--;
  978. }
  979. }
  980. }
  982. //
  983. // If we're just zapping free space, and this is NTFS, we have to take care of
  984. // deleted files within the MFT. We do this by creating as many of the largest sized
  985. // files we can (if there is space in the MFT, we'll be able to create non-zero sized
  986. // files, where the data is resident in the MFT record).
  987. //
  988. if( ZapFreeSpace ) {
  990. mftFilesCreated = 0;
  991. prevSize = 4096; // max MFT record size
  992. while( 1 ) {
  994. _stprintf( tempFileName, _T("%sSDELMFT%06d"), DrivePath, mftFilesCreated++ );
  995. hTempFile = CreateFile( tempFileName, GENERIC_WRITE, 
  996. 0, NULL, CREATE_NEW, 
  997. FILE_FLAG_SEQUENTIAL_SCAN|FILE_FLAG_DELETE_ON_CLOSE|
  998. FILE_ATTRIBUTE_HIDDEN, NULL );
  999. if( hTempFile == INVALID_HANDLE_VALUE ) {
  1001. break;
  1002. }
  1004. //
  1005. // Mft record can be up to 4K in size
  1006. //
  1007. cleanSize = prevSize;
  1008. createdFile = FALSE;
  1009. while( cleanSize ) {
  1011. if( !SecureOverwrite( hTempFile, cleanSize )) {
  1013. cleanSize--;
  1015. } else {
  1017. prevSize = cleanSize;
  1018. createdFile = TRUE;
  1019. }
  1020. }
  1022. //
  1023. // If the only file we could create is length 0, then this is FAT
  1024. //
  1025. if( !createdFile ) break;
  1027. if( mftFilesCreated == 1 ) {
  1028. _tprintf( _T("r                                                           "));
  1030. } 
  1032. _tprintf( _T("rCleaning MFT...%c"),
  1033. progress[ mftFilesCreated % 8 ]);
  1035. // Don't close the file, since we want it to keep the space until we're
  1036. // done.
  1037. }
  1038. }
  1040. //
  1041. // Done. No need to close our handles, since they are all delete-on-close.
  1042. //
  1043. _tprintf(_T("rFree space cleaned on %s                                       n"),
  1044. DrivePath );
  1045. return TRUE;
  1046. }
  1049. //--------------------------------------------------------------------
  1050. //
  1051. // LocateNativeEntryPoints
  1052. //
  1053. //--------------------------------------------------------------------
  1054. VOID LocateNativeEntryPoints()
  1055. {
  1056. //
  1057. // If we're on Win9x, just return
  1058. //
  1059. if( GetVersion() >= 0x80000000) return;
  1061.     //
  1062.     // Load the NTDLL entry point we need
  1063.     //
  1064. if( !(NtFsControlFile = (void *) GetProcAddress( GetModuleHandle(_T("ntdll.dll")),
  1065. "NtFsControlFile" )) ) {
  1067. _tprintf(_T("nCould not find NtFsControlFile entry point in NTDLL.DLLn"));
  1068. exit(1);
  1069. }
  1070. if( !(RtlNtStatusToDosError = (void *) GetProcAddress( GetModuleHandle(_T("ntdll.dll")),
  1071. "RtlNtStatusToDosError" )) ) {
  1073. _tprintf(_T("nCould not find RtlNtStatusToDosError entry point in NTDLL.DLLn"));
  1074. exit(1);
  1075. }
  1076. }
  1079. //--------------------------------------------------------------------
  1080. //
  1081. // Usage
  1082. //
  1083. // Tell user how to use the program.
  1084. //
  1085. //--------------------------------------------------------------------
  1086. int Usage( TCHAR *ProgramName ) 
  1087. {
  1088.     _tprintf(_T("usage: %s [-p passes] [-s] [-q] <file or directory>n"), ProgramName );
  1089. _tprintf(_T("       %s [-p passes] -z [drive letter]n"), ProgramName );
  1090. _tprintf(_T("   -p passes  Specifies number of overwrite passes (default is 1)n"));
  1091.     _tprintf(_T("   -s         Recurse subdirectoriesn"));
  1092.     _tprintf(_T("   -q         Don't print errors (Quiet)n"));
  1093. _tprintf(_T("   -z         Clean free spacenn"));
  1094.     return -1;
  1095. }
  1098. //--------------------------------------------------------------------
  1099. //
  1100. // Main
  1101. //
  1102. // Runs the show. 
  1103. //
  1104. //--------------------------------------------------------------------
  1105. int _tmain( int argc, TCHAR *argv[] ) 
  1106. {
  1107.     TCHAR       searchPattern[MAX_PATH];
  1108. TCHAR searchPath[MAX_PATH];
  1109. PTCHAR filePart;
  1110. BOOL foundFileArg = FALSE;
  1111. int i;
  1113.     //
  1114.     // Print banner and perform parameter check
  1115.     //
  1116.     _tprintf(_T("nSDelete - Secure Delete v1.1n") );
  1117.     _tprintf(_T("Copyright (C) 1999 Mark Russinovichn"));
  1118.     _tprintf(_T("Systems Internals - http://www.sysinternals.comnn"));
  1120.     if( argc < 2 ) {
  1122.         return Usage( argv[0] );
  1123.     }
  1125.     for( i = 1; i < argc; i++ ) {
  1127.     if( !_tcsicmp( argv[i], _T("/s") ) ||
  1128. !_tcsicmp( argv[i], _T("-s") )) {
  1130. Recurse = TRUE;
  1132. } else if( !_tcsicmp( argv[i], _T("/q") ) ||
  1133.    !_tcsicmp( argv[i], _T("-q") )) {
  1135. Silent = TRUE;
  1137. } else if( !_tcsicmp( argv[i], _T("/z") ) ||
  1138.    !_tcsicmp( argv[i], _T("-z") )) {
  1140. ZapFreeSpace = TRUE;
  1142. } else if( !_tcsicmp( argv[i], _T("/p") ) ||
  1143.    !_tcsicmp( argv[i], _T("-p") )) {
  1145. NumPasses = atoi( argv[i+1] );
  1146. if( !NumPasses ) return Usage( argv[0] );
  1147. i++;
  1149. } else if( !_tcsicmp( argv[i], _T("/?") ) ||
  1150.    !_tcsicmp( argv[i], _T("-?") )) {
  1151.    
  1152. return Usage( argv[0] );
  1154. } else {
  1156. if( foundFileArg ) return Usage( argv[0] );
  1157. foundFileArg = TRUE;
  1158. }
  1159.     }
  1161. //
  1162. // Have to have file if not zapping free space
  1163. //
  1164. if( !ZapFreeSpace && !foundFileArg ) {
  1166. return Usage( argv[0] );
  1167. }
  1169. //
  1170. // Locate Native entry points we need
  1171. //
  1172. LocateNativeEntryPoints();
  1174. if( foundFileArg ) {
  1176. //
  1177. // Get canonical path name
  1178. //
  1179. GetFullPathName( argv[argc-1], MAX_PATH, searchPath, &filePart );
  1180. }
  1181. printf("SDelete is set for %d pass%s.n", NumPasses,
  1182. NumPasses > 1 ? "es" : "");
  1184. //
  1185. // Do the deleting
  1186. //
  1187. if( !ZapFreeSpace ) {
  1189. //
  1190. // Now go and process directories
  1191. //
  1192. ProcessDirectory( searchPath, searchPattern );
  1194. if( !FilesFound ) _tprintf(_T("No files found that match %s.n"), argv[argc-1] );
  1196. } else if( !foundFileArg ) {
  1198. GetCurrentDirectory( MAX_PATH, searchPath );
  1199. } 
  1201. //
  1202. // If we encountered a compressed file along the way, and we couldn't directly
  1203. // zap its on-disk clusters then we have to clean all the free space.
  1204. //
  1205. if( CleanCompressedFiles || ZapFreeSpace ) {
  1207. CleanFreeSpace( searchPath );
  1208. }
  1210. _tprintf(_T("n"));
  1211.     return 0;
  1212. }