TFS_ANTIGUO/SIGPC/wcfSigdd/WindowsApplication__Encriptar/Seguridad/Encriptar.cs

using System;
using System.Security.Cryptography;
using System.Text;
using System.IO;

namespace WindowsApplication_OTSI_Encriptar
{
    public class Encriptar
    {

        ///// <summary>
        ///// Encripta el texto enviado usando el algoritmo "Rijndael"
        ///// </summary>
        ///// <param name="Texto">
        ///// El texto sin codificar.
        ///// </param>        
        ///// <returns>
        ///// El texto codificado. <see cref="string"/>.
        ///// </returns>
        //public string Encripta(String Texto)
        //{
        //    try
        //    {
        //        byte[] claveSecreta = Encoding.ASCII.GetBytes("12EstaClave34es56dificil489ssswf"); // Clave del cifrado para Rijndael.
        //        string strVectorInicializacion = "@Fa1C02.1cO8U3B9"; // Debe ser de 16 letras
        //        byte[] vectorInicializacion = Encoding.ASCII.GetBytes(strVectorInicializacion); // Vector de inicio para Rijndael


        //        // Instancia del algoritmo de Rijndael
        //        Rijndael RijndaelAlg = Rijndael.Create();

        //        // Flujo en memoria para el cifrado
        //        MemoryStream flujoMemoria = new MemoryStream();

        //        // Flujo de cifrado basado en el flujo de los datos
        //        CryptoStream flujoCifrado = new CryptoStream(flujoMemoria, RijndaelAlg.CreateEncryptor(claveSecreta, vectorInicializacion), CryptoStreamMode.Write);

        //        // Representación en bytes de la información a cifrar
        //        byte[] textoBytes = UTF8Encoding.UTF8.GetBytes(Texto);

        //        // Cifrar los datos enviándolos al flujo de cifrado
        //        flujoCifrado.Write(textoBytes, 0, textoBytes.Length);
        //        flujoCifrado.FlushFinalBlock();

        //        // Datos cifrados como un arreglo de bytes
        //        byte[] textoCifradoBytes = flujoMemoria.ToArray();

        //        // Cerrar los flujos 
        //        flujoMemoria.Close();
        //        flujoCifrado.Close();

        //        // Retornar la representación de texto de los datos cifrados
        //        return Convert.ToBase64String(textoCifradoBytes);
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }


        //}


        ///// <summary>
        ///// Desencripta el texto enviado usando el algoritmo "Rijndael"
        ///// </summary>
        ///// <param name="Texto">
        ///// El texto cifrado.
        ///// </param>        
        ///// <returns>
        ///// El texto descifrado. <see cref="string"/>.
        ///// </returns>
        //public string Desencripta(String textoEncriptado)
        //{
        //    try
        //    {
        //        byte[] claveSecreta = Encoding.ASCII.GetBytes("12EstaClave34es56dificil489ssswf"); // Clave del cifrado para Rijndael.
        //        string strVectorInicializacion = "@Fa1C02.1cO8U3B9"; // Debe ser de 16 letras
        //        byte[] vectorInicializacion = Encoding.ASCII.GetBytes(strVectorInicializacion); // Vector de inicio para Rijndael

        //        // Representación en bytes del texto cifrado
        //        byte[] textoCifradoBytes = Convert.FromBase64String(textoEncriptado);

        //        // Datos descifrados
        //        byte[] textoBytes = new byte[textoCifradoBytes.Length];

        //        // Instancia del algoritmo de Rijndael
        //        Rijndael RijndaelAlg = Rijndael.Create();

        //        // Flujo en memoria con la representación de bytes del texto cifrado
        //        MemoryStream flujoMemoria = new MemoryStream(textoCifradoBytes);

        //        // Flujo de descifrado basado en el flujo de los datos
        //        CryptoStream flujoCifrado = new CryptoStream(flujoMemoria, RijndaelAlg.CreateDecryptor(claveSecreta, vectorInicializacion), CryptoStreamMode.Read);

        //        // Datos descifrados obteniéndolos del flujo de descifrado
        //        int DesencriptadoByteCount = flujoCifrado.Read(textoBytes, 0, textoBytes.Length);

        //        // Cerrar los flujos 
        //        flujoMemoria.Close();
        //        flujoCifrado.Close();

        //        // Retornar la representación de texto de los datos descifrados
        //        return Encoding.UTF8.GetString(textoBytes, 0, DesencriptadoByteCount);
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}

        /// <summary>

        /// Clase encargada de la generacion de contrasenas aleatorias, llaves para encripcion, cifrado y decifrado de mensajes.

        /// </summary>



        private const string key = "FjaOJ0x9poxy+nRjPGOk6w==";





        /// <summary>

        /// Metodo encargado de Cifrar un texto

        /// </summary>

        /// <param name="mensaje">Texto a cifrar</param>

        /// <returns>Retorna el texto cifrado</returns>

        public string Encripta(string mensaje)
        {

            TripleDESCryptoServiceProvider algoritmo = new TripleDESCryptoServiceProvider();

            ///se define la llave

            algoritmo.Key = Convert.FromBase64String(key);

            //Obtiene o establece el modo de funcionamiento del algoritmo simétrico.

            algoritmo.Mode = CipherMode.ECB;

            //crea la transformación

            ICryptoTransform encryptor = algoritmo.CreateEncryptor();

            ///se obtiene el mensaje en bites para ser cifrado

            byte[] dato = Encoding.Unicode.GetBytes(mensaje);

            ///se cifra

            byte[] datoEncriptado = encryptor.TransformFinalBlock(dato, 0, dato.Length);

            ///se retorna como string

            return Convert.ToBase64String(datoEncriptado);

        }



        /// <summary>

        /// Metodo para decifrar un texto

        /// </summary>

        /// <param name="mensaje">Texto Cifrado</param>

        /// <returns>Retorna el texto decifrado</returns>

        public string Desencripta(string mensaje)
        {



            TripleDESCryptoServiceProvider algoritmo = new TripleDESCryptoServiceProvider();

            ///se define la llave

            algoritmo.Key = Convert.FromBase64String(key);

            //Obtiene o establece el modo de funcionamiento del algoritmo simétrico.

            algoritmo.Mode = CipherMode.ECB;

            //crea la transformación

            ICryptoTransform decryptor = algoritmo.CreateDecryptor();

            ///se obtiene el mensaje en bites para ser cifrado

            byte[] dato = Convert.FromBase64String(mensaje);

            ///se obtiene el mensaje en bites para ser descifrado

            byte[] datoDecifrado = decryptor.TransformFinalBlock(dato, 0, dato.Length);

            ///se retorna como string

            return Encoding.Unicode.GetString(datoDecifrado);

        }



        /// <summary>

        /// Metodo encargado de la generacion de un password de forma aleatoria

        /// </summary>

        /// <param name="PasswordLength">Tamanio del password a generar</param>

        /// <returns>Retorna el Password Generado de forma aleatoria con el tamanio indicado</returns>

        public string GenerarPassword(int PasswordLength)
        {

            string _allowedChars = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789!@$?";

            Byte[] randomBytes = new Byte[PasswordLength];

            char[] chars = new char[PasswordLength];

            int allowedCharCount = _allowedChars.Length;



            for (int i = 0; i < PasswordLength; i++)
            {

                Random randomObj = new Random();

                randomObj.NextBytes(randomBytes);

                chars[i] = _allowedChars[(int)randomBytes[i] % allowedCharCount];

            }



            return new string(chars);

        }


    }
}