Login Silencioso, C#

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

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

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            Console.WriteLine("Verificar Login Silencioso");
            
            var token  = "";
            var hash = "";
            
            
            try
            {
                
                var urlinicial = Encriptacion.DesencriptarURL(Util.Decode64(token));
                string hashCalculado;
                string hashfinal = Util.Decode64(hash);
                Encriptacion.EncryptStringComputeHash(urlinicial, out hashCalculado);
                if (hashfinal == hashCalculado)
                {
                    Console.WriteLine(string.Format("HashFinal {0},  es igual HashCalculado {1}",hashfinal,hashCalculado));
                    
                    var data = urlinicial.Split(';');
                    var fechaStr = data[1];
                    var user = data[0];
                    
                    Console.WriteLine(string.Format("Usuario {0},  Fecha {1}",user,fechaStr));
                    
                    var time = DateTime.ParseExact(fechaStr, "dd/MM/yyyy HH:mm", System.Globalization.CultureInfo.InvariantCulture);
                    var tiempovalido = 5;

if (DateTime.Now <= time.AddMinutes(Convert.ToDouble(tiempovalido)))
                    {                    
                        Console.WriteLine(string.Format("Login silencioso Ok. Usuario {0}",user));
                    }else{
                        Console.WriteLine(string.Format("Login silencioso. Enlace Caducado. Usuario {0}. Fecha {1}",user,fechaStr));
                    }
                }else{
                    Console.WriteLine(string.Format("HashFinal {0}, no es igual HashCalculado {1}",hashfinal,hashCalculado));
                } 
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.StackTrace); 
            }
        }
    }
    
    
    /// <summary>
    /// 
    /// </summary>
    public class Encriptacion
    {
        /// <summary>
        /// Encripta una cadena
        /// </summary>
        /// <param name="cadena">Cadena a encriptar</param>
        /// <param name="clave">Clave de encriptacion</param>
        /// <returns></returns>
        public static string Encriptar(string cadena, string clave)
        {
            // Convierto la cadena y la clave en arreglos de bytes
            // para poder usarlas en las funciones de encriptacion
            var cadenaBytes = Encoding.UTF8.GetBytes(cadena);
            var claveBytes = Encoding.UTF8.GetBytes(clave);

// Creo un objeto de la clase Rijndael
            var rij = new RijndaelManaged();

// Configuro para que utilice el modo ECB
            rij.Mode = CipherMode.ECB;

// Configuro para que use encriptacion de 256 bits.
            rij.BlockSize = 256;

// Declaro que si necesitara mas bytes agregue ceros.
            rij.Padding = PaddingMode.Zeros;

// Declaro un encriptador que use mi clave secreta y un vector
            // de inicializacion aleatorio
            ICryptoTransform encriptador;

encriptador = rij.CreateEncryptor(claveBytes, rij.IV);

// Declaro un stream de memoria para que guarde los datos
            // encriptados a medida que se van calculando
            var memStream = new MemoryStream();

// Declaro un stream de cifrado para que pueda escribir aqui
            // la cadena a encriptar. Esta clase utiliza el encriptador
            // y el stream de memoria para realizar la encriptacion
            // y para almacenarla
            CryptoStream cifradoStream;
            cifradoStream = new CryptoStream(memStream, encriptador, CryptoStreamMode.Write);

// Escribo los bytes a encriptar. A medida que se va escribiendo
            // se va encriptando la cadena
            cifradoStream.Write(cadenaBytes, 0, cadenaBytes.Length);

// Aviso que la encriptación se terminó
            cifradoStream.FlushFinalBlock();

// Convert our encrypted data from a memory stream into a byte array.
            var cipherTextBytes = memStream.ToArray();

// Cierro los dos streams creados
            memStream.Close();
            cifradoStream.Close();

// Convierto el resultado en base 64 para que sea legible
            // y devuelvo el resultado
            return Convert.ToBase64String(cipherTextBytes);
        }

/// <summary>
        /// Desencripta una cadena encriptada
        /// </summary>
        /// <param name="cadena">Cadena encriptada</param>
        /// <param name="clave">Clave de encriptacion(debe ser la misma clave con la cual se encripto la cadena)</param>
        /// <returns></returns>
        public static string Desencriptar(string cadena, string clave)
        {
            // Convierto la cadena y la clave en arreglos de bytes
            // para poder usarlas en las funciones de encriptacion
            // En este caso la cadena la convierta usando base 64
            // que es la codificacion usada en el metodo encriptar
            var cadenaBytes = Convert.FromBase64String(cadena);
            var claveBytes = Encoding.UTF8.GetBytes(clave);

// Creo un objeto de la clase Rijndael
            var rij = new RijndaelManaged();

// Configuro para que utilice el modo ECB
            rij.Mode = CipherMode.ECB;

// Configuro para que use encriptacion de 256 bits.
            rij.BlockSize = 256;

// Declaro que si necesitara mas bytes agregue ceros.
            rij.Padding = PaddingMode.Zeros;

// Declaro un desencriptador que use mi clave secreta y un vector
            // de inicializacion aleatorio
            ICryptoTransform desencriptador;
            desencriptador = rij.CreateDecryptor(claveBytes, rij.IV);

// Declaro un stream de memoria para que guarde los datos
            // encriptados
            var memStream = new MemoryStream(cadenaBytes);

// Declaro un stream de cifrado para que pueda leer de aqui
            // la cadena a desencriptar. Esta clase utiliza el desencriptador
            // y el stream de memoria para realizar la desencriptacion
            CryptoStream cifradoStream;
            cifradoStream = new CryptoStream(memStream, desencriptador, CryptoStreamMode.Read);

// Declaro un lector para que lea desde el stream de cifrado.
            // A medida que vaya leyendo se ira desencriptando.
            var lectorStream = new StreamReader(cifradoStream);

// Leo todos los bytes y lo almaceno en una cadena
            var resultado = lectorStream.ReadToEnd();

// Cierro los dos streams creados
            memStream.Close();
            cifradoStream.Close();

// Devuelvo la cadena
            return resultado.Trim();
        }

#region Se establecio esto para encriptar el token que se envia por url cuando se llama a el financiero

private static string _key = "3fqm=_po";//3DES"ABc%47563Lka_=";
        public static string EncriptarURL(string strValor)
        {
            EncryptDecryptQueryString encrypt = new EncryptDecryptQueryString();
            return encrypt.Encrypt(strValor, _key);
        }

public static string DesencriptarURL(string strValor)
        {
            EncryptDecryptQueryString encrypt = new EncryptDecryptQueryString();
            return encrypt.Decrypt(strValor, _key);
        }
        /// <summary>
        /// Permite encriptar una cadena y generar un valor hash parea dicha cadena.
        /// Esta cadena encriptada será enviada por querystring a un URL.
        /// </summary>
        /// <param name="strCadena">Cadena original</param>
        /// <param name="hash">Valor Hash</param>
        /// <returns></returns>
        public static string EncryptStringComputeHash(string originalString, out string hash)
        {
            //calculamos valor hash para asegurar integridad datos
            SHA1 sha1 = new SHA1CryptoServiceProvider();
            byte[] valorHashOrigen = sha1.ComputeHash(Encoding.UTF8.GetBytes(originalString));
            hash = HttpUtility.UrlEncode(System.Convert.ToBase64String(valorHashOrigen));

//encriptamos los datos a enviar
            string strQueryString = Encriptacion.EncriptarURL(originalString);

//Codificamos el string para poder enviarlo como querystring sin problemas
            byte[] toEncodeAsBytes = Encoding.ASCII.GetBytes(strQueryString.ToString());
            string returnValue = System.Convert.ToBase64String(toEncodeAsBytes);
            string datosAEnviarPorURL = HttpUtility.UrlEncode(returnValue);
            return datosAEnviarPorURL;
        }

public static string DecryptStringComputeHash(string encryptString, out string hash)
        {
            /****Decodficamos el string*****/
            string str = HttpUtility.UrlDecode(encryptString);
            byte[] decbuff = Convert.FromBase64String(str);
            string valorRecibido = System.Text.Encoding.UTF8.GetString(decbuff);

//desencriptamos la cadena
            string strQueryStringDesencriptado = Encriptacion.DesencriptarURL(valorRecibido);

//Calculamos el valor hash de la cadena desencriptada
            SHA1 sha1 = new SHA1CryptoServiceProvider();
            byte[] valorHashDestino = sha1.ComputeHash(Encoding.UTF8.GetBytes(strQueryStringDesencriptado));
            hash = System.Convert.ToBase64String(valorHashDestino);

return strQueryStringDesencriptado;
        }

/// <summary>
        /// Codifica el valor retornado por data.ToString() en base 64 y url encode
        /// </summary>
        /// <param name="data">Objeto a codificar</param>
        /// <returns>Cadena codificada</returns>
        public static string Encode64(string strCadenaEncriptada)
        {
            //byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(data != null ? data.ToString() : string.Empty);
            //string returnValue = System.Convert.ToBase64String(toEncodeAsBytes);
            //return HttpUtility.UrlEncode(returnValue);

byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(strCadenaEncriptada.ToString());
            string returnValue = System.Convert.ToBase64String(toEncodeAsBytes);
            string datosAEnviarPorURL = HttpUtility.UrlEncode(returnValue);
            return datosAEnviarPorURL;
        }

/// <summary>
        /// Decofifica una cadena con url decode y decodificación de base 64
        /// </summary>
        /// <param name="str">Cadena a decodificar</param>
        /// <returns>Cadena decodificada</returns>
        public static string Decode64(string strCadenaURL)
        {
            try
            {
                //str = HttpUtility.UrlDecode(str);
                //byte[] decbuff = Convert.FromBase64String(str != null ? str : string.Empty);
                //return System.Text.Encoding.UTF8.GetString(decbuff);

string str = HttpUtility.UrlDecode(strCadenaURL);
                byte[] decbuff = Convert.FromBase64String(str);
                string valorRecibido = System.Text.Encoding.UTF8.GetString(decbuff);
                return valorRecibido;
            }
            catch
            {
                throw new Exception("El parámetro ha sido alterado");
            }
        }

#endregion

}
    class EncryptDecryptQueryString
    {
        private byte[] key = { };
        private byte[] IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
        internal string Decrypt(string stringToDecrypt, string sEncryptionKey)
        {
            byte[] inputByteArray = new byte[stringToDecrypt.Length + 1];
           
                //DES
                /* key = System.Text.Encoding.UTF8.GetBytes(sEncryptionKey);
                 DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                 inputByteArray = Convert.FromBase64String(stringToDecrypt);

MemoryStream ms = new MemoryStream();
                 CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(key, IV), CryptoStreamMode.Write);
                 cs.Write(inputByteArray, 0, inputByteArray.Length);
                 cs.FlushFinalBlock();
                 System.Text.Encoding encoding = System.Text.Encoding.UTF8;
                 return encoding.GetString(ms.ToArray());*/

//3DES
                key = System.Text.Encoding.UTF8.GetBytes(sEncryptionKey);
                TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
                inputByteArray = Convert.FromBase64String(stringToDecrypt);

PasswordDeriveBytes generadorKey = new PasswordDeriveBytes(key, null);
                byte[] bytesKeySHA1 = generadorKey.CryptDeriveKey("TripleDES", "SHA1", 192, des.IV);

MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(bytesKeySHA1, IV), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                Encoding encoding = Encoding.UTF8;
                return encoding.GetString(ms.ToArray());
           
        }

internal string Encrypt(string stringToEncrypt, string SEncryptionKey)
        {
           
                //DES
                /*key = System.Text.Encoding.UTF8.GetBytes(SEncryptionKey);
                DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                byte[] inputByteArray = Encoding.UTF8.GetBytes(stringToEncrypt);

MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(key, IV), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                return Convert.ToBase64String(ms.ToArray());*/

//3DES
                key = Encoding.UTF8.GetBytes(SEncryptionKey);
                TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
                byte[] inputByteArray = Encoding.UTF8.GetBytes(stringToEncrypt);

PasswordDeriveBytes generadorKey = new PasswordDeriveBytes(key, null);
                byte[] bytesKeySHA1 = generadorKey.CryptDeriveKey("TripleDES", "SHA1", 192, des.IV);

MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(bytesKeySHA1, IV), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                return Convert.ToBase64String(ms.ToArray());
            
        }
    }
    
     public class Util
    {

/// <summary>
        /// Decofifica una cadena con url decode y decodificación de base 64
        /// </summary>
        /// <param name="str">Cadena a decodificar</param>
        /// <returns>Cadena decodificada</returns>
        public static string Decode64(string strCadenaURL)
        {
            try
            {
                string str = HttpUtility.UrlDecode(strCadenaURL);
                byte[] decbuff = Convert.FromBase64String(str);
                string valorRecibido = System.Text.Encoding.UTF8.GetString(decbuff);
                return valorRecibido;
            }
            catch
            {
                throw new Exception("El parámetro ha sido alterado");
            }
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,17 sec, absolute running time: 0,36 sec, cpu time: 0,34 sec, average memory usage: 24 Mb, average nr of threads: 5