AES zurückzukehren Alphanumeric

Question

ich einen AES-Verschlüsselungscode haben, ich will es nur alphanumerische Zeichen wie {ABCDEFGHIJKLMNOPQRSTWUVYZ}

zurückkehren machen, aber aber ich konnte nicht herausfinden, wie das zu tun. Ich habe fast keine Ahnung von Verschlüsselung, konnte nicht herausfinden, wo ich reparieren soll. Ich würde Ihr Feedback sehr begrüßen. Viele Grüße ...

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

Verschlüsselungs- und Entschlüsselungsfunktionen verwenden Byte-Arrays als Parameter. Also müssen Sie diese Arrays in Basis 36 Zeichenfolge konvertieren.

Sie die folgende Klasse verwenden können (Base36), um diese Konvertierungen zu machen:

Alles, was Sie tun müssen, ist, diese beiden Funktionen aufrufen:

byte[] byteArray; 

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

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

und ist dies die Klasse:

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

Sie können die resultierenden Bytes kodieren Base36 oder eine andere solche binary-to-text encoding verwenden.