Cómo implementar el cifrado y descifrado DES usando C#

Usar System.Collections.Generic;

Usar System.Linq;

Usar System.Text;

Usar Sistema .Seguridad.Criptografía;

¿Espacio de nombres?

usando?System.Security.Cryptography;

espacio de nombres?Sens.Security

{

#region?lt;class?- ?hDESgt;

clase?HDES

{

#región?privada?campo

//? resumengt;

//?Algoritmo de cifrado de claves, el valor predeterminado es SHA1

//?lt;/summarygt;

private?HashAlgorithm?KeyHash;

privado?Listlt; intgt;?supportedKeySize;

privado?Codificación?_ codificación?=?Encoding.Default;

privado?des;

#endregion

#region?Constructor

public?HDES(string?key, ?DES?des)

{

si ? (des?==?null)

throw?new?Exception("des no puede ser nulo");

else

this.des?=? des;

if?IsNullOrEmpty(key))

throw?new?Exception("La clave no puede ser nula");

//Obtener la longitud de la clave admitida

this.supportedKeySize?=?new?Listlt;intgt;(SupportedKeySize);

/?Inicializa el método de cifrado de clave predeterminado

this . KeyHash?=?SHA1.Create();

this.StringKey?=?key;

}

#endregion

# región?Propiedades públicas

//?lt;Summarygt;

//?Métodos para obtener o configurar la codificación de texto

//?lt;/ resumengt;

public?Encoding?encoding

{

set?{_encoding?=?value?==?nullEncoding.Default?：?value;? /p>

obtener?

obtener?

}

//? lt；summarygt;

// ?Establecer clave por cadena

//?lt;/summarygt;

public?stringKey

{

set

{

si

(string.IsNullOrEmpty(valor))

throw?new?Exception("La clave no puede ser nula");

byte[]?keyHash?=?KeyHash.ComputeHash(encoding. GetBytes(valor));

byte[]?tmp?=?new?byte[8];

for?(int?i?=?0;?i?lt ;?8;?i )

{

tmp[i]?=?keyHash[i];

}

esto .Key?=?tmp;

para?8]? =?keyHash[i];

}

este.IV?=?tmp;

}

}

}

//?lt；summarygt;

//?

//?lt;/summarygt;

public?byte[]?Key

{

conjunto

{

if?(!supportedKeySize.Contains(valor.

if (!supportedKeySize.Contains(valor.KeySize))

obtener{?return?this. Clave;?}

get{?return?this.Key;?｝

}

//? resumengt;

//?Establecer el vector de inicialización del algoritmo de cifrado simétrico

//? lt;/summarygt;

public?byte[]?IV

{

establecer

{

if?(!supportedKeySize.Contains(value.Length?*?8))

throw?new ?Excepción ("Longitud de vector incorrecta");

this.des.IV?=?value;

}

get{?return?this.IV ;? ｝

}

/? lt; resumengt;

//?Obtener el tamaño de la clave

//? ;/summarygt ;

public?int?KeySize

{

get?{?return?des.KeySize;?｝

}

//?lt;summarygt;

//?Obtener tamaños de clave admitidos

//?lt;/summarygt;

público?KeySizes[]?LegalKeySizes

{

obtener?{?return?des.LegalKeySizes;?}

}

/ /?lt;summarygt;

//?Obtener tamaños de bloque admitidos

//?lt;/summarygt;

public?KeySizes[]?LegalBlockSizes

{

obtener?{?return?des.LegalBlockSizes;?}

p>}

//?lt;summarygt;

//?Obtenga los tamaños de clave admitidos

//?lt;/summarygt;

public?int[]?SupportedKeySize

{

get

{

Listlt;intgt;?tmp?= ?new?Listlt;intgt;();

int?step?=?0;

foreach?(KeySizes?item?in?des.LegalKeySizes)

{

si?(item.SkipSize?==?0)

si?(item.MaxSize?==?item.MinSize)

paso?=?item.MaxSize;

else

paso?=?item.MaxSize?-?item.MinSize;

else

paso?=?item.SkipSize;

for(int?i?=?item.MinSize;?i?lt;=?item.MaxSize;?i? =?paso )

{

if?Agregar (i);

}

}

return?tmp. ToArray();

}

}

#endregion

#region?Cadena cifrada

/ / ?lt;/summarygt;

//?lt;param?name="scr"gt;lt;/paramgt;

//?lt;returnsgt;lt;/ returnsgt ;

public?string?EncryptString(string?

{

MemoryStream?ms?=?new?MemoryStream();

CryptoStream?cs?=?new?CryptoStream(ms,?des.CreateEncryptor(),?CryptoStreamMode.Write);

byte[]?inputByteArray=?encoding.GetBytes(scr) ;

cs.Write(inputByteArray,?0,?inputByteArray.Length);

cs.FlushFinalBlock();

StringBuilder?ret?=?new ? StringBuilder();

foreach?(byte?b?in?ms.ToArray())

{

ret.AppendFormat("{0： X2 }",?b);

}

return?ret.ToString();

//?lt; resumengt;

//?Descifrar cadena

//? lt;/summarygt;

//? lt;param?name="scr"gt;lt;/paramgt;

//?lt;returnsgt;lt;/returns

gt;

public?string?DecryptString(string?scr)

{

byte[]?inputByteArray?=?new?byte[scr.Length? /?2];

for?(System.Convert.ToInt32(scr.Substring(x?*?2,?2),?16));

inputByteArray[x ]? =?(byte)i;

}

MemoryStream?ms?=?new?MemoryStream();

CryptoStream?cs?=? ?CryptoStream(ms,?des.CreateDecryptor(),?CryptoStreamMode.Write);

cs.Write(inputByteArray,?0,?inputByteArray.Length);

cs. ();

StringBuilder?ret?=?new?StringBuilder();

return?encoding.GetString(ms.ToArray());

}

#endregion

#region?Cifrando y descifrando el archivo

//?lt；summarygt;

//?Encryption File

//?lt;/summarygt;

//?lt;param?name="filePath"gt;La ubicación del archivo que se va a cifrarlt;/paramgt;

//?lt;param?name="filePath"gt;La ubicación del archivo que se va a cifrarlt;/paramgt;

p>

//?name="savePath "gt;La ubicación donde se guarda el archivo cifradolt;/paramgt;

//? lt;returnsgt;lt;/returnsgt;

public?bool?EncryptFile(string?filePath , string?savePath)

{

FileStream?fs?=?File .OpenRead(filePath);

byte[]?inputByteArray?=?new? byte[fs.Length];

fs?=?File.OpenWrite(savePath);

foreach?(byte?b? in?ms.ToArray())

{

fs.WriteByte(b);

}

fs.Close( ) ;

cs.Close ();

ms.Close();

return?true;

}

//?lt;summarygt;

//?Descifrar archivo

//?lt;/summarygt;

//?lt;param ?name="filePath"gt;Archivo a ser decryptedlt;/paramgt;

//?name="savePath"gt;Ubicación donde guardar después de decryptionlt;/paramgt;

//?lt;par

am?name="keyStr"gt;lt;/paramgt;

//? lt;returnsgt;lt;/returnsgt;

public?bool?DecryptFile(string?filePath, ?string?savePath)

{

FileStream?fs?=?File .OpenRead(filePath);

byte[]?inputByteArray?=?new? byte[fs.Length];

fs?=?File.OpenWrite(savePath);

foreach?ToArray())

{

fs.WriteByte(b);

}

fs.Close();

cs.Close();

ms.Close();

¿regresar?