Changeset 1263


Ignore:
Timestamp:
Mar 26, 2010, 3:27:13 PM (12 years ago)
Author:
Matthäus Wander
Message:

Nihilist:

TextOutput:

  • added decimal output format (output bytes as decimal numbers, separated by whitespace)
Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Nihilist/Nihilist.cs

    r899 r1263  
    11/*                             
    2    Copyright 2009 Fabian Enkler
     2   Copyright 2009-2010 Fabian Enkler, Matthäus Wander
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
     
    2323using Cryptool.PluginBase.Cryptography;
    2424using System.Windows;
     25using System.Diagnostics;
     26using Cryptool.PluginBase.Miscellaneous;
    2527
    2628namespace Nihilist
     
    3133    public class Nihilist : IEncryption
    3234    {
     35        public const string ALPHABET = "abcdefghiklmnopqrstuvwxyz";
     36
    3337        private readonly NihilistSettings settings = new NihilistSettings();
    3438
     
    3640#pragma warning disable 67
    3741        public event StatusChangedEventHandler OnPluginStatusChanged;
     42#pragma warning restore
    3843        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    39 #pragma warning restore
    4044        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    4145
     
    8488        }
    8589
     90        // Convert byte[] indexes (0..4, 0..4) to two-digit number (11..55)
     91        // 0, 0 -> 11
     92        // 4, 1 -> 52
     93        private byte ConvertIndexesToTwoDigit(byte[] arr)
     94        {
     95            Debug.Assert(arr.Length == 2);
     96            return ConvertToDimensionOne(arr[0], arr[1]);
     97        }
     98
     99        private byte ConvertToDimensionOne(byte x, byte y)
     100        {
     101            Debug.Assert(0 <= x && x <= 4);
     102            Debug.Assert(0 <= y && y <= 4);
     103
     104            x++;
     105            y++;
     106            return (byte) (x * 10 + y);
     107        }
     108
     109        // Convert two-digit number (11..55) to byte[] indexes (0..4, 0..4)
     110        // 11 -> 0, 0
     111        // 52 -> 4, 1
     112        private byte[] ConvertTwoDigitToIndexes(byte z)
     113        {
     114            Debug.Assert(11 <= z && z <= 55, "Expected 11..55, got: " + z);
     115
     116            byte x = (byte)(z / 10);
     117            byte y = (byte)(z % 10);
     118            x--;
     119            y--;
     120
     121            return new byte[] { x, y };
     122        }
     123
    86124        public void Execute()
    87125        {
    88126            char[,] KeyArray;
    89             var CryptMatrix = CreateCryptMatrix(out KeyArray);
    90             var secondKeyByteArray = new byte[settings.SecondKeyWord.Length];
    91             int Counter = 0;
    92             foreach (var c in settings.SecondKeyWord.ToLower())
    93             {
    94                 byte tmpByte = byte.Parse(CryptMatrix[c].X.ToString() + CryptMatrix[c].Y.ToString());
    95                 secondKeyByteArray[Counter] = tmpByte;
    96                 Counter++;
    97             }
    98             output = new byte[input.Length];
    99             int max = input.Length;
     127            Dictionary<char, byte[]> CryptMatrix = CreateCryptMatrix(out KeyArray);
     128
     129            string secondKeyWord = settings.SecondKeyWord.ToLower();
     130            byte[] secondKeyNumbers = new byte[secondKeyWord.Length];
     131            for(int i = 0; i < secondKeyWord.Length; i++)
     132            {
     133                char c = secondKeyWord[i];
     134                secondKeyNumbers[i] = ConvertIndexesToTwoDigit(CryptMatrix[c]);
     135            }
    100136            if (settings.Action == 0)
    101137            {
    102                 int i = 0;
    103                 int j = 0;
    104                 string inputString = ByteArrayToString(input);
    105 
    106                 foreach (var c in inputString.ToLower())
    107                 {
    108                     var c1 = c;
    109                     if (c1 == 'j')
    110                         c1 = 'i';
    111 
    112                     byte tmpByte = CryptMatrix.ContainsKey(c1) ? byte.Parse(CryptMatrix[c1].X.ToString() + CryptMatrix[c1].Y.ToString()) : HandleUnknownChar();
    113                     tmpByte += secondKeyByteArray[j];
    114                     output[i] = tmpByte;
    115                     i++;
    116                     j++;
    117                     if (j >= secondKeyByteArray.Length)
    118                         j = 0;
    119 
    120                     OnProgressChanged(i+1,max);
    121                 }
     138                string rawInputString = ByteArrayToString(input).ToLower();
     139                string inputString = StringUtil.StripUnknownSymbols(ALPHABET, rawInputString);
     140                byte[] outputBytes = new byte[inputString.Length];
     141                for (int i = 0; i < inputString.Length; i++)
     142                {
     143                    // convert character -> two-digit number
     144                    char plainChar = inputString[i];
     145                    byte plainNumber = ConvertIndexesToTwoDigit(CryptMatrix[plainChar]);
     146
     147                    // calculate cipher number
     148                    outputBytes[i] = (byte)(plainNumber + secondKeyNumbers[i % secondKeyNumbers.Length]);
     149
     150                    OnProgressChanged(i+1, inputString.Length);
     151                }
     152                this.output = outputBytes;
    122153            }
    123154            else
    124155            {
    125                 int i = 0;
    126                 int j = 0;
    127                 foreach (byte b in input)
    128                 {
    129                     byte tmpbyte = b;
    130                     tmpbyte -= secondKeyByteArray[j];
    131                     string tmpString = tmpbyte.ToString();
    132                     if (tmpbyte < 255)
     156                char[] outputChars = new char[input.Length];
     157                for (int i = 0; i < input.Length; i++)
     158                {
     159                    // calculate plain number
     160                    byte plainNumber = (byte)(input[i] - secondKeyNumbers[i % secondKeyNumbers.Length]);
     161                    if (plainNumber < 11 || plainNumber > 55)
    133162                    {
    134                         if (tmpbyte < 10)
    135                             tmpString = "0" + tmpString;
    136                         int Index1 = int.Parse(tmpString[0].ToString());
    137                         int Index2 = int.Parse(tmpString[1].ToString());
    138                         char DecryptedChar = KeyArray[Index1, Index2];
    139                         output[i] = (byte)DecryptedChar;
     163                        GuiLogMessage("Plaintext two-digit-number out of range, expected 11 <= x <= 55, got: " + plainNumber + ". Wrong key?", NotificationLevel.Error);
     164                        break;
    140165                    }
    141                     else
    142                     {
    143                         output[i] = (byte)'?';
    144                     }
    145 
    146                     i++;
    147                     j++;
    148                     if (j >= secondKeyByteArray.Length)
    149                         j = 0;
    150                     OnProgressChanged(i+1, max);
    151                 }
     166                    byte[] indexes = ConvertTwoDigitToIndexes(plainNumber);
     167
     168                    // convert two-digit number -> character
     169                    outputChars[i] = KeyArray[indexes[0], indexes[1]];
     170
     171                    OnProgressChanged(i+1, input.Length);
     172                }
     173                this.output = CharArrayToByteArray(outputChars);
    152174            }
    153175            OnPropertyChanged("Output");
    154176        }
    155177
    156         private static byte HandleUnknownChar()
    157         {
    158             return 255;
    159         }
    160 
    161         private static string ByteArrayToString(ICollection<byte> arr)
    162         {
    163             var builder = new StringBuilder(arr.Count);
    164             foreach (var b in arr)
    165             {
    166                 builder.Append((char)b);
    167             }
    168             return builder.ToString();
    169         }
    170 
    171         private Dictionary<char, Vector> CreateCryptMatrix(out char[,] KeyArr)
     178        private static string ByteArrayToString(byte[] arr)
     179        {
     180            return Encoding.Default.GetString(arr);
     181        }
     182
     183        private static byte[] CharArrayToByteArray(char[] arr)
     184        {
     185            return Encoding.Default.GetBytes(arr);
     186        }
     187
     188        private Dictionary<char, byte[]> CreateCryptMatrix(out char[,] KeyArr)
    172189        {
    173190            var KeyArray = new char[5, 5];
     
    175192            int Row = 0;
    176193            int Col = 0;
    177             foreach (var c in settings.KeyWord.ToLower() + "abcdefghiklmnopqrstuvwxyz")
     194            foreach (var c in settings.KeyWord.ToLower() + ALPHABET)
    178195            {
    179196                if (!CharDic.Contains(c))
     
    191208            }
    192209            KeyArr = KeyArray;
    193             var CharPosDic = new Dictionary<char, Vector>();
    194             for (int i = 0; i < KeyArray.GetLength(0); i++)
    195             {
    196                 for (int j = 0; j < KeyArray.GetLength(1); j++)
    197                 {
    198                     CharPosDic.Add(KeyArray[i, j], new Vector(i, j));
     210            var CharPosDic = new Dictionary<char, byte[]>();
     211            for (byte i = 0; i < KeyArray.GetLength(0); i++)
     212            {
     213                for (byte j = 0; j < KeyArray.GetLength(1); j++)
     214                {
     215                    CharPosDic.Add(KeyArray[i, j], new byte[] { i, j });
    199216                }
    200217            }
     
    238255                OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
    239256        }
     257
     258        private void GuiLogMessage(string message, NotificationLevel logLevel)
     259        {
     260            if (OnGuiLogNotificationOccured != null)
     261                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));
     262        }
    240263    }
    241264}
  • trunk/CrypPlugins/TextOutput/TextOutput.cs

    r1259 r1263  
    314314          case TextOutputSettings.PresentationFormat.Base64:
    315315            fillValue = Convert.ToBase64String(Encoding.Default.GetBytes(fillValue.ToCharArray()));
     316            break;
     317          case TextOutputSettings.PresentationFormat.Decimal:
     318            byte[] decValues = Encoding.Default.GetBytes(fillValue.ToCharArray());
     319            StringBuilder sb = new StringBuilder();
     320            if (decValues.Length > 0)
     321            {
     322              sb.Append(decValues[0]);
     323              for (int i = 1; i < decValues.Length; i++)
     324              {
     325                sb.Append(" ");
     326                sb.Append(decValues[i]);
     327              }
     328            }
     329            fillValue = sb.ToString();
    316330            break;
    317331          default:
  • trunk/CrypPlugins/TextOutput/TextOutputSettings.cs

    r1259 r1263  
    3939    public enum EncodingTypes { Default = 0, Unicode = 1, UTF7 = 2, UTF8 = 3, UTF32 = 4, ASCII = 5, BigEndianUnicode = 6 };
    4040    public enum DynamicDataTypes { CryptoolStream, String, ByteArray, Boolean, Integer , Double, Object};
    41     public enum PresentationFormat { Text, Hex, Base64 }
     41    public enum PresentationFormat { Text, Hex, Base64, Decimal }
    4242
    4343    public bool CanChangeProperty { get; set; }
     
    100100    /// </summary>
    101101    /// <value>The presentation format setting.</value>
    102     [ContextMenu("Presentation format", "Choose the format that will be used te present the input data.", 2, DisplayLevel.Experienced, ContextMenuControlType.ComboBox, null, new string[] { "Text", "Hex", "Base64" })]
    103     [TaskPane("Presentation format", "Choose the format that will be used te present the input data.", null, 2, false, DisplayLevel.Experienced, ControlType.RadioButton, new string[] { "Text", "Hex", "Base64" })]
     102    [ContextMenu("Presentation format", "Choose the format that will be used te present the input data.", 2, DisplayLevel.Experienced, ContextMenuControlType.ComboBox, null, new string[] { "Text", "Hex", "Base64", "Decimal" })]
     103    [TaskPane("Presentation format", "Choose the format that will be used te present the input data.", null, 2, false, DisplayLevel.Experienced, ControlType.RadioButton, new string[] { "Text", "Hex", "Base64", "Decimal" })]
    104104    public int PresentationFormatSetting
    105105    {
Note: See TracChangeset for help on using the changeset viewer.