Q:

C# Bad PKCS7 Padding

I have been getting said error when trying to implement DES encryption and decryption (Although my code allows for different implementations)
I have done a lot of research on this and have found several similar questions, here on Stack Overflow, however the answer's they provide are to ensure the Key and IV are identical on the encryption and decryption process, I seem to already have implemented this, so it seems as if the root of the issue lies elsewhere. 
The following is my code, the exception is thrown on line #164
namespace xNFCE
{
    public class Crypto
    {

        public enum cryptype
        {
            DES,
            THREEDES,
            AES
        };

        // Variables for the file input, output and the password to encrypt the file
        string _input, _output;
        byte[] _password;
        cryptype _type;

        /// <summary>
        /// Initializes a new instance of the <see cref="xNFCE.Crypto"/> class. 
        /// </summary>
        /// <param name="input">Input.</param>
        /// <param name="output">Output.</param>
        /// <param name="password">Password.</param>
        public Crypto(string input, string output, string password, cryptype type = cryptype. AES)
        {
            // Set the properties for the encryption
            _input = input;
            _output = output;
            _password = hash(password);
            _type = type;
        }

        /// <summary>
        /// Run the appropriate encryption function
        /// </summary>
        public void Encrypt()
        {
            switch (_type)
            {
                case cryptype. DES:
                    DESenc();
                    break;
                case cryptype. THREEDES:
                    // TODO Implement
                    throw new NotImplementedException();
                case cryptype. AES:
                    // TODO Implement
                    throw new NotImplementedException();
            }
        }

        /// <summary>
        /// Run the appropriate decryption function
        /// </summary>
        public void Decrypt()
        {
            switch (_type)
            {
                case cryptype. DES:
                    DESdec();
                    break;
                case cryptype. THREEDES:
                    // TODO Implement
                    throw new NotImplementedException();
                case cryptype. AES:
                    // TODO Implement
                    throw new NotImplementedException();
            }
        }

        /// <summary>
        /// Hash the password and return it as a byte array
        /// </summary>
        /// <param name="pwd">Pwd.</param>
        byte[] hash(String pwd)
        {
            // System. Text provides .GetBytes() this converts a string to the series of bytes
            // Convert the password string to an array of bytes
            byte[] bytes = Encoding. ASCII.GetBytes(pwd);
            // Create an instance of Managed SHA256
            SHA256Managed hashman = new SHA256Managed();
            // Hash the array of bytes
            byte[] hash = hashman. ComputeHash(bytes);
            return hash;
        }

         /// <summary>
         /// This function is called when the user wants to encrypt a file
         /// </summary>
        void DESenc()
        {   
            // Create file streams for the input and output of the files
            FileStream fileInput = new FileStream(_input, FileMode. Open, FileAccess. Read);
            // Append the xNFCE extension to the output
            FileStream fileEncrypted = new FileStream(_output + GlobalValues.fextension, FileMode. Create, FileAccess. Write);

            // Declare an insrance of the DESCryptoServiceProvider class
            // This represents the actual encryption and decryption technology that is used on the files
            // Other cryptographic techniques can be used here
            // TODO implement other encryption techniques
            DESCryptoServiceProvider DES = new DESCryptoServiceProvider();

            // Each cryptographic technique takes a different syze key, DES takes a 64Bit key which is 8 Bytes (8 Characters)
            // If we do not provide a key and IV here, they are randomly generated, meaning we cannot decrypt the file
            // Take the first 8 bytes from the password
            DES.Key = _password. Take(8).ToArray();
            DES.IV =  _password. Take(8).ToArray();

            // Cretae an instance of the CryptoStream class by using the cryptographic prover to obtain an encrypting object
            // and the existing output filestream as part of the constructor. 
            ICryptoTransform desencrypt = DES.CreateEncryptor();
            CryptoStream cryptostream = new CryptoStream(fileEncrypted, desencrypt, CryptoStreamMode. Write);

            // Read in the input file and write to the output file while passing through the crypto stream object using the password provided
            byte[] bytearrayinput = new byte[fileInput. Length - 1];
            fileInput. Read(bytearrayinput, 0, bytearrayinput. Length);
            cryptostream. Write(bytearrayinput, 0, bytearrayinput. Length);
        }

        /// <summary>
        /// This function is called when the user wants to decrypt a file
        /// </summary>
        void DESdec()
        {
            // This function has two key differences from the encrypt function
            // CreateDecryptor is used instead of CreateEncryptor to create the crypto stream object
            // When the decrypted text is written to the destination file, the CryptoStream object is now the source isntead of the destination stream
            DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
            // Take the first 8 bytes from the password
            DES.Key = _password. Take(8).ToArray();
            DES.IV =  _password. Take(8).ToArray();

            // Create the file stream to read the encrypted file back
            FileStream fileInput = new FileStream(_input, FileMode. Open, FileAccess. Read);
            // Create a DES decryptor
            ICryptoTransform desdecrypt = DES.CreateDecryptor();
            // Create a crypto stream set to read and do a decryption transform on incoming bytes
            CryptoStream cryptostream = new CryptoStream(fileInput, desdecrypt, CryptoStreamMode. Read);

            // Print the contents of the decrypted file
            FileInfo fi = new FileInfo(_output);
            string writename = Path. Combine(fi. DirectoryName, Path. GetFileNameWithoutExtension(_output));
            StreamWriter fsDecrypted = new StreamWriter(writename);
            fsDecrypted. Write(new StreamReader(cryptostream).ReadToEnd());
            fsDecrypted. Flush();
            fsDecrypted. Close();
        }

    }
}

Note:I am using Xamarin. Android for this but I don't believe that it's relevant
Thanks! :) 

A:

The issue is that the encrypted file will be empty, so you subsequently attempt to decrypt an empty string which will fail. 
The file is empty because the CryptoStream is never flushed to disk. 
This is related to the fact that you are not disposing of anything, you need to go back and add a using () {} clause to anything that implements IDisposable (doing this for a CryptoStream will flush it correctly). 
As a minimum:
using (CryptoStream cryptostream = new CryptoStream(fileEncrypted, desencrypt, CryptoStreamMode. Write))
{
    // Read in the input file and write to the output file while passing through the crypto stream object using the password provided
    byte[] bytearrayinput = new byte[fileInput. Length - 1];
    fileInput. Read(bytearrayinput, 0, bytearrayinput. Length);

    cryptostream. Write(bytearrayinput, 0, bytearrayinput. Length);
}

Would cause your program to behave as expected. ( but still leak elsewhere). 
(Don't use the same value for key and iv)

