Szybkie, lekkie szyfrowanie klienta .NET -> Odszyfrowywanie serwera

Question

Mam prostą konfigurację klient/serwer. Klient i serwer mają klucz prywatny.

Co NET mi zaoferować w drodze

ClientData-> ClientEncrypt z kluczykowy> przekazują server-> ServerDecrypt z kluczykowy> ClientData

Czy ktoś może zaproponować jakieś szybkie proste biblioteki do odczytu dalej?

Dzięki

Answer 1

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

namespace ServiceConsole 
{ 
    public class Obfuscation 
    { 
     public static byte[] Encrypt(string data) 
     { 
      return Encrypt(data, SecurityCredentials.KeyString, SecurityCredentials.IvString); 
     } 

     public static byte[] Encrypt(string data, string key, string iv) 
     { 
      return Encrypt(data, key, iv, SecurityCredentials.PaddingString); 
     } 

     public static byte[] Encrypt(string data, string key, string iv, char paddingCharacter) 
     { 
      byte[] keyBytes = Encoding.UTF8.GetBytes(key.PadLeft(32, paddingCharacter).Substring(0, 32)); 
      byte[] ivBytes = Encoding.UTF8.GetBytes(iv.PadLeft(32, paddingCharacter).Substring(0, 32)); 

      RijndaelManaged rijndaelManaged = new RijndaelManaged(); 
      rijndaelManaged.BlockSize = 256; 
      rijndaelManaged.KeySize = 256; 

      MemoryStream memoryStream = new MemoryStream(); 

      ICryptoTransform iCryptoTransform = rijndaelManaged.CreateEncryptor(keyBytes, ivBytes); 

      CryptoStream cryptoStream = new CryptoStream(memoryStream, iCryptoTransform, CryptoStreamMode.Write); 

      StreamWriter streamWriter = new StreamWriter(cryptoStream); 

      streamWriter.Write(data); 
      streamWriter.Flush(); 

      cryptoStream.FlushFinalBlock(); 

      byte[] returnBytes = memoryStream.ToArray(); 

      /// Disposal 
      streamWriter.Dispose(); 
      cryptoStream.Dispose(); 
      iCryptoTransform.Dispose(); 
      memoryStream.Dispose(); 
      rijndaelManaged.Clear(); 
      /// 

      return returnBytes; 
     } 

     public static string Decrypt(byte[] data) 
     { 
      return Decrypt(data, SecurityCredentials.KeyString, SecurityCredentials.IvString); 
     } 

     public static string Decrypt(byte[] data, string key, string iv) 
     { 
      return Decrypt(data, key, iv, SecurityCredentials.PaddingString); 
     } 

     public static string Decrypt(byte[] data, string key, string iv, char paddingCharacter) 
     { 
      byte[] keyBytes = Encoding.UTF8.GetBytes(key.PadLeft(32, paddingCharacter).Substring(0, 32)); 
      byte[] ivBytes = Encoding.UTF8.GetBytes(iv.PadLeft(32, paddingCharacter).Substring(0, 32)); 

      RijndaelManaged rijndaelManaged = new RijndaelManaged(); 
      rijndaelManaged.BlockSize = 256; 
      rijndaelManaged.KeySize = 256; 

      MemoryStream memoryStream = new MemoryStream(data); 

      ICryptoTransform iCryptoTransform = rijndaelManaged.CreateDecryptor(keyBytes, ivBytes); 

      CryptoStream cryptoStream = new CryptoStream(memoryStream, iCryptoTransform, CryptoStreamMode.Read); 

      StreamReader streamReader = new StreamReader(cryptoStream); 

      string returnString = streamReader.ReadLine(); 

      /// Disposal 
      streamReader.Dispose(); 
      cryptoStream.Dispose(); 
      iCryptoTransform.Dispose(); 
      memoryStream.Dispose(); 
      rijndaelManaged.Clear(); 
      /// 

      return returnString; 
     } 
    } 
} 

(lub po prostu google wokół!)

Answer 2

RijndaelManaged:

Oto an example:

private static string CreateEncryptedString(string myString, string hexiv, string key) 
     { 
      RijndaelManaged alg = new RijndaelManaged(); 
      alg.Padding = PaddingMode.Zeros; 
      alg.Mode = CipherMode.CBC; 
      alg.BlockSize = 16 * 8; 
      alg.Key = ASCIIEncoding.UTF8.GetBytes(key); 
      alg.IV = StringToByteArray(hexiv); 
      ICryptoTransform encryptor = alg.CreateEncryptor(alg.Key, alg.IV); 

      MemoryStream msStream = new MemoryStream(); 
      CryptoStream mCSWriter = new CryptoStream(msStream, encryptor, CryptoStreamMode.Write); 
      StreamWriter mSWriter = new StreamWriter(mCSWriter); 
      mSWriter.Write(myString); 
      mSWriter.Flush(); 
      mCSWriter.FlushFinalBlock(); 

      var EncryptedByte = new byte[msStream.Length]; 
      msStream.Position = 0; 
      msStream.Read(EncryptedByte, 0, (int)msStream.Length); 

      return ByteArrayToHexString(EncryptedByte); 

     } 
     public static byte[] StringToByteArray(String hex) 
     { 
      int NumberChars = hex.Length; 
      byte[] bytes = new byte[NumberChars/2]; 
      for (int i = 0; i < NumberChars; i += 2) 
       bytes[i/2] = Convert.ToByte(hex.Substring(i, 2), 16); 
      return bytes; 
     } 
     public static string ByteArrayToHexString(byte[] ba) 
     { 
      StringBuilder hex = new StringBuilder(ba.Length * 2); 
      foreach (byte b in ba) 
       hex.AppendFormat("{0:x2}", b); 
      return hex.ToString(); 
     } 

można łatwo wyjść z algorytmu deszyfrowania i przykłady