public void Dispose()
{
_decryptor?.Dispose();
_encryptor?.Dispose();
_symmetricAlgorithm.Dispose();
}
public override void Close()
{
cryptoStream.Dispose();
stream.Dispose();
symmetricAlgorithm.Dispose();
cryptoTransform.Dispose();
}
public void Dispose()
{
if (symmetric != null)
{
symmetric.Dispose();
}
}
protected virtual SymmetricAlgorithm CreateAlgorithm(ApplicationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
SymmetricAlgorithm alg = null;
try
{
alg = CreateAlgorithmImpl(context);
var salt = GetSaltBytes(context);
using (var pbkdf2 = new Rfc2898DeriveBytes(context.Secret, salt, DefaultIterationsCount))
{
alg.Key = pbkdf2.GetBytes(32);
alg.IV = pbkdf2.GetBytes(16);
}
return(alg);
}
catch (Exception)
{
alg?.Dispose();
throw;
}
}
public void Dispose()
{
if (algorithm != null)
{
algorithm.Dispose();
}
}
public void Dispose()
{
if (m_decryptionBulkAlgorithm != null)
{
m_decryptionBulkAlgorithm.Dispose();
m_decryptionBulkAlgorithm = null;
}
if (m_encryptionBulkAlgorithm != null)
{
m_encryptionBulkAlgorithm.Dispose();
m_encryptionBulkAlgorithm = null;
}
if (m_decryptionHMAC != null)
{
m_decryptionHMAC.Dispose();
m_decryptionHMAC = null;
}
if (m_encryptionHMAC != null)
{
m_encryptionHMAC.Dispose();
m_encryptionHMAC = null;
}
if (PRF != null)
{
PRF.Dispose();
PRF = null;
}
}
private static byte[] CryptoTransform(
string fileName, CryptoTransformOperationsEnum operation, SymmetricAlgorithm algo)
{
byte[] orignalFile = File.ReadAllBytes(fileName);
byte[] processedFile;
ICryptoTransform cryptoTransform;
switch (operation)
{
case CryptoTransformOperationsEnum.Encrypt:
cryptoTransform = algo.CreateEncryptor();
break;
case CryptoTransformOperationsEnum.Decrypt:
cryptoTransform = algo.CreateDecryptor();
break;
default:
throw new Exception();
}
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write))
{
cryptoStream.Write(orignalFile, 0, orignalFile.Length);
}
algo.Dispose();
processedFile = memoryStream.ToArray();
}
return(processedFile);
}
public void Dispose()
{
#if TSS_USE_BCRYPT
Key.Dispose();
#else
Alg.Dispose();
#endif
}
private void Dispose(bool Disposing)
{
if (!_disposed)
{
_symAlgo.Dispose();
_disposed = true;
}
}
public void Release()
{
IsReleased = true;
//_hashAlgorithm.Clear();
//_symmetricAlgorithm.Clear();
_hashAlgorithm.Clear();
_symmetricAlgorithm.Dispose();
}
public static void ReleaseSymmetricAlgorithm(this CryptoProviderFactory _, SymmetricAlgorithm symmetricAlgorithm)
{
if (symmetricAlgorithm == null)
{
throw LogHelper.LogArgumentNullException(nameof(symmetricAlgorithm));
}
symmetricAlgorithm.Dispose();
}
public void Dispose()
{
#if !SILVERLIGHT
if (algorithm != null)
{
algorithm.Dispose();
}
#endif
}
public void Dispose()
{
if (mCryptoService != null)
{
mCryptoService.Dispose();
mCryptoService = null;
}
GC.SuppressFinalize(this);
}
public void Teardown()
{
if (algorithm != null)
{
algorithm.Dispose();
}
mKey = null;
mIv = null;
}
public void Dispose()
{
_encryptor?.Dispose();
_decryptor?.Dispose();
if (_disposeAlgorithm)
{
_algorithm.Dispose();
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed == false)
{
_disposed = true;
if (disposing == true)
{
control.Dispose();
}
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_symmetricAlgorithm.Dispose();
}
disposedValue = true;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (encrypto != null)
{
encrypto.Dispose();
encrypto = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
blow.Dispose();
}
DisposeHelper.OnDispose <BlowfishCryptoProvider>(disposing);
disposed = true;
}
}
public void TestMethod(byte[] key, byte[] someOtherBytesForIV)
{
string someHardCodedBase64String = "sssdsdsdsdsdsds" +
"sdasdsadasddsda" +
"sdasdsadasddsda";
A();
B();
SymmetricAlgorithm rijn = SymmetricAlgorithm.Create();
rijn.CreateEncryptor(key, someOtherBytesForIV);
rijn.Dispose();
}
/// <summary>
/// Releases the unmanaged resources used by the <c>EncryptionReader</c> class and optionally
/// releases the managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
/// <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!disposed)
{
disposed = true;
if (disposing)
{
// Dispose managed objects
base.Dispose(true);
Decryptor.Dispose();
Algorithm.Dispose();
}
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// free managed resources
if (saltGenerator != null)
{
saltGenerator.Dispose();
}
if (algorithm != null)
{
algorithm.Dispose();
}
}
}
void IDisposable.Dispose()
{
if (mRawDataStream != null)
{
mRawDataStream.Dispose();
}
if (mAlgorithm != null)
{
mAlgorithm.Dispose();
}
if (mTransform != null)
{
mTransform.Dispose();
}
}
/// <summary>
/// Dispose of all contained resources.
/// </summary>
public void Dispose()
{
if (m_decryptionBulkAlgorithm != null)
{
#if NET40
m_decryptionBulkAlgorithm.Dispose();
#else
m_decryptionBulkAlgorithm.Clear();
#endif
m_decryptionBulkAlgorithm = null;
}
if (m_encryptionBulkAlgorithm != null)
{
#if NET40
m_encryptionBulkAlgorithm.Dispose();
#else
m_encryptionBulkAlgorithm.Clear();
#endif
m_encryptionBulkAlgorithm = null;
}
if (m_decryptionHMAC != null)
{
#if NET40
m_decryptionHMAC.Dispose();
#else
m_decryptionHMAC.Clear();
#endif
m_decryptionHMAC = null;
}
if (m_encryptionHMAC != null)
{
#if NET40
m_encryptionHMAC.Dispose();
#else
m_encryptionHMAC.Clear();
#endif
m_encryptionHMAC = null;
}
if (PRF != null)
{
PRF.Dispose();
PRF = null;
}
}
/// <summary>
/// Disposes of internal components.
/// </summary>
/// <param name="disposing">true, if called from Dispose(), false, if invoked inside a finalizer.</param>
protected override void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
if (_symmetricAlgorithm != null)
{
_symmetricAlgorithm.Dispose();
_symmetricAlgorithm = null;
}
_disposed = true;
}
}
}
// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be disposed.
// If disposing equals false, the method has been called by the
// runtime from inside the finalizer and you should not reference
// other objects. Only unmanaged resources can be disposed.
protected virtual void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Dispose managed resources.
_algorithm.Dispose();
}
// Note disposing has been done.
disposed = true;
}
}
private void btnEncodeText_Click(object sender, EventArgs e)
{
// legal sizes for AES Key = (128 to 256)/block size(currently 8), so 24*8=192
// legal sizes for AES IV = 128/block size(currently 8), so 16*8=128
// legal sizes for key in TripleDES is 128-192, IV seems to be mulitples of 8
baKeyString = Encoding.UTF8.GetBytes(txtKeyString.Text);
if (rbAES.Checked)
{
baIVstring = Encoding.UTF8.GetBytes(txtIVstring.Text.Substring(0, 16));
}
else if (rbTripleDES.Checked)
{
// seems to have the native ability to trim the string to what it wants
baIVstring = Encoding.UTF8.GetBytes(txtIVstring.Text);
}
SymmetricAlgorithm oAlgorithm = null;
if (rbTripleDES.Checked)
{
oAlgorithm = TripleDES.Create();
}
else if (rbAES.Checked)
{
oAlgorithm = Aes.Create();
}
ICryptoTransform oTransform = oAlgorithm.CreateEncryptor(baKeyString, baIVstring);
try
{
byte[] inputbuffer = Encoding.Unicode.GetBytes(txtInputString.Text);
outputbuffer = oTransform.TransformFinalBlock(inputbuffer, 0, inputbuffer.Length);
txtOutputString.Text = Convert.ToBase64String(outputbuffer);
}
catch (Exception e9)
{
MessageBox.Show(this, "Error encoding!\n" + e9.Message);
}
finally
{
oTransform.Dispose();
oTransform = null;
oAlgorithm.Clear();
oAlgorithm.Dispose();
oAlgorithm = null;
}
}
public override void Dispose(bool disposing)
{
if (disposing)
{
if (_cryptoAlgorithm != null)
{
_cryptoAlgorithm.Dispose();
_cryptoAlgorithm = null;
}
if (_encryptor != null)
{
_encryptor.Dispose();
_encryptor = null;
}
}
}
private void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (_symAlgo != null)
{
_symAlgo.Dispose();
}
}
_disposed = true;
}
