Perhaps I’ll post that, however for now here is the class that does the work.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Security.Cryptography;

namespace SecureDelete
{
    public class Delete
    {
        public void deleteFile(string filename, int totalPasses = 2)
        {
            try
            {
                if (File.Exists(filename))
                {
                    // RNG
                    RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
                    
                    // init our dummy sector buffer
                    byte[] buffer = new byte[512];

                    // can we read / write the file?
                    File.SetAttributes(filename, FileAttributes.Normal);

                    // calculate our file sectors
                    double totalSectors = Math.Ceiling(new FileInfo(filename).Length / 512.0);

                    // open the file
                    FileStream inputStream = new FileStream(filename, FileMode.Open);
                    
                    // write with random data
                    for (int currentPass = 0; currentPass < totalPasses; currentPass++)
                    {
                        // update the pass info
                        UpdatePassInfo(currentPass + 1, totalPasses);

                        // align to start of file
                        inputStream.Position = 0;

                        // loop all sectors
                        for (int sectorsWritten = 0; sectorsWritten < totalSectors; sectorsWritten++)
                        {
                            // update sector info
                            UpdateSectorInfo(sectorsWritten + 1, (int)totalSectors);

                            // fill buffer with random data
                            rng.GetBytes(buffer);

                            // write it to file
                            inputStream.Write(buffer, 0, buffer.Length);
                        }
                    }

                    // added
                    inputStream.SetLength(0);

                    // close input
                    inputStream.Close();

                    // value added
                    DateTime d = new DateTime(2099, 1, 1, 1, 1, 0);
                    DateTime dt = new DateTime(2037, 1, 1, 0, 0, 0);
                    File.SetCreationTime(filename, dt);
                    File.SetLastAccessTime(filename, dt);
                    File.SetLastWriteTime(filename, dt);

                    File.SetCreationTimeUtc(filename, dt);
                    File.SetLastAccessTimeUtc(filename, dt);
                    File.SetLastWriteTimeUtc(filename, dt);
                    
                    // delete the file
                    File.Delete(filename);

                    // call the done event
                    DeleteDone();
                }
            }
            catch(Exception e)
            {
                DeleteError(e);
            }
        }

    #region Events 
        
        public event PassInfoEventHandler PassInfoEvent;

        private void UpdatePassInfo(int currentPass, int totalPasses)
        {
            PassInfoEvent(new PassInfoEventArgs(currentPass, totalPasses));
        }

        public event SectorInfoEventHandler SectorInfoEvent;
        private void UpdateSectorInfo(int currentSector, int totalSectors)
        {
            SectorInfoEvent(new SectorInfoEventArgs(currentSector, totalSectors));
        }

        public event DeleteDoneEventHandler DeleteDoneEvent;
        private void DeleteDone()
        {
            DeleteDoneEvent(new DeleteDoneEventArgs());
        }

        public event DeleteErrorEventHandler DeleteErrorEvent;
        private void DeleteError(Exception e)
        {
            DeleteErrorEvent(new DeleteErrorEventArgs(e));
        }

    #endregion

    #region PassInfo

        public delegate void PassInfoEventHandler(PassInfoEventArgs e);
        
        public class PassInfoEventArgs : EventArgs
        {
            private readonly int cPass;
            private readonly int tPass;

            public PassInfoEventArgs(int currentPass, int totalPasses)
            {
                cPass = currentPass;
                tPass = totalPasses;
            }

            public int CurrentPass { get { return cPass; } }

            public int TotalPasses { get { return tPass; } }
        }

    #endregion

    #region SectorInfo
    
        public delegate void SectorInfoEventHandler(SectorInfoEventArgs e);
        
        public class SectorInfoEventArgs : EventArgs
        {
            private readonly int cSector;
            private readonly int tSectors;

            public SectorInfoEventArgs(int currentSector, int totalSectors)
            {
                cSector = currentSector;
                tSectors = totalSectors;
            }

            public int CurrentSector { get { return cSector; } }

            public int TotalSectors { get { return tSectors; } }
        }

    #endregion

    #region DeleteDone

        public delegate void DeleteDoneEventHandler(DeleteDoneEventArgs e);
        
        public class DeleteDoneEventArgs : EventArgs { }
        
    #endregion

    #region DeleteError

        public delegate void DeleteErrorEventHandler(DeleteErrorEventArgs e);
        
        public class DeleteErrorEventArgs : EventArgs
        {
            private readonly Exception e;

            public DeleteErrorEventArgs(Exception error) { e = error; }

            public Exception WipeError { get { return e; } }
        }

    #endregion

    }
}

This has been tested on Xshell v5, after a quick look, it appears that version 6 is now available and I have no idea if this will work on the newer version. Regardless here is the app for download.

Binaries:

Download “xDEC v1.0” xdec.v1.0.zip – Downloaded 88 times – 40 KB

Source:

Download “xDEC v1.0 Src” xdec.v1.src_.zip – Downloaded 68 times – 50 KB

So I will be posting stuff I here and hopefully keeping it… somewhat… updated.