using System;

using System.Security.Cryptography;

using Newtonsoft.Json;

using System.Web;

using System.Collections.Generic;

using System.Text;

public class Program

{

    public static void Main()

    {

        /* Importar la librería RedsysAPI y Newronsoft.Json en su proyecto */

    /* Calcular el parámetro Ds_MerchantParameters. Para llevar a cabo el cálculo

de este parámetro, inicialmente se deben añadir todos los parámetros de la

petición de pago que se desea enviar, tal y como se muestra a continuación: */

​

    var merchantCode = "034761064";

    var terminal = "1";

    var moneda = "978";

    var transactionType = "0";

    var merchantUrl = "http://www.prueba.com/urlNotificacion.php";

    var urlOK = "http://www.prueba.com/urlOK.php";

    var urlKO = "http://www.prueba.com/urlKO.php";

    // Generate randomly with Customer's platform

    var commerceOrderNumber = "12010111041";

    var amount = "200";

    var commerceKey = "sq7HjrUOBfKmC576ILgskD5srU870gJ7";

​

    RedsysAPI redsysParameters = new RedsysAPI();

    redsysParameters.SetParameter("DS_MERCHANT_AMOUNT", amount);

    redsysParameters.SetParameter("DS_MERCHANT_ORDER", commerceOrderNumber);

    redsysParameters.SetParameter("DS_MERCHANT_MERCHANTCODE", merchantCode);

    redsysParameters.SetParameter("DS_MERCHANT_CURRENCY", moneda);

    redsysParameters.SetParameter("DS_MERCHANT_TRANSACTIONTYPE", transactionType);

    redsysParameters.SetParameter("DS_MERCHANT_TERMINAL", terminal);

    redsysParameters.SetParameter("DS_MERCHANT_MERCHANTURL", merchantUrl);

    redsysParameters.SetParameter("DS_MERCHANT_URLOK", urlOK);

    redsysParameters.SetParameter("DS_MERCHANT_URLKO", urlKO);

    /* Por último se debe llamar a la función de la librería

    “createMerchantParameters()” para crear los parámetros y asignar dicho valor a

    la etiqueta Ds_MerchantrParameters, tal y como se muestra a continuación: */

    string parameters = redsysParameters.createMerchantParameters().Dump("PARAMETEEEEEEEEEEEEEEERS!!!!!!!!!!!!!");

    /* Calcular el parámetro Ds_Signature. Para llevar a cabo el cálculo de este

    parámetro, se debe llamar a la función de la librería

    “createMerchantSignature()” con la clave SHA-256 del comercio (obteniendola en

    el panel del módulo de administración), tal y como se muestra a continuación:

    */

​

    string firma = redsysParameters.createMerchantSignature(commerceKey).Dump("FIRMAAAAAAAAAAAAAAA!!!!!!!!!!!!!!!!!");

    /* Una vez obtenidos los valores de los parámetros Ds_MerchantParameters y

    Ds_Signature , se debe rellenar la petición REST con dichos valores y el parámetro Ds_SignatureVersion */

    }

}

​

public static class DumpExtensions

{

    public static string Dump(this string text, string caption=null)

    {

        if(!string.IsNullOrEmpty(caption))

        {

            Console.WriteLine(caption); 

        }

        Console.WriteLine(text);

        Console.WriteLine();

        return text;

    }

}

​

public class RedsysAPI

{

​

    private Dictionary<string, string> m_keyvalues;

​

    private Cryptogra cryp;

​

    public RedsysAPI()

    {

        m_keyvalues = new Dictionary<string, string>();

        cryp = new Cryptogra();

    }

​

    /// <summary>

    /// Get parameter by key

    /// </summary>

    /// <param name="key"></param>

    /// <returns></returns>

    public string GetParameter(string key)

    {

        if (m_keyvalues.ContainsKey(key))

        {

            return m_keyvalues[key];

        }

        return null;

    }

​

    /// <summary>

    /// Set the value of a key

    /// </summary>

    /// <param name="key"></param>

    /// <param name="value"></param>

    public void SetParameter(string key, string value)

    {

        m_keyvalues.Add(key, value);

    }

​

​

​

    /// <summary>

    ///  Convert Dictionary to JSON string

    /// </summary>

    /// <param name="keyvalues"></param>

    /// <returns></returns>

    private string ToJson(Dictionary<string, string> keyvalues)

​

    {

​

        try

        {

            string res = JsonConvert.SerializeObject(keyvalues, Newtonsoft.Json.Formatting.None);

            return res;

​

        }

        catch (JsonSerializationException ex)

        {

            throw new JsonSerializationException(ex.Message);

​

        }

​

    }

​

    /// <summary>

    ///  Encode string to Base64

    /// </summary>

    /// <param name="toEncode"></param>

    /// <returns></returns>

    private string Base64Encode(string toEncode)

    {

        try

        {

            byte[] toEncodeAsBytes = System.Text.Encoding.UTF8.GetBytes(toEncode);

            string returnValue = System.Convert.ToBase64String(toEncodeAsBytes);

            return returnValue;

        }

        catch (FormatException ex)

        {

            throw new FormatException(ex.Message);

        }

    }

​

    /// <summary>

    /// Encode url string to Base64

    /// </summary>

    /// <param name="toEncode"></param>

    /// <returns></returns>

    private string Base64Encode_url(string toEncode)

    {

        try

        {

            byte[] toEncodeAsBytes = System.Text.Encoding.UTF8.GetBytes(toEncode);

            string returnValue = System.Convert.ToBase64String(toEncodeAsBytes).Replace('+', '-').Replace('/', '_');

            return returnValue;

        }

        catch (FormatException ex)

        {

            throw new FormatException(ex.Message);

​

        }

    }

    /// <summary>

    /// Encode byte[] to base64 string

    /// </summary>

    /// <param name="toEncode"></param>

    /// <returns></returns>

    private string Base64Encode2(byte[] toEncode)

    {

        try

        {

            string returnValue

                  = System.Convert.ToBase64String(toEncode);

            return returnValue;

        }

        catch (FormatException ex)

        {

​

            throw new FormatException(ex.Message);

        }

    }

​

    /// <summary>

    ///  Decode base64 url to string 

    /// </summary>

    /// <param name="encodedData"></param>

    /// <returns></returns>

    private string Base64Decode_url(string encodedData)

    {

        try

        {

            byte[] encodedDataAsBytes = System.Convert.FromBase64String(encodedData.Replace('-', '+').Replace('_', '/'));

            string returnValue = System.Text.Encoding.UTF8.GetString(encodedDataAsBytes);

            return HttpUtility.UrlDecode(returnValue);

        }

        catch (FormatException ex)

        {

​

            throw new FormatException(ex.Message);

​

        }

    }

​

    /// <summary>

    /// Decode Base64 string to byte[]

    /// </summary>

    /// <param name="encodedData"></param>

    /// <returns></returns>

    private byte[] Base64Decode(string encodedData)

    {

​

        try

        {

            byte[] encodedDataAsBytes = System.Convert.FromBase64String(encodedData);

​

            return encodedDataAsBytes;

        }

        catch (FormatException ex)

        {

            throw new FormatException(ex.Message);

        }

    }

​

    /// <summary>

    /// Calculate Encoded base64 JSON string with Merchant Parameters 

    /// </summary>

    /// <returns></returns>

    public string createMerchantParameters()

    {

​

        string json = ToJson(m_keyvalues);

​

        string j = Base64Encode(json);

        return j;

​

    }

​

​

    /// <summary>

    ///  Get Merchant Order

    /// </summary>

    /// <returns></returns>

    private string getOrder()

    {

        string numOrder = "";

​

        if (m_keyvalues.ContainsKey("DS_MERCHANT_ORDER"))

        {

            numOrder = m_keyvalues["DS_MERCHANT_ORDER"];

​

        }

        if (m_keyvalues.ContainsKey("Ds_Merchant_Order"))

        {

​

​

            numOrder = m_keyvalues["Ds_Merchant_Order"];

        }

        return numOrder;

​

    }

    /// <summary>

    /// Calculate  Merchant Signature 

    /// </summary>

    /// <param name="key"> Encoded base64 Key </param>

    /// <returns></returns>

    public string createMerchantSignature(string key)

    {

        // Decode key to byte[]

        byte[] k = Base64Decode(key);

​

        // Calculate Encoded base64 JSON string with Merchant Parameters 

        string ent = createMerchantParameters();

​

​

        // Calculate derivated key by encrypting with 3DES the "DS_MERCHANT_ORDER" with decoded key 

        byte[] kk = cryp.Encrypt3DES(getOrder(), k);

​

​

        /// Calculate HMAC SHA256 with Encoded base64 JSON string using derivated key calculated previously

        byte[] res = cryp.GetHMACSHA256(ent, kk);

​

​

        // Encode byte[] res to Base64 String

        string result = Base64Encode2(res);

​

        return result;

​

    }

​

    /// <summary>

    /// Decode base64 url to string  (Get the parameters)

    /// </summary>

    /// <param name="dat"></param>

    /// <returns></returns>

    public string decodeMerchantParameters(string dat)

    {

​

        return Base64Decode_url(dat);

​

    }

    /// <summary>

    /// Convert JSON string to Dictionary

    /// </summary>

    /// <param name="json"></param>

    /// <returns></returns>

    private Dictionary<string, string> FromJson(string json)

    {

​

        try

        {

            Dictionary<string, string> res = JsonConvert.DeserializeObject<Dictionary<string, string>>(json);

            return res;

        }

        catch (JsonSerializationException ex)

        {

            throw new JsonSerializationException(ex.Message);

        }

    }

​

    /// <summary>

    /// Get Order Notification

    /// </summary>

    /// <returns>"DS_ORDER"</returns>

    private string GetOrderNotif()

    {

        string numOrder = "";

        // "DS_ORDER"

        if (m_keyvalues.ContainsKey("Ds_Order"))

        {

            numOrder = m_keyvalues["Ds_Order"];

        }

​

        if (m_keyvalues.ContainsKey("DS_ORDER"))

        {

            numOrder = m_keyvalues["DS_ORDER"];

        }

        return numOrder;

    }

    /// <summary>

    /// Calculate Signature Notificacion to comparate with original Signature 

    /// </summary>

    /// <param name="key"></param>

    /// <param name="data"></param>

    /// <returns></returns>

    public string createMerchantSignatureNotif(string key, string data)

    {

        // Decode key to byte[]

        var k = Base64Decode(key);

​

        //Decode base64 url to string  (Get the parameters)

        var deco = Base64Decode_url(data);

​

        // Convert JSON string to Dictionary

        m_keyvalues = FromJson(deco);

​

        string result = "";

​

        // If dictionary has values

        if (m_keyvalues != null)

        {

            // Calculate derivated key by encrypting with 3DES the "DS_ORDER" with decoded key 

            var derivatekey = cryp.Encrypt3DES(GetOrderNotif(), k);

​

            // Calculate HMAC SHA256 with Encoded base64 JSON string using derivated key calculated previously

            var res = cryp.GetHMACSHA256(data, derivatekey);

​

            // Encode byte[] res to Base64 String

            string res2 = Base64Encode2(res);

​

            // Convert the result to be compatible with url

            return res2.Replace('+', '-').Replace('/', '_');

        }

        //If dictionary has not value 

        return result;

    }

​

}

​

public class Cryptogra

{

​

    /// <summary>

    /// calculate HMAC SHA-256

    /// </summary>

    /// <param name="msg"></param>

    /// <param name="key"></param>

    /// <returns>byte[] with the result</returns>

    public byte[] GetHMACSHA256(string msg, byte[] key)

    {

        try

        {

            /// Obtain byte[] from input string 

            byte[] msgBytes = Encoding.UTF8.GetBytes(msg);

​

            // Initialize the keyed hash object.

            using (HMACSHA256 hmac = new HMACSHA256(key))

            {

​

                //Compute the hash of the input file.

                byte[] hashValue = hmac.ComputeHash(msgBytes, 0, msgBytes.Length);

                return hashValue;

            }

        }

        // Error in crytographic process  

        catch (CryptographicException ex)

        {

            throw new CryptographicException(ex.Message);

        }

​

    }

​

    /// <summary>

    /// Encrypt 3DES 

    /// </summary>

    /// <param name="plainText"></param>

    /// <param name="key"></param>

    /// <returns>byte[] with the result</returns>

    public byte[] Encrypt3DES(string plainText, byte[] key)

    {

        if (String.IsNullOrEmpty(plainText))

        {

            throw new FormatException();

        }

​

​

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

        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();

​

​

        try

        {

​

            /// <summary>

            /// SALT used in 3DES encryptation process.

            /// </summary>

            byte[] SALT = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 };

​

            // Block size 64 bit (8 bytes)

            tdes.BlockSize = 64;

​

            // Key Size 192 bit (24 bytes)

            tdes.KeySize = 192;

            tdes.Mode = CipherMode.CBC;

            tdes.Padding = PaddingMode.Zeros;

​

​

            tdes.IV = SALT;

            tdes.Key = key;

​

            var cTransform = tdes.CreateEncryptor();

​

            //transform the specified region of bytes array to resultArray

            byte[] resultArray =

              cTransform.TransformFinalBlock(toEncryptArray, 0,

              toEncryptArray.Length);

​

            //Release resources held by TripleDes Encryptor

            tdes.Clear();

​

            return resultArray;

​

        }

        // Error in Cryptographic method

        catch (CryptographicException ex)

        {

            throw new CryptographicException(ex.Message);

        }

​

​

    }

}