Changeset 1210


Ignore:
Timestamp:
9/29/2009 10:39:00 AM (4 years ago)
Author:
lowjoel
Message:

Reshuffle the directory structure for Eraser.DefaultPlugins? as the files were becoming messy.

Location:
trunk/eraser6/Eraser.DefaultPlugins
Files:
4 added
2 edited
13 moved

Legend:

Unmodified
Added
Removed

  • trunk/eraser6/Eraser.DefaultPlugins/Eraser.DefaultPlugins.csproj

    r1209 r1210  
    5757      <DependentUpon>CustomMethodPassEditor.cs</DependentUpon> 
    5858    </Compile> 
    59     <Compile Include="EraseCustom.cs" /> 
    60     <Compile Include="EraseDoD.cs" /> 
    61     <Compile Include="EraseRandom.cs" /> 
    62     <Compile Include="EraseGutmann.cs" /> 
    63     <Compile Include="EraseFirstLast16KB.cs" /> 
    64     <Compile Include="EraseHMGIS5.cs" /> 
    65     <Compile Include="EraseGOSTP50739.cs" /> 
    66     <Compile Include="EraseUSAF5020.cs" /> 
    67     <Compile Include="EraseVSITR.cs" /> 
    68     <Compile Include="EraseRCMP_TSSIT_OPS_II.cs" /> 
    69     <Compile Include="FileSystemWindows.cs" /> 
     59    <Compile Include="ErasureMethods\Custom.cs" /> 
     60    <Compile Include="ErasureMethods\DoD.cs" /> 
     61    <Compile Include="ErasureMethods\Random.cs" /> 
     62    <Compile Include="ErasureMethods\Gutmann.cs" /> 
     63    <Compile Include="ErasureMethods\FirstLast16KB.cs" /> 
     64    <Compile Include="ErasureMethods\HMGIS5.cs" /> 
     65    <Compile Include="ErasureMethods\GOSTP50739.cs" /> 
     66    <Compile Include="ErasureMethods\USAF5020.cs" /> 
     67    <Compile Include="ErasureMethods\VSITR.cs" /> 
     68    <Compile Include="ErasureMethods\RCMP_TSSIT_OPS_II.cs" /> 
     69    <Compile Include="FileSystems\Fat.cs" /> 
     70    <Compile Include="FileSystems\Ntfs.cs" /> 
     71    <Compile Include="FileSystems\Windows.cs" /> 
    7072    <Compile Include="Plugin.cs" /> 
    7173    <Compile Include="Properties\AssemblyInfo.cs" /> 
    7274    <Compile Include="RNGCrypto.cs" /> 
    73     <Compile Include="EraseSchneier.cs" /> 
     75    <Compile Include="ErasureMethods\Schneier.cs" /> 
    7476    <Compile Include="SettingsForm.cs"> 
    7577      <SubType>Form</SubType> 
    … …  
    7880      <DependentUpon>SettingsForm.cs</DependentUpon> 
    7981    </Compile> 
    80     <Compile Include="EraseUSArmyAR380_19.cs" /> 
     82    <Compile Include="ErasureMethods\USArmyAR380_19.cs" /> 
    8183  </ItemGroup> 
    8284  <ItemGroup> 

  • trunk/eraser6/Eraser.DefaultPlugins/FileSystems/Windows.cs

    r1209 r1210  
    310310        protected abstract DateTime MinTimestamp { get; } 
    311311    } 
    312  
    313     /// <summary> 
    314     /// Provides functions to handle erasures specific to NTFS volumes. 
    315     /// </summary> 
    316     public class NtfsFileSystem : WindowsFileSystem 
    317     { 
    318         public override bool Supports(string fileSystemName) 
    319         { 
    320             if (fileSystemName == "NTFS") 
    321                 return true; 
    322             return false; 
    323         } 
    324  
    325         public override void EraseOldFileSystemResidentFiles(VolumeInfo volume, 
    326             DirectoryInfo tempDirectory, ErasureMethod method, 
    327             FileSystemEntriesEraseProgress callback) 
    328         { 
    329             try 
    330             { 
    331                 //Squeeze one-byte files until the volume or the MFT is full. 
    332                 long oldMFTSize = NtfsApi.GetMftValidSize(volume); 
    333  
    334                 for (; ; ) 
    335                 { 
    336                     //Open this stream 
    337                     using (FileStream strm = new FileStream( 
    338                         GenerateRandomFileName(tempDirectory, 18), FileMode.CreateNew, 
    339                         FileAccess.Write, FileShare.None, 8, FileOptions.WriteThrough)) 
    340                     { 
    341                         long streamSize = 0; 
    342                         try 
    343                         { 
    344                             while (true) 
    345                             { 
    346                                 //Stretch the file size to use up some of the resident space. 
    347                                 strm.SetLength(++streamSize); 
    348  
    349                                 //Then run the erase task 
    350                                 method.Erase(strm, long.MaxValue, 
    351                                     PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng), 
    352                                     null); 
    353                             } 
    354                         } 
    355                         catch (IOException) 
    356                         { 
    357                             if (streamSize == 1) 
    358                                 return; 
    359                         } 
    360                     } 
    361  
    362                     //We can stop when the MFT has grown. 
    363                     if (NtfsApi.GetMftValidSize(volume) > oldMFTSize) 
    364                         break; 
    365                 } 
    366             } 
    367             catch (IOException) 
    368             { 
    369                 //OK, enough squeezing. 
    370             } 
    371         } 
    372  
    373         public override void EraseDirectoryStructures(VolumeInfo info, 
    374             FileSystemEntriesEraseProgress callback) 
    375         { 
    376             //Create a directory to hold all the temporary files 
    377             DirectoryInfo tempDir = new DirectoryInfo(FileSystem.GenerateRandomFileName( 
    378                 new DirectoryInfo(info.MountPoints[0]), 32)); 
    379             tempDir.Create(); 
    380  
    381             try 
    382             { 
    383                 //Get the size of the MFT 
    384                 long mftSize = NtfsApi.GetMftValidSize(info); 
    385                 long mftRecordSegmentSize = NtfsApi.GetMftRecordSegmentSize(info); 
    386                 int pollingInterval = (int)Math.Max(1, (mftSize / info.ClusterSize / 20)); 
    387                 int totalFiles = (int)Math.Max(1L, mftSize / mftRecordSegmentSize) * 
    388                     (FileNameErasePasses + 1); 
    389                 int filesCreated = 0; 
    390  
    391                 while (true) 
    392                 { 
    393                     ++filesCreated; 
    394                     using (FileStream strm = new FileStream(FileSystem.GenerateRandomFileName( 
    395                         tempDir, 220), FileMode.CreateNew, FileAccess.Write)) 
    396                     { 
    397                     } 
    398  
    399                     if (filesCreated % pollingInterval == 0) 
    400                     { 
    401                         if (callback != null) 
    402                             callback(filesCreated, totalFiles); 
    403  
    404                         //Check if the MFT has grown. 
    405                         if (mftSize < NtfsApi.GetMftValidSize(info)) 
    406                             break; 
    407                     } 
    408                 } 
    409             } 
    410             catch (IOException) 
    411             { 
    412             } 
    413             finally 
    414             { 
    415                 //Clear up all the temporary files 
    416                 FileInfo[] files = tempDir.GetFiles("*", SearchOption.AllDirectories); 
    417                 int totalFiles = files.Length * (FileNameErasePasses + 1); 
    418                 for (int i = 0; i < files.Length; ++i) 
    419                 { 
    420                     if (callback != null && i % 50 == 0) 
    421                         callback(files.Length + i * FileNameErasePasses, totalFiles); 
    422                     DeleteFile(files[i]); 
    423                 } 
    424  
    425                 DeleteFolder(tempDir); 
    426             } 
    427         } 
    428  
    429         public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method, 
    430             ErasureMethodProgressFunction callback) 
    431         { 
    432             //Check if the file fits in one MFT record 
    433             long mftRecordSize = NtfsApi.GetMftRecordSegmentSize(VolumeInfo.FromMountpoint(info.DirectoryName)); 
    434             while (info.Length < mftRecordSize) 
    435             { 
    436                 //Yes it does, erase exactly to the file length 
    437                 using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write, 
    438                     FileShare.None)) 
    439                 { 
    440                     strm.SetLength(strm.Length + 1); 
    441                     method.Erase(strm, long.MaxValue, 
    442                         PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng), null); 
    443                 } 
    444             } 
    445  
    446             //Create the file stream, and call the erasure method to write to 
    447             //the stream. 
    448             long fileArea = GetFileArea(info.FullName); 
    449  
    450             //If the stream is empty, there's nothing to overwrite. Continue 
    451             //to the next entry 
    452             if (fileArea == 0) 
    453                 return; 
    454  
    455             using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write, 
    456                 FileShare.None, FileOptions.WriteThrough)) 
    457             { 
    458                 //Set the end of the stream after the wrap-round the cluster size 
    459                 strm.SetLength(fileArea); 
    460  
    461                 //Then erase the file. 
    462                 method.Erase(strm, long.MaxValue, 
    463                     PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng), 
    464                     callback 
    465                 ); 
    466  
    467                 //Set the length of the file to 0. 
    468                 strm.Seek(0, SeekOrigin.Begin); 
    469                 strm.SetLength(0); 
    470             } 
    471         } 
    472  
    473         protected override DateTime MinTimestamp 
    474         { 
    475             get 
    476             { 
    477                 return new DateTime(1601, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); 
    478             } 
    479         } 
    480     } 
    481  
    482     /// <summary> 
    483     /// Provides functions to handle erasures specific to FAT volumes. 
    484     /// </summary> 
    485     public class FatFileSystem : WindowsFileSystem 
    486     { 
    487         public override bool Supports(string fileSystemName) 
    488         { 
    489             if (fileSystemName == "FAT" || fileSystemName == "FAT32") 
    490                 return true; 
    491             return false; 
    492         } 
    493  
    494         public override void EraseOldFileSystemResidentFiles(VolumeInfo volume, 
    495             DirectoryInfo tempDirectory, ErasureMethod method, 
    496             FileSystemEntriesEraseProgress callback) 
    497         { 
    498             //Nothing to be done here. FAT doesn't store files in its FAT. 
    499         } 
    500  
    501         public override void EraseDirectoryStructures(VolumeInfo info, 
    502             FileSystemEntriesEraseProgress callback) 
    503         { 
    504             Fat32Api api = new Fat32Api(info); 
    505         } 
    506  
    507         public override void EraseFileSystemObject(StreamInfo info, ErasureMethod method, 
    508             ErasureMethodProgressFunction callback) 
    509         { 
    510             //Create the file stream, and call the erasure method to write to 
    511             //the stream. 
    512             long fileArea = GetFileArea(info.FullName); 
    513             using (FileStream strm = info.Open(FileMode.Open, FileAccess.Write, 
    514                 FileShare.None, FileOptions.WriteThrough)) 
    515             { 
    516                 //Set the end of the stream after the wrap-round the cluster size 
    517                 strm.SetLength(fileArea); 
    518  
    519                 //If the stream is empty, there's nothing to overwrite. Continue 
    520                 //to the next entry 
    521                 if (strm.Length != 0) 
    522                 { 
    523                     //Then erase the file. 
    524                     method.Erase(strm, long.MaxValue, 
    525                         PrngManager.GetInstance(ManagerLibrary.Settings.ActivePrng), 
    526                         callback 
    527                     ); 
    528                 } 
    529  
    530                 //Set the length of the file to 0. 
    531                 strm.Seek(0, SeekOrigin.Begin); 
    532                 strm.SetLength(0); 
    533             } 
    534         } 
    535  
    536         protected override DateTime MinTimestamp 
    537         { 
    538             get 
    539             { 
    540                 return new DateTime(1980, 1, 1, 0, 0, 0); 
    541             } 
    542         } 
    543     } 
    544312} 

  • trunk/eraser6/Eraser.DefaultPlugins/Plugin.cs

    r1209 r1210  
    5656            PrngManager.Register(new RngCrypto()); 
    5757 
    58             FileSystemManager.Register(new FatFileSystem()); 
     58            FileSystemManager.Register(new Fat32FileSystem()); 
    5959            FileSystemManager.Register(new NtfsFileSystem()); 
    6060        } 
Note: See TracChangeset for help on using the changeset viewer.