/// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
/// <param name="cryptProvider">Tipo de criptografia.</param>
public Criptografia(CryptProvider cryptProvider)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
_algorithm = new RijndaelManaged();
_cryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
_algorithm = new RC2CryptoServiceProvider();
_cryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
_algorithm = new DESCryptoServiceProvider();
_cryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider();
_cryptProvider = CryptProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public Criptografia()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
_key = "KPT873KL23DF90WI5E1JAS467NMCXXL6JAOAUWLTQNTAOMM4A492EQ3KHJUI2347EJHJKDF3424SKLCK3LAKDJSL9RTIKJ";
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public CryptService(CryptProvider cryptProvider)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
algoritmo = new RijndaelManaged();
provider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
algoritmo = new RC2CryptoServiceProvider();
provider = CryptProvider.RC2;
break;
case CryptProvider.DES:
algoritmo = new DESCryptoServiceProvider();
provider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
algoritmo = new TripleDESCryptoServiceProvider();
provider = CryptProvider.TripleDES;
break;
}
algoritmo.Mode = CipherMode.CBC;
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public CriptografiaServices()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
_key = RegistroLocalService.BuscarChaveServico();
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
/// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
/// <param name="FilePath">Caminho completo do arquivo a ser encriptado.</param>
/// <param name="Descriptografar">Quando setado como true, informa à classe que não é para
/// criptografar o arquivo, e sim descriptografá-lo.</param>
public SkaEncrypt(CryptProvider cryptProvider, String ChaveSimetrica, String FilePath, Boolean Descriptografar = false)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
_algorithm = new RijndaelManaged();
_cryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
_algorithm = new RC2CryptoServiceProvider();
_cryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
_algorithm = new DESCryptoServiceProvider();
_cryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider();
_cryptProvider = CryptProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
_key = ChaveSimetrica;
_filePath = FilePath;
if (!Descriptografar)
{
EncriptarArquivo();
}
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
/// </summary>
public Criptografia(string key)
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
this._key = key.ToString();// ConfigurationManager.AppSettings["CriptoKey"].ToString();//.Substring(0, 8);
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public Criptografia(CryptProvider cryptProvider, string key)
{
// Seleciona algoritmo simétrico
//this._key = ConfigurationManager.AppSettings["CriptoKey"].ToString();//.Substring(0, 8);
this._key = key.ToString();
switch (cryptProvider)
{
case CryptProvider.Rijndael:
_algorithm = new RijndaelManaged();
_cryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
_algorithm = new RC2CryptoServiceProvider();
_cryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
_algorithm = new DESCryptoServiceProvider();
_cryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider();
_cryptProvider = CryptProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
/// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
/// <param name="FilePath">Caminho completo do arquivo a ser encriptado.</param>
/// <param name="Descriptografar">Quando setado como true, informa à classe que não é para
/// criptografar o arquivo, e sim descriptografá-lo.</param>
public CustomEncrypt(CryptProvider cryptProvider, String ChaveSimetrica, String FilePath, Boolean Descriptografar = false)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
mAlgorithm = new RijndaelManaged();
mCryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
mAlgorithm = new RC2CryptoServiceProvider();
mCryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
mAlgorithm = new DESCryptoServiceProvider();
mCryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
mAlgorithm = new TripleDESCryptoServiceProvider();
mCryptProvider = CryptProvider.TripleDES;
break;
}
mAlgorithm.Mode = CipherMode.CBC;
mKey = ChaveSimetrica;
mFilePath = FilePath;
if (!Descriptografar)
{
EncryptFile();
}
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public HelperCrypt()
{
_algorithm = new RijndaelManaged {
Mode = CipherMode.CBC
};
_cryptProvider = CryptProvider.Rijndael;
}
/// <summary>
/// Construtor utilizando apenas para criptografar textos (sem arquivos físicos).
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
/// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
public CustomEncrypt(CryptProvider cryptProvider, String ChaveSimetrica)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
mAlgorithm = new RijndaelManaged();
mCryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
mAlgorithm = new RC2CryptoServiceProvider();
mCryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
mAlgorithm = new DESCryptoServiceProvider();
mCryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
mAlgorithm = new TripleDESCryptoServiceProvider();
mCryptProvider = CryptProvider.TripleDES;
break;
}
mAlgorithm.Mode = CipherMode.CBC;
mKey = ChaveSimetrica;
mFilePath = "";
}
public CryptHelpers(CryptProvider cryptProvider = CryptProvider.Rijndael)
{
switch (cryptProvider)
{
case CryptProvider.Rijndael:
_algorithm = new RijndaelManaged();
_cryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
_algorithm = new RC2CryptoServiceProvider();
_cryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
_algorithm = new DESCryptoServiceProvider();
_cryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider();
_cryptProvider = CryptProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
}
public Cryptography(CryptProvider provider, String key)
{
this.Provider = provider;
switch (provider)
{
case CryptProvider.DES:
break;
case CryptProvider.RC2:
break;
case CryptProvider.TripleDES:
break;
case CryptProvider.MD5:
break;
case CryptProvider.Rijndael:
this.Algorithm = new RijndaelManaged();
this.Algorithm.Mode = CipherMode.CBC;
this.Algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };
break;
}
this.Key = GetKey(key);
this.Algorithm.Key = this.Key;
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public Cryptography( CryptProvider cryptProvider )
{
// Seleciona algoritmo simétrico
switch ( cryptProvider )
{
case CryptProvider.Rijndael:
_algorithm = new RijndaelManaged ( );
_cryptProvider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
_algorithm = new RC2CryptoServiceProvider ( );
_cryptProvider = CryptProvider.RC2;
break;
case CryptProvider.DES:
_algorithm = new DESCryptoServiceProvider ( );
_cryptProvider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider ( );
_cryptProvider = CryptProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
}
/// <summary> Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael). </summary>
public Cripto(string key)
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
_key = key;
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
/// </summary>
public Crypt()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
Key = "WebEleitor1234/";
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public Crypt(CryptProvider cryptProvider)
{
// Seleciona algoritmo simétrico
/*switch (cryptProvider) - MÃO DE FERNANDO PASSAIA AQUI, GAMBIARRA
*
* case CryptProvider.Rijndael:
*
* break;
* case CryptProvider.RC2:
* _algorithm = new RC2CryptoServiceProvider();
* _cryptProvider = CryptProvider.RC2;
* break;
* case CryptProvider.DES:
* _algorithm = new DESCryptoServiceProvider();
* _cryptProvider = CryptProvider.DES;
* break;
* case CryptProvider.TripleDES:
* _algorithm = new TripleDESCryptoServiceProvider();
* _cryptProvider = CryptProvider.TripleDES;
* break;
* }*/
_algorithm = new RijndaelManaged();
_cryptProvider = CryptProvider.Rijndael;
_algorithm.Mode = CipherMode.CBC;
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public CryptService(CryptProvider cryptProvider)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptProvider.Rijndael:
algoritmo = new RijndaelManaged();
provider = CryptProvider.Rijndael;
break;
case CryptProvider.RC2:
algoritmo = new RC2CryptoServiceProvider();
provider = CryptProvider.RC2;
break;
case CryptProvider.DES:
algoritmo = new DESCryptoServiceProvider();
provider = CryptProvider.DES;
break;
case CryptProvider.TripleDES:
algoritmo = new TripleDESCryptoServiceProvider();
provider = CryptProvider.TripleDES;
break;
}
algoritmo.Mode = CipherMode.CBC;
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public Criptografia()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public Criptografia()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
}
private void checkedChanged(object sender, EventArgs e)
{
var rb = (RadioButton)sender;
var index = int.Parse(rb.Tag.ToString());
if (rb.Checked)
{
providerSelecionado = (CryptProvider)index;
}
}
public string Authenticate(string userName, string password)
{
var account = AccountRepository.Get(userName);
if (account != null)
{
if (account.ValidatePassword(CryptProvider, password))
{
return(CryptProvider.Encrypt(account.CreateToken().GenerateString(DateProvider)));
}
}
return(string.Empty);
}
private static void Constructor()
{
if (_algorithm == null)
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
}
if (_cryptProvider == CryptProvider.None)
{
_cryptProvider = CryptProvider.Rijndael;
}
}
public xml_request(string DecryptKey, string string_request)
{
try
{
_isvalid = false;
// xâu rỗng đưa vào
if (String.IsNullOrEmpty(string_request))
{
return;
}
CryptProvider myde = new CryptProvider();
// giải mã xâu
source = myde.Decrypt(DecryptKey, string_request);
// chuyển thành các đối tượng
doc.LoadXml(source.Trim());
_isvalid = true;
}
catch (Exception ex)
{ throw ex; }
}
public Token Validate(string token)
{
return(new TokenParser(CryptProvider.Decrypt(token)).GetToken());
}
// ----------------------------------------------------------------------------------------------------
#region Constructors
/// <summary>Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).</summary>
public CryptService()
{
algoritmo = new RijndaelManaged();
algoritmo.Mode = CipherMode.CBC;
provider = CryptProvider.Rijndael;
}
public static bool CryptAcquireContext(ref IntPtr hProv, string pszContainer, string pszProvider, CryptProvider prov, ContextFlags flags) => CryptAcquireContext(ref hProv, pszContainer, pszProvider, (uint) prov, (uint) flags);
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
/// </summary>
public Encryptar()
{
_algorithm = new RijndaelManaged();
_algorithm.Mode = CipherMode.CBC;
_cryptProvider = CryptProvider.Rijndael;
}
public string response_string(string key)
{
CryptProvider myen = new CryptProvider();
return(myen.Encrypt(key, response_string()));
}
public User()
{
myCrypt = new CryptProvider();
}
// ----------------------------------------------------------------------------------------------------
#region Constructors
/// <summary>Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).</summary>
public CryptService()
{
algorithm = new RijndaelManaged();
algorithm.Mode = CipherMode.CBC;
provider = CryptProvider.Rijndael;
}
public Descriptografia NoMetodo(CryptProvider mode)
{
this._mode = mode;
return(this);
}
/// <summary>
/// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
/// </summary>
public ServicoDeCriptografia()
{
algorithm = new RijndaelManaged();
algorithm.Mode = CipherMode.CBC;
cryptProvider = CryptProvider.Rijndael;
}
