AES, aby powrócić alfanumerycznych

Question

Mam kod szyfrujący AES, chcę, aby zwrócić tylko znaków alfanumerycznych jak {ABCDEFGHIJKLMNOPQRSTWUVYZ}

Ale jednak nie mogłem dowiedzieć się, jak to zrobić. Nie mam prawie żadnego pojęcia o szyfrowaniu, nie mogłem ustalić, gdzie naprawić. Naprawdę doceniłbym twoją opinię. Pozdrawiam ...

public class clsCrypto 
    { 
     private string _KEY = string.Empty; 
     protected internal string KEY 
     { 
      get 
      { 
       return _KEY; 
      } 
      set 
      { 
       if (!string.IsNullOrEmpty(value)) 
       { 
        _KEY = value; 
       } 
      } 
     } 

     private string _IV = string.Empty; 
     protected internal string IV 
     { 
      get 
      { 
       return _IV; 
      } 
      set 
      { 
       if (!string.IsNullOrEmpty(value)) 
       { 
        _IV = value; 
       } 
      } 
     } 

     private string CalcMD5(string strInput) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        StringBuilder strHex = new StringBuilder(); 
        using (MD5 md5 = MD5.Create()) 
        { 
         byte[] bytArText = Encoding.Default.GetBytes(strInput); 
         byte[] bytArHash = md5.ComputeHash(bytArText); 
         for (int i = 0; i < bytArHash.Length; i++) 
         { 
          strHex.Append(bytArHash[i].ToString("X2")); 
         } 
         strOutput = strHex.ToString(); 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

     private byte[] GetBytesFromHexString(string strInput) 
     { 
      byte[] bytArOutput = new byte[] { }; 
      if ((!string.IsNullOrEmpty(strInput)) && strInput.Length % 2 == 0) 
      { 
       SoapHexBinary hexBinary = null; 
       try 
       { 
        hexBinary = SoapHexBinary.Parse(strInput); 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
       bytArOutput = hexBinary.Value; 
      } 
      return bytArOutput; 
     } 

     private byte[] GenerateIV() 
     { 
      byte[] bytArOutput = new byte[] { }; 
      try 
      { 
       string strIV = CalcMD5(IV); 
       bytArOutput = GetBytesFromHexString(strIV); 
      } 
      catch (Exception ex) 
      { 
       MessageBox.Show(ex.Message); 
      } 
      return bytArOutput; 
     } 

     private byte[] GenerateKey() 
     { 
      byte[] bytArOutput = new byte[] { }; 
      try 
      { 
       string strKey = CalcMD5(KEY); 
       bytArOutput = GetBytesFromHexString(strKey); 
      } 
      catch (Exception ex) 
      { 
       MessageBox.Show(ex.Message); 
      } 
      return bytArOutput; 
     } 

     protected internal string Encrypt(string strInput, CipherMode cipherMode) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        byte[] bytePlainText = Encoding.Default.GetBytes(strInput); 
        using (RijndaelManaged rijManaged = new RijndaelManaged()) 
        { 
         rijManaged.Mode = cipherMode; 
         rijManaged.BlockSize = 128; 
         rijManaged.KeySize = 128; 
         rijManaged.IV = GenerateIV(); 
         rijManaged.Key = GenerateKey(); 
         rijManaged.Padding = PaddingMode.Zeros; 
         ICryptoTransform icpoTransform = rijManaged.CreateEncryptor(rijManaged.Key, rijManaged.IV); 
         using (MemoryStream memStream = new MemoryStream()) 
         { 
          using (CryptoStream cpoStream = new CryptoStream(memStream, icpoTransform, CryptoStreamMode.Write)) 
          { 
           cpoStream.Write(bytePlainText, 0, bytePlainText.Length); 
           cpoStream.FlushFinalBlock(); 
          } 
          strOutput = Encoding.Default.GetString(memStream.ToArray()); 
         } 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

     protected internal string Decrypt(string strInput, CipherMode cipherMode) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        byte[] byteCipherText = Encoding.Default.GetBytes(strInput); 
        byte[] byteBuffer = new byte[strInput.Length]; 
        using (RijndaelManaged rijManaged = new RijndaelManaged()) 
        { 
         rijManaged.Mode = cipherMode; 
         rijManaged.BlockSize = 128; 
         rijManaged.KeySize = 128; 
         rijManaged.IV = GenerateIV(); 
         rijManaged.Key = GenerateKey(); 
         rijManaged.Padding = PaddingMode.Zeros; 
         ICryptoTransform icpoTransform = rijManaged.CreateDecryptor(rijManaged.Key, rijManaged.IV); 
         using (MemoryStream memStream = new MemoryStream(byteCipherText)) 
         { 
          using (CryptoStream cpoStream = new CryptoStream(memStream, icpoTransform, CryptoStreamMode.Read)) 
          { 
           cpoStream.Read(byteBuffer, 0, byteBuffer.Length); 
          } 
          strOutput = Encoding.Default.GetString(byteBuffer); 
         } 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

    } 

Answer 1

Funkcje szyfrowania i odszyfrowywania używają tablic bajtowych jako parametrów. Musisz więc przekonwertować te tablice na łańcuch bazowy 36.

Można stosować następujące klasy (Base36), aby te konwersje:

Wszystko co musisz zrobić, dzwoni te dwie funkcje:

byte[] byteArray; 

//To convert byte array to String 
string byteArrayInBase36 = Base36.ByteArrayToBase36String(byteArray); 

//To convert String to byte Array 
byte[] byteArray2 = Base36.Base36StringToByteArray(byteArrayInBase36); 

i jest to klasa:

using System; 
using System.Collections.Generic; 

class Base36 
{ 
#region public methods 
public static string ByteArrayToBase36String(byte[] bytes) 
{ 
    string result = string.Empty; 
    result = Encode36((ulong)bytes.Length).PadLeft(BASE36_LENGTH_BLOC_SIZE_36, '0'); 

    if (bytes.Length > 0) 
    { 
     List<byte[]> byteslist = SplitBytes(bytes, 8); 
     if (byteslist[byteslist.Count - 1].Length < 8) 
     { 
      byte[] newLastArray = new byte[8]; 
      byteslist[byteslist.Count - 1].CopyTo(newLastArray, 0); 
      byteslist[byteslist.Count - 1] = newLastArray; 
     } 
     foreach (byte[] byteArray in byteslist) 
     { 
      ulong value = 0; 

      //for (int i = 0; i < byteArray.Length; i++) value = value * 256 + byteArray[i]; 
      value = BitConverter.ToUInt64(byteArray, 0); 
      result = result + Encode36(value).PadLeft(BASE36_BLOC_SIZE_36, '0'); 
     } 
    } 
    return result; 
} 
public static byte[] Base36StringToByteArray(string input) 
{ 
    byte[] result = new byte[0]; 
    if (input.Length >= BASE36_LENGTH_BLOC_SIZE_36) 
    { 
     int arrayLength = (int)Decode36(input.Substring(0, BASE36_LENGTH_BLOC_SIZE_36)); 
     string data = input.Remove(0, BASE36_LENGTH_BLOC_SIZE_36); 
     List<byte[]> bytesList = new List<byte[]>(); 
     foreach (string value36 in new List<string>(SplitStringByLength(data, BASE36_BLOC_SIZE_36))) 
     { 
      byte[] byteArray = BitConverter.GetBytes(Decode36(value36)); 
      bytesList.Add(byteArray); 
     } 
     result = JoinBytes(bytesList); 
     Array.Resize(ref result, arrayLength); 
    } 
    return result; 
} 
#endregion 

#region Const 
private const int BASE36_LENGTH_BLOC_SIZE_36 = 6; 
private const int BASE36_BLOC_SIZE_36 = 13; //Encode36(ulong.MaxValue).Length; 
#endregion 

#region private methods 
static string _CharList36 = string.Empty; 
static private string CharList36 
{ 
    get 
    { 
     if (_CharList36.Length < 36) 
     { 
      char[] array = new char[36]; 
      for (int i = 0; i < 10; i++) array[i] = (char)(i + 48); 
      for (int i = 0; i < 26; i++) array[i + 10] = (char)(i + 97); 
      _CharList36 = new string(array); 
     } 
     return _CharList36; 
    } 
} 

private static List<string> SplitStringByLength(string str, int chunkSize) 
{ 
    List<string> list = new List<string>(); 
    int i; 
    for (i = 0; i < str.Length/chunkSize; i++) 
    { 
     list.Add(str.Substring(i * chunkSize, chunkSize)); 
    } 
    i = i * chunkSize; 
    if (i < str.Length - 1) 
     list.Add(str.Substring(i, str.Length - i)); 
    return list; 
} 

private static String Encode36(ulong input) 
{ 
    if (input < 0) throw new ArgumentOutOfRangeException("input", input, "input cannot be negative"); 

    char[] clistarr = CharList36.ToCharArray(); 
    var result = new Stack<char>(); 
    while (input != 0) 
    { 
     result.Push(clistarr[input % 36]); 
     input /= 36; 
    } 
    return new string(result.ToArray()).ToUpper(); 
} 

private static ulong Decode36(string input) 
{ 
    var reversed = ReverseString(input.ToLower()); 
    ulong result = 0; 
    int pos = 0; 
    foreach (char c in reversed) 
    { 
     result += (ulong)CharList36.IndexOf(c) * (ulong)Math.Pow(36, pos); 
     pos++; 
    } 
    return result; 
} 

private static string ReverseString(string text) 
{ 
    char[] cArray = text.ToCharArray(); 
    string reverse = String.Empty; 
    for (int i = 0; i < cArray.Length/2; i++) 
    { 
     char c = cArray[i]; 
     cArray[i] = cArray[cArray.Length - 1 - i]; 
     cArray[cArray.Length - 1 - i] = c; 
    } 
    return new string(cArray); 
} 

private static byte[] StringToBytes(string str) 
{ 
    byte[] bytes = new byte[str.Length * sizeof(char)]; 
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length); 
    return bytes; 
} 

private static List<byte[]> SplitBytes(byte[] bytes, int length) 
{ 
    List<byte[]> result = new List<byte[]>(); 

    int position = 0; 
    while (bytes.Length - position > length) 
    { 
     byte[] temp = new byte[length]; 
     for (int i = 0; i < temp.Length; i++) temp[i] = bytes[i + position]; 
     position += length; 
     result.Add(temp); 
    } 
    if (position < bytes.Length) 
    { 
     byte[] temp = new byte[bytes.Length - position]; 
     for (int i = 0; i + position < bytes.Length; i++) temp[i] = bytes[i + position]; 
     result.Add(temp); 
    } 
    return result; 
} 

private static string BytesToString(byte[] bytes) 
{ 
    char[] chars = new char[bytes.Length/sizeof(char)]; 
    System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length); 
    return new string(chars); 
} 

private static byte[] JoinBytes(List<byte[]> listBytes) 
{ 
    int totalLength = 0; 
    foreach (byte[] bytes in listBytes) totalLength += bytes.Length; 
    byte[] result = new byte[totalLength]; 
    int position = 0; 
    foreach (byte[] bytes in listBytes) 
     for (int i = 0; i < bytes.Length; i++) 
     { 
      result[position] = bytes[i]; 
      position++; 
     } 
    return result; 
} 

#endregion 
} 

Answer 2

można zakodować wynikające bajtów za pomocą Base36 lub innego takiego binary-to-text encoding.