none
Conta com Numeros e letras

Respostas

  • Boa noite Guilherme!

    O código abaixo funciona normalmente, aconselho montar um form novo para testar. Por favor, se te ajudou não se esqueça de votar.

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Windows.Forms;
    using System.Security;
    using System.Security.Cryptography;



    namespace Criptografia
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            
        /// <summary>
        /// Enumerator com os tipos de classes para criptografia.
        /// </summary>

        public enum CryptProvider
        {
            /// <summary>
            /// Representa a classe base para implementações criptografia dos algoritmos simétricos Rijndael.
            /// </summary>
            Rijndael,
            /// <summary>
            /// Representa a classe base para implementações do algoritmo RC2.
            /// </summary>
            RC2,
            /// <summary>
            /// Representa a classe base para criptografia de dados padrões (DES - Data Encryption Standard).
            /// </summary>
            DES,
            /// <summary>
            /// Representa a classe base (TripleDES - Triple Data Encryption Standard).
            /// </summary>
            TripleDES

        }


        public class Criptografia

        {
            #region Variáveis e Métodos Privados

            private string _key = string.Empty;
            private CryptProvider _cryptProvider;
            private SymmetricAlgorithm _algorithm;


            /// <summary>
            /// Inicialização do vetor do algoritmo simétrico
            /// </summary>
            private void SetIV()
            {
                switch (_cryptProvider)
                {
                    case CryptProvider.Rijndael:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };
                        break;

                    default:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9 };
                        break;
                }
            }


            #endregion


            #region Properties
            /// <summary>
            /// Chave secreta para o algoritmo simétrico de criptografia.
            /// </summary>
            public string Key

            {
                get { return _key; }
                set { _key = value; }
            }


            #endregion


            #region Constructors
            /// <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>
            /// 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 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;
                 }

            #endregion


            #region Public methods
            /// <summary>
            /// Gera a chave de criptografia válida dentro do array.
            /// </summary>
            /// <returns>Chave com array de bytes.</returns>
            public virtual byte[] GetKey()
            {
                char pad = '*';
                string salt = string.Empty;
                // Ajusta o tamanho da chave se necessário e retorna uma chave válida
                if (_algorithm.LegalKeySizes.Length > 0)
                {
                    // Tamanho das chaves em bits
                    int keySize = _key.Length * 8;
                    int minSize = _algorithm.LegalKeySizes[0].MinSize;
                    int maxSize = _algorithm.LegalKeySizes[0].MaxSize;
                    int skipSize = _algorithm.LegalKeySizes[0].SkipSize;
                    if (keySize > maxSize)
                    {
                        // Busca o valor máximo da chave
                        _key = _key.Substring(0, maxSize / 8);
                    }
                    else if (keySize < maxSize)
                    {
                        // Seta um tamanho válido
                        int validSize = (keySize <= minSize) ? minSize : (keySize - keySize % skipSize) + skipSize;
                        if (keySize < validSize)
                        {
                            // Preenche a chave com arterisco para corrigir o tamanho
                            _key = _key.PadRight(validSize / 8, pad);
                        }
                    }
                }
                PasswordDeriveBytes key = new PasswordDeriveBytes(_key, ASCIIEncoding.ASCII.GetBytes(salt));
                return key.GetBytes(_key.Length);
            }
            /// <summary>
            /// Encripta o dado solicitado.
            /// </summary>
            /// <param name="plainText">Texto a ser criptografado.</param>
            /// <returns>Texto criptografado.</returns>
            public virtual string Encrypt(string texto)
            {
                byte[] plainByte = Encoding.UTF8.GetBytes(texto);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de criptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateEncryptor();
                MemoryStream _memoryStream = new MemoryStream();
                CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Write);
                // Grava os dados criptografados no MemoryStream
                _cryptoStream.Write(plainByte, 0, plainByte.Length);
                _cryptoStream.FlushFinalBlock();
                // Busca o tamanho dos bytes encriptados
                byte[] cryptoByte = _memoryStream.ToArray();
                // Converte para a base 64 string para uso posterior em um xml
                return Convert.ToBase64String(cryptoByte, 0, cryptoByte.GetLength(0));
            }
            /// <summary>
            /// Desencripta o dado solicitado.
            /// </summary>
            /// <param name="cryptoText">Texto a ser descriptografado.</param>
            /// <returns>Texto descriptografado.</returns>
            public virtual string Decrypt(string textoCriptografado)
            {
                // Converte a base 64 string em num array de bytes
                byte[] cryptoByte = Convert.FromBase64String(textoCriptografado);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de descriptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateDecryptor();
                try
                {
                    MemoryStream _memoryStream = new MemoryStream(cryptoByte, 0, cryptoByte.Length);
                    CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Read);
                    // Busca resultado do CryptoStream
                    StreamReader _streamReader = new StreamReader(_cryptoStream);
                    return _streamReader.ReadToEnd();
                }
                catch
                {
                    return null;
                }
            }
            #endregion

        }

        private void btnCriptografar_Click(object sender, EventArgs e)
        {
            
            string texto = txtNormal.Text;
            string key = "Criptografia"; //Está chave você mesmo é quem escolhe.
            Criptografia crip = new Criptografia(CryptProvider.DES);

                  crip.Key = key;

            txtCriptografado.Text = crip.Encrypt(texto);
            txtNormal.Text = string.Empty;

        }

        private void btnDecriptar_Click(object sender, EventArgs e)
        {
            
          string texto = txtCriptografado.Text;

          //Está chave tem que ser a mesma que a do texto Encriptado.

          string key = "Criptografia"; 
          Criptografia crip = new Criptografia(CryptProvider.DES);
          crip.Key = key;
          txtNormal.Text = crip.Decrypt(texto);
        
        }


       }
    }

    • Sugerido como Resposta M. Almeida sexta-feira, 28 de dezembro de 2012 20:47
    • Marcado como Resposta Ricardo RussoModerator terça-feira, 8 de janeiro de 2013 13:20
    sexta-feira, 28 de dezembro de 2012 20:32

Todas as Respostas

  • mas letras nao tem valor matematico como vc quer fazer essa conta? 

    Olavo Oliveira Neto
    http://olavooneto.wordpress.com
    Twitter @Olavooneto
    Facebook Olavo Neto
    Linkedin Olavo Neto
    Se for útil marque como resposta e faça um Developer feliz :)

    sexta-feira, 28 de dezembro de 2012 13:46
  • Tipo, eu quero misturar letras com os numeros
    sexta-feira, 28 de dezembro de 2012 13:57
  • guilherme, misturar é uam coisa, faze conta com eles é outra

    Olavo Oliveira Neto
    http://olavooneto.wordpress.com
    Twitter @Olavooneto
    Facebook Olavo Neto
    Linkedin Olavo Neto
    Se for útil marque como resposta e faça um Developer feliz :)

    sexta-feira, 28 de dezembro de 2012 16:04
  • Isso... eu quero misturar...
    sexta-feira, 28 de dezembro de 2012 16:08
  • Com qual finalidade? dá um exemplo concreto do que queres que seja feito.
    sexta-feira, 28 de dezembro de 2012 16:39
  • Tipo... eu quero gerar uma senha então eu vo pegar como parametro... o codigo do cliente como controle... a data e uma "palavra" ai eu quero fazer uma conta com o codigo do cliente e a data e misturar letras da seguinte "palavra" !
    sexta-feira, 28 de dezembro de 2012 19:41
  • mas se queres uma senha, porque não colocas um campo para senha e depois usas uma encriptação de senhas, como por exemplo o hash?

    Até mesmo podes juntar isso tudo e depois de teres a string completa, convertes para hash.

    Acho que seria a melhor hipótese para aquilo que pretendes.

    Cumpz, ADAE.

    sexta-feira, 28 de dezembro de 2012 20:25
  • Boa noite Guilherme!

    O código abaixo funciona normalmente, aconselho montar um form novo para testar. Por favor, se te ajudou não se esqueça de votar.

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Windows.Forms;
    using System.Security;
    using System.Security.Cryptography;



    namespace Criptografia
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            
        /// <summary>
        /// Enumerator com os tipos de classes para criptografia.
        /// </summary>

        public enum CryptProvider
        {
            /// <summary>
            /// Representa a classe base para implementações criptografia dos algoritmos simétricos Rijndael.
            /// </summary>
            Rijndael,
            /// <summary>
            /// Representa a classe base para implementações do algoritmo RC2.
            /// </summary>
            RC2,
            /// <summary>
            /// Representa a classe base para criptografia de dados padrões (DES - Data Encryption Standard).
            /// </summary>
            DES,
            /// <summary>
            /// Representa a classe base (TripleDES - Triple Data Encryption Standard).
            /// </summary>
            TripleDES

        }


        public class Criptografia

        {
            #region Variáveis e Métodos Privados

            private string _key = string.Empty;
            private CryptProvider _cryptProvider;
            private SymmetricAlgorithm _algorithm;


            /// <summary>
            /// Inicialização do vetor do algoritmo simétrico
            /// </summary>
            private void SetIV()
            {
                switch (_cryptProvider)
                {
                    case CryptProvider.Rijndael:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };
                        break;

                    default:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9 };
                        break;
                }
            }


            #endregion


            #region Properties
            /// <summary>
            /// Chave secreta para o algoritmo simétrico de criptografia.
            /// </summary>
            public string Key

            {
                get { return _key; }
                set { _key = value; }
            }


            #endregion


            #region Constructors
            /// <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>
            /// 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 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;
                 }

            #endregion


            #region Public methods
            /// <summary>
            /// Gera a chave de criptografia válida dentro do array.
            /// </summary>
            /// <returns>Chave com array de bytes.</returns>
            public virtual byte[] GetKey()
            {
                char pad = '*';
                string salt = string.Empty;
                // Ajusta o tamanho da chave se necessário e retorna uma chave válida
                if (_algorithm.LegalKeySizes.Length > 0)
                {
                    // Tamanho das chaves em bits
                    int keySize = _key.Length * 8;
                    int minSize = _algorithm.LegalKeySizes[0].MinSize;
                    int maxSize = _algorithm.LegalKeySizes[0].MaxSize;
                    int skipSize = _algorithm.LegalKeySizes[0].SkipSize;
                    if (keySize > maxSize)
                    {
                        // Busca o valor máximo da chave
                        _key = _key.Substring(0, maxSize / 8);
                    }
                    else if (keySize < maxSize)
                    {
                        // Seta um tamanho válido
                        int validSize = (keySize <= minSize) ? minSize : (keySize - keySize % skipSize) + skipSize;
                        if (keySize < validSize)
                        {
                            // Preenche a chave com arterisco para corrigir o tamanho
                            _key = _key.PadRight(validSize / 8, pad);
                        }
                    }
                }
                PasswordDeriveBytes key = new PasswordDeriveBytes(_key, ASCIIEncoding.ASCII.GetBytes(salt));
                return key.GetBytes(_key.Length);
            }
            /// <summary>
            /// Encripta o dado solicitado.
            /// </summary>
            /// <param name="plainText">Texto a ser criptografado.</param>
            /// <returns>Texto criptografado.</returns>
            public virtual string Encrypt(string texto)
            {
                byte[] plainByte = Encoding.UTF8.GetBytes(texto);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de criptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateEncryptor();
                MemoryStream _memoryStream = new MemoryStream();
                CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Write);
                // Grava os dados criptografados no MemoryStream
                _cryptoStream.Write(plainByte, 0, plainByte.Length);
                _cryptoStream.FlushFinalBlock();
                // Busca o tamanho dos bytes encriptados
                byte[] cryptoByte = _memoryStream.ToArray();
                // Converte para a base 64 string para uso posterior em um xml
                return Convert.ToBase64String(cryptoByte, 0, cryptoByte.GetLength(0));
            }
            /// <summary>
            /// Desencripta o dado solicitado.
            /// </summary>
            /// <param name="cryptoText">Texto a ser descriptografado.</param>
            /// <returns>Texto descriptografado.</returns>
            public virtual string Decrypt(string textoCriptografado)
            {
                // Converte a base 64 string em num array de bytes
                byte[] cryptoByte = Convert.FromBase64String(textoCriptografado);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de descriptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateDecryptor();
                try
                {
                    MemoryStream _memoryStream = new MemoryStream(cryptoByte, 0, cryptoByte.Length);
                    CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Read);
                    // Busca resultado do CryptoStream
                    StreamReader _streamReader = new StreamReader(_cryptoStream);
                    return _streamReader.ReadToEnd();
                }
                catch
                {
                    return null;
                }
            }
            #endregion

        }

        private void btnCriptografar_Click(object sender, EventArgs e)
        {
            
            string texto = txtNormal.Text;
            string key = "Criptografia"; //Está chave você mesmo é quem escolhe.
            Criptografia crip = new Criptografia(CryptProvider.DES);

                  crip.Key = key;

            txtCriptografado.Text = crip.Encrypt(texto);
            txtNormal.Text = string.Empty;

        }

        private void btnDecriptar_Click(object sender, EventArgs e)
        {
            
          string texto = txtCriptografado.Text;

          //Está chave tem que ser a mesma que a do texto Encriptado.

          string key = "Criptografia"; 
          Criptografia crip = new Criptografia(CryptProvider.DES);
          crip.Key = key;
          txtNormal.Text = crip.Decrypt(texto);
        
        }


       }
    }

    • Sugerido como Resposta M. Almeida sexta-feira, 28 de dezembro de 2012 20:47
    • Marcado como Resposta Ricardo RussoModerator terça-feira, 8 de janeiro de 2013 13:20
    sexta-feira, 28 de dezembro de 2012 20:32
  • Estou realizando a integração com um WebServices que me pede o envio de dados JSON encriptados por esse código exatamente igual o site, problema é um PHP conectando no WebServices.

    Então como gerar o KEY ou o IV, no PHP isso acontece RANDOM ou seja o JSON nunca é o mesmo, já pelo o código do Criptografia C# não altera tenho um código de C# que funciona.

    quinta-feira, 26 de junho de 2014 19:41
  • Boa tarde Man,

    Estou precisando de uma ajuda até o momento eu não entendi qual é o IV, em string.  Por exemplo eu já cheguei no bytes e nos Hex que ele gera... Mais preciso fazer o mesmo funcionar em PHP e não estou conseguindo a solução desse IV

    Boa noite Guilherme!

    O código abaixo funciona normalmente, aconselho montar um form novo para testar. Por favor, se te ajudou não se esqueça de votar.

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Windows.Forms;
    using System.Security;
    using System.Security.Cryptography;



    namespace Criptografia
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }

            
        /// <summary>
        /// Enumerator com os tipos de classes para criptografia.
        /// </summary>

        public enum CryptProvider
        {
            /// <summary>
            /// Representa a classe base para implementações criptografia dos algoritmos simétricos Rijndael.
            /// </summary>
            Rijndael,
            /// <summary>
            /// Representa a classe base para implementações do algoritmo RC2.
            /// </summary>
            RC2,
            /// <summary>
            /// Representa a classe base para criptografia de dados padrões (DES - Data Encryption Standard).
            /// </summary>
            DES,
            /// <summary>
            /// Representa a classe base (TripleDES - Triple Data Encryption Standard).
            /// </summary>
            TripleDES

        }


        public class Criptografia

        {
            #region Variáveis e Métodos Privados

            private string _key = string.Empty;
            private CryptProvider _cryptProvider;
            private SymmetricAlgorithm _algorithm;


            /// <summary>
            /// Inicialização do vetor do algoritmo simétrico
            /// </summary>
            private void SetIV()
            {
                switch (_cryptProvider)
                {
                    case CryptProvider.Rijndael:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };
                        break;

                    default:

                        _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9 };
                        break;
                }
            }


            #endregion


            #region Properties
            /// <summary>
            /// Chave secreta para o algoritmo simétrico de criptografia.
            /// </summary>
            public string Key

            {
                get { return _key; }
                set { _key = value; }
            }


            #endregion


            #region Constructors
            /// <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>
            /// 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 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;
                 }

            #endregion


            #region Public methods
            /// <summary>
            /// Gera a chave de criptografia válida dentro do array.
            /// </summary>
            /// <returns>Chave com array de bytes.</returns>
            public virtual byte[] GetKey()
            {
                char pad = '*';
                string salt = string.Empty;
                // Ajusta o tamanho da chave se necessário e retorna uma chave válida
                if (_algorithm.LegalKeySizes.Length > 0)
                {
                    // Tamanho das chaves em bits
                    int keySize = _key.Length * 8;
                    int minSize = _algorithm.LegalKeySizes[0].MinSize;
                    int maxSize = _algorithm.LegalKeySizes[0].MaxSize;
                    int skipSize = _algorithm.LegalKeySizes[0].SkipSize;
                    if (keySize > maxSize)
                    {
                        // Busca o valor máximo da chave
                        _key = _key.Substring(0, maxSize / 8);
                    }
                    else if (keySize < maxSize)
                    {
                        // Seta um tamanho válido
                        int validSize = (keySize <= minSize) ? minSize : (keySize - keySize % skipSize) + skipSize;
                        if (keySize < validSize)
                        {
                            // Preenche a chave com arterisco para corrigir o tamanho
                            _key = _key.PadRight(validSize / 8, pad);
                        }
                    }
                }
                PasswordDeriveBytes key = new PasswordDeriveBytes(_key, ASCIIEncoding.ASCII.GetBytes(salt));
                return key.GetBytes(_key.Length);
            }
            /// <summary>
            /// Encripta o dado solicitado.
            /// </summary>
            /// <param name="plainText">Texto a ser criptografado.</param>
            /// <returns>Texto criptografado.</returns>
            public virtual string Encrypt(string texto)
            {
                byte[] plainByte = Encoding.UTF8.GetBytes(texto);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de criptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateEncryptor();
                MemoryStream _memoryStream = new MemoryStream();
                CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Write);
                // Grava os dados criptografados no MemoryStream
                _cryptoStream.Write(plainByte, 0, plainByte.Length);
                _cryptoStream.FlushFinalBlock();
                // Busca o tamanho dos bytes encriptados
                byte[] cryptoByte = _memoryStream.ToArray();
                // Converte para a base 64 string para uso posterior em um xml
                return Convert.ToBase64String(cryptoByte, 0, cryptoByte.GetLength(0));
            }
            /// <summary>
            /// Desencripta o dado solicitado.
            /// </summary>
            /// <param name="cryptoText">Texto a ser descriptografado.</param>
            /// <returns>Texto descriptografado.</returns>
            public virtual string Decrypt(string textoCriptografado)
            {
                // Converte a base 64 string em num array de bytes
                byte[] cryptoByte = Convert.FromBase64String(textoCriptografado);
                byte[] keyByte = GetKey();
                // Seta a chave privada
                _algorithm.Key = keyByte;
                SetIV();
                // Interface de criptografia / Cria objeto de descriptografia
                ICryptoTransform cryptoTransform = _algorithm.CreateDecryptor();
                try
                {
                    MemoryStream _memoryStream = new MemoryStream(cryptoByte, 0, cryptoByte.Length);
                    CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Read);
                    // Busca resultado do CryptoStream
                    StreamReader _streamReader = new StreamReader(_cryptoStream);
                    return _streamReader.ReadToEnd();
                }
                catch
                {
                    return null;
                }
            }
            #endregion

        }

        private void btnCriptografar_Click(object sender, EventArgs e)
        {
            
            string texto = txtNormal.Text;
            string key = "Criptografia"; //Está chave você mesmo é quem escolhe.
            Criptografia crip = new Criptografia(CryptProvider.DES);

                  crip.Key = key;

            txtCriptografado.Text = crip.Encrypt(texto);
            txtNormal.Text = string.Empty;

        }

        private void btnDecriptar_Click(object sender, EventArgs e)
        {
            
          string texto = txtCriptografado.Text;

          //Está chave tem que ser a mesma que a do texto Encriptado.

          string key = "Criptografia"; 
          Criptografia crip = new Criptografia(CryptProvider.DES);
          crip.Key = key;
          txtNormal.Text = crip.Decrypt(texto);
        
        }


       }
    }


    terça-feira, 8 de julho de 2014 18:20
  • Já tentou fazer com MD5?

    Veja os links abaixo para C# e PHP.

    http://msdn.microsoft.com/pt-br/library/system.security.cryptography.md5(v=vs.110).aspx

    http://www.devmedia.com.br/md5-php-aprende-a-criar-hash-md5-em-php/22478

    Acho que este seja o padrão mais próximo entre as duas linguagens.

    Nos dois padrões são gerados valores hex de 32 caracteres.

    Além desta, você ainda poderia gerar um número e transformar metade dele em char.




    • Editado Supimpa quarta-feira, 9 de julho de 2014 00:02
    terça-feira, 8 de julho de 2014 23:54