Untitled

mail@pastecode.io avatar
unknown
plain_text
2 years ago
12 kB
2
Indexable
Never
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Web;

/// <summary>
/// Descripción breve de Encriptar
/// </summary>
public class Encriptar
{

    private const String SECRET_KEY = "3614Nico3614Nico";//16 char secret key

    public  string DecryptIOS(string textToDecrypt)
    {
        return DecryptIOS(textToDecrypt, SECRET_KEY);
    }

    private  string DecryptIOS(string textToDecrypt, string key)
    {
        RijndaelManaged rijndaelCipher = new RijndaelManaged();
        rijndaelCipher.Mode = CipherMode.CBC;
        rijndaelCipher.Padding = PaddingMode.PKCS7;

        rijndaelCipher.KeySize = 0x80;
        rijndaelCipher.BlockSize = 0x80;
         byte[] encryptedData = Convert.FromBase64String(textToDecrypt);
       // byte[] encryptedData = Convert.FromHexString(textToDecrypt);
        byte[] pwdBytes = Encoding.UTF8.GetBytes(key);
        byte[] keyBytes = new byte[0x10];
        int len = pwdBytes.Length;
        if (len > keyBytes.Length)
        {
            len = keyBytes.Length;
        }
        Array.Copy(pwdBytes, keyBytes, len);
        rijndaelCipher.Key = keyBytes;
        rijndaelCipher.IV = keyBytes;
        byte[] plainText = rijndaelCipher.CreateDecryptor().TransformFinalBlock(encryptedData, 0, encryptedData.Length);
        return Encoding.UTF8.GetString(plainText);
    }

    public  string EncryptIOS(string textToEncrypt)
    {
        return EncryptIOS(textToEncrypt, SECRET_KEY);
    }

    private  string EncryptIOS(string textToEncrypt, string key)
    {
        RijndaelManaged rijndaelCipher = new RijndaelManaged();
        rijndaelCipher.Mode = CipherMode.CBC;
        rijndaelCipher.Padding = PaddingMode.PKCS7;

        rijndaelCipher.KeySize = 0x80;
        rijndaelCipher.BlockSize = 0x80;
        byte[] pwdBytes = Encoding.UTF8.GetBytes(key);
        byte[] keyBytes = new byte[0x10];
        int len = pwdBytes.Length;
        if (len > keyBytes.Length)
        {
            len = keyBytes.Length;
        }
        Array.Copy(pwdBytes, keyBytes, len);
        rijndaelCipher.Key = keyBytes;
        rijndaelCipher.IV = keyBytes;
        ICryptoTransform transform = rijndaelCipher.CreateEncryptor();
        byte[] plainText = Encoding.UTF8.GetBytes(textToEncrypt);
        return Convert.ToBase64String(transform.TransformFinalBlock(plainText, 0, plainText.Length));
    }

    public   string Encrypt(string plainText)
    {

        string passPhrase = "Pas5pr@se"; // can be any string
        string saltValue = "s@1tValue"; // can be any string
        string hashAlgorithm = "SHA1"; // can be "MD5"
        int passwordIterations = 2; // can be any number
        string initVector = "@1B2c3D4e5F6g7H8"; // must be 16 bytes
        int keySize = 192;
        byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);

        string s = "[cód_ provincia]";

        byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

        byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

        PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);

        byte[] keyBytes = password.GetBytes(keySize / 8);

        // Create uninitialized Rijndael encryption object.
        RijndaelManaged symmetricKey = new RijndaelManaged();

        // It is reasonable to set encryption mode to Cipher Block Chaining
        // (CBC). Use default options for other symmetric key parameters.
        symmetricKey.Mode = CipherMode.CBC;

        // Generate encryptor from the existing key bytes and initialization 
        // vector. Key size will be defined based on the number of the key 
        // bytes.
        ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);

        // Define memory stream which will be used to hold encrypted data.
        MemoryStream memoryStream = null;
        memoryStream = new MemoryStream();

        // Define cryptographic stream (always use Write mode for encryption).
        CryptoStream cryptoStream = null;
        cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
        // Start encrypting.
        cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

        // Finish encrypting.
        cryptoStream.FlushFinalBlock();

        // Convert our encrypted data from a memory stream into a byte array.
        byte[] cipherTextBytes = memoryStream.ToArray();

        // Close both streams.
        memoryStream.Close();
        cryptoStream.Close();

        // Convert encrypted data into a base64-encoded string.
        string cipherText = Convert.ToBase64String(cipherTextBytes);

        // Return encrypted string.
        return cipherText;

    }

    public string DecryptAES(string textToDecrypt, string key)
    {
        if (textToDecrypt.Equals(""))
        {
            return "";
        }
        RijndaelManaged rijndaelCipher = new RijndaelManaged();
        rijndaelCipher.Mode = CipherMode.CBC;
        rijndaelCipher.Padding = PaddingMode.PKCS7;

        rijndaelCipher.KeySize = 0x80;
        rijndaelCipher.BlockSize = 0x80;
        byte[] encryptedData = Convert.FromBase64String(textToDecrypt);
        byte[] pwdBytes = Encoding.UTF8.GetBytes(key);
        byte[] keyBytes = new byte[0x10];
        int len = pwdBytes.Length;
        if (len > keyBytes.Length)
        {
            len = keyBytes.Length;
        }
        Array.Copy(pwdBytes, keyBytes, len);
        rijndaelCipher.Key = keyBytes;
        rijndaelCipher.IV = keyBytes;
        byte[] plainText = rijndaelCipher.CreateDecryptor().TransformFinalBlock(encryptedData, 0, encryptedData.Length);
        return Encoding.UTF8.GetString(plainText);
    }

    public string EncryptAES(string textToEncrypt, string key)
    {
        RijndaelManaged rijndaelCipher = new RijndaelManaged();
        rijndaelCipher.Mode = CipherMode.CBC;
        rijndaelCipher.Padding = PaddingMode.PKCS7;

        rijndaelCipher.KeySize = 0x80;
        rijndaelCipher.BlockSize = 0x80;
        byte[] pwdBytes = Encoding.UTF8.GetBytes(key);
        byte[] keyBytes = new byte[0x10];
        int len = pwdBytes.Length;
        if (len > keyBytes.Length)
        {
            len = keyBytes.Length;
        }
        Array.Copy(pwdBytes, keyBytes, len);
        rijndaelCipher.Key = keyBytes;
        rijndaelCipher.IV = keyBytes;
        ICryptoTransform transform = rijndaelCipher.CreateEncryptor();
        byte[] plainText = Encoding.UTF8.GetBytes(textToEncrypt);
        return Convert.ToBase64String(transform.TransformFinalBlock(plainText, 0, plainText.Length));
    }

    //java code
//    String Decrypt(String text, String key) throws Exception
//    {
//        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
//byte[] keyBytes = new byte[16];
//    byte[] b = key.getBytes("UTF-8");
//    int len = b.length;
//if (len > keyBytes.length) len = keyBytes.length;
//System.arraycopy(b, 0, keyBytes, 0, len);
//SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
//    IvParameterSpec ivSpec = new IvParameterSpec(keyBytes);
//    cipher.init(Cipher.DECRYPT_MODE,keySpec,ivSpec);

//BASE64Decoder decoder = new BASE64Decoder();
//    byte[] results = cipher.doFinal(decoder.decodeBuffer(text));
//return new String(results,"UTF-8");
//}

//String Encrypt(String text, String key)
//throws Exception
//{
//    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
//byte[]
//    keyBytes= new byte[16];
//byte[] b = key.getBytes("UTF-8");
//int len = b.length;
//if (len > keyBytes.length) len = keyBytes.length;
//System.arraycopy(b, 0, keyBytes, 0, len);
//SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
//IvParameterSpec ivSpec = new IvParameterSpec(keyBytes);
//cipher.init(Cipher.ENCRYPT_MODE,keySpec,ivSpec);

//byte[] results = cipher.doFinal(text.getBytes("UTF-8"));
//BASE64Encoder encoder = new BASE64Encoder();
//return encoder.encode(results);
//}

    public   string Decrypt(string cipherText)
    {
        string tempDecrypt = null;


        string passPhrase = "Pas5pr@se"; // can be any string
        string saltValue = "s@1tValue"; // can be any string
        string hashAlgorithm = "SHA1"; // can be "MD5"
        int passwordIterations = 2; // can be any number
        string initVector = "@1B2c3D4e5F6g7H8"; // must be 16 bytes
        int keySize = 192;

        byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);

        byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);

        // Convert our ciphertext into a byte array.
        byte[] cipherTextBytes = Convert.FromBase64String(cipherText);


        PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations);

        // Use the password to generate pseudo-random bytes for the encryption
        // key. Specify the size of the key in bytes (instead of bits).
        byte[] keyBytes = password.GetBytes(keySize / 8);

        // Create uninitialized Rijndael encryption object.
        RijndaelManaged symmetricKey = new RijndaelManaged();

        // It is reasonable to set encryption mode to Cipher Block Chaining
        // (CBC). Use default options for other symmetric key parameters.
        symmetricKey.Mode = CipherMode.CBC;

        // Generate decryptor from the existing key bytes and initialization 
        // vector. Key size will be defined based on the number of the key 
        // bytes.
        ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes);

        // Define memory stream which will be used to hold encrypted data.
        MemoryStream memoryStream = null;
        memoryStream = new MemoryStream(cipherTextBytes);

        // Define memory stream which will be used to hold encrypted data.
        CryptoStream cryptoStream = null;
        cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);

        // Since at this point we don't know what the size of decrypted data
        // will be, allocate the buffer long enough to hold ciphertext;
        // plaintext is never longer than ciphertext.
        byte[] plainTextBytes = null;
        plainTextBytes = new byte[cipherTextBytes.Length + 1];
        try
        {


            // Start decrypting.
            int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);

            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();

            // Convert decrypted data into a string. 
            // Let us assume that the original plaintext string was UTF8-encoded.
            string plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);

            // Return decrypted string.
            tempDecrypt = plainText;

        }
        catch (Exception ex)
        {

        }


        return tempDecrypt;

    }



    public string encriptar(string texto)
    {
        char[] letras;
        letras = texto.ToCharArray();
        for (int i = 0; i < letras.Length; i++)
        {
            letras[i] = (char)(letras[i] + (char)5);
        }
        string encriptado = new string(letras);
        return encriptado;
    }




    /**

     * FUNCION DESENCRIPTAR TEXTO

     * @param texto

     * @return

     */

    public virtual string desencriptar(string texto)

    {
        char[] letras;
        letras = texto.ToCharArray();
        for (int i = 0; i < letras.Length; i++)
        {
            letras[i] = (char)(letras[i] - (char)5);
        }
        string desencriptado = new string(letras);
        return desencriptado;

    }
}