Ignore:
Timestamp:
Jul 30, 2009, 8:02:07 PM (12 years ago)
Author:
Sören Rinne
Message:
  • Trivium now generates correct keystream
Location:
trunk/CrypPlugins/Trivium
Files:
4 deleted
5 edited

Legend:

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

    r371 r410  
    1515namespace Cryptool.Trivium
    1616{
    17     [Author("Soeren Rinne & Daehyun Strobel", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for Embedded Security (EmSec)", "http://www.crypto.ruhr-uni-bochum.de/")]
     17    [Author("Soeren Rinne, David Oruba & Daehyun Strobel", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for Embedded Security (EmSec)", "http://www.trust.ruhr-uni-bochum.de/")]
    1818    [PluginInfo(false, "Trivium", "Trivium", "Trivium/DetailedDescription/Description.xaml", "Trivium/icon.png", "Trivium/Images/encrypt.png", "Trivium/Images/decrypt.png")]
    1919    [EncryptionType(EncryptionType.SymmetricBlock)]
     
    2323
    2424        private TriviumSettings settings;
    25         private string inputString;
     25        private string inputString = null;
    2626        private string outputString;
    2727        private string inputKey;
     
    5151        }
    5252
    53         [PropertyInfo(Direction.Input, "Input", "Data to be encrypted or decrypted.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     53        /*[PropertyInfo(Direction.Input, "Input", "Data to be encrypted or decrypted.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    5454        public string InputString
    5555        {
     
    6060                OnPropertyChanged("InputString");
    6161            }
    62         }
     62        }*/
    6363
    6464        [PropertyInfo(Direction.Input, "Key", "Must be 10 bytes (80 bit) in Hex.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     
    224224                        bin[i * 4 + 3] = 1;
    225225                        break;
     226                    case 'A':
     227                        bin[i * 4] = 1;
     228                        bin[i * 4 + 1] = 0;
     229                        bin[i * 4 + 2] = 1;
     230                        bin[i * 4 + 3] = 0;
     231                        break;
     232                    case 'B':
     233                        bin[i * 4] = 1;
     234                        bin[i * 4 + 1] = 0;
     235                        bin[i * 4 + 2] = 1;
     236                        bin[i * 4 + 3] = 1;
     237                        break;
     238                    case 'C':
     239                        bin[i * 4] = 1;
     240                        bin[i * 4 + 1] = 1;
     241                        bin[i * 4 + 2] = 0;
     242                        bin[i * 4 + 3] = 0;
     243                        break;
     244                    case 'D':
     245                        bin[i * 4] = 1;
     246                        bin[i * 4 + 1] = 1;
     247                        bin[i * 4 + 2] = 0;
     248                        bin[i * 4 + 3] = 1;
     249                        break;
     250                    case 'E':
     251                        bin[i * 4] = 1;
     252                        bin[i * 4 + 1] = 1;
     253                        bin[i * 4 + 2] = 1;
     254                        bin[i * 4 + 3] = 0;
     255                        break;
     256                    case 'F':
     257                        bin[i * 4] = 1;
     258                        bin[i * 4 + 1] = 1;
     259                        bin[i * 4 + 2] = 1;
     260                        bin[i * 4 + 3] = 1;
     261                        break;
    226262                }
    227263            }
     
    230266        }
    231267
    232         private char[] bintohex(int[] bin)
     268        private string bintohex(string bin)
    233269        {
    234270            int i;
    235             char[] hex = new char[bin.Length / 16];
    236             GuiLogMessage("output length: " + hex.Length, NotificationLevel.Info);
     271            string hex = null;
    237272            string temp;
    238273
    239             for (i = 0; i < hex.Length; i++)
     274            for (i = 0; i < bin.Length / 4; i++)
    240275            {
    241276                temp = null;
     
    248283                {
    249284                    case "0000":
    250                         hex[i] = '0';
     285                        hex += '0';
    251286                        break;
    252287                    case "0001":
    253                         hex[i] = '1';
     288                        hex += '1';
    254289                        break;
    255290                    case "0010":
    256                         hex[i] = '2';
     291                        hex += '2';
    257292                        break;
    258293                    case "0011":
    259                         hex[i] = '3';
     294                        hex += '3';
    260295                        break;
    261296                    case "0100":
    262                         hex[i] = '4';
     297                        hex += '4';
    263298                        break;
    264299                    case "0101":
    265                         hex[i] = '5';
     300                        hex += '5';
    266301                        break;
    267302                    case "0110":
    268                         hex[i] = '6';
     303                        hex += '6';
    269304                        break;
    270305                    case "0111":
    271                         hex[i] = '7';
     306                        hex += '7';
    272307                        break;
    273308                    case "1000":
    274                         hex[i] = '8';
     309                        hex += '8';
    275310                        break;
    276311                    case "1001":
    277                         hex[i] = '9';
     312                        hex += '9';
    278313                        break;
    279314                    case "1010":
    280                         hex[i] = 'a';
     315                        hex += 'A';
    281316                        break;
    282317                    case "1011":
    283                         hex[i] = 'b';
     318                        hex += 'B';
    284319                        break;
    285320                    case "1100":
    286                         hex[i] = 'c';
     321                        hex += 'C';
    287322                        break;
    288323                    case "1101":
    289                         hex[i] = 'd';
     324                        hex += 'D';
    290325                        break;
    291326                    case "1110":
    292                         hex[i] = 'e';
     327                        hex += 'E';
    293328                        break;
    294329                    case "1111":
    295                         hex[i] = 'f';
     330                        hex += 'F';
    296331                        break;
    297332                }
     
    304339        public void Execute()
    305340        {
    306             process(settings.Action);
     341            process(1);
    307342        }
    308343
     
    312347            try
    313348            {
    314                 //read input
    315                 int[] inputIntArray = new int[inputString.Length * 4];
    316                 inputIntArray = hextobin(inputString.ToCharArray());
    317                 long inputbytes = inputIntArray.Length;
    318 
    319                 GuiLogMessage("input length [byte]: " + inputbytes, NotificationLevel.Info);
    320 
    321                 long keybytes = inputKey.Length;
    322                 int[] key = new int[keybytes];
    323 
    324                 GuiLogMessage("inputKey length [byte]: " + keybytes.ToString(), NotificationLevel.Debug);
    325 
    326                 if (keybytes != 20)
    327                 {
    328                     GuiLogMessage("Given key has false length. Please provide a key with 20 Bytes length in Hex notation. Aborting now.", NotificationLevel.Error);
    329                     return;
    330                 }
    331 
    332                 long IVbytes = inputIV.Length;
    333                 int[] IV = new int[IVbytes];
    334                 GuiLogMessage("inputIV length [byte]: " + IVbytes.ToString(), NotificationLevel.Debug);
    335 
    336                 if (IVbytes != 20)
    337                 {
    338                     GuiLogMessage("Given IV has false length. Please provide an IV with 20 Bytes length in Hex notation. Aborting now.", NotificationLevel.Error);
    339                     return;
    340                 }
    341 
    342                 // convert from hex to binary
    343                 IV = hextobin(inputIV.ToCharArray());
    344                 key = hextobin(inputKey.ToCharArray());
     349                //string IV_string = "288ff65dc42b92f960c7";
     350                //string key_string = "0f62b5085bae0154a7fa";
     351                string IV_string = inputIV;
     352                string key_string = inputKey;
     353                int[] IV = new int[IV_string.Length * 4];
     354                int[] key = new int[key_string.Length * 4];
     355               
     356                IV = hextobin(IV_string.ToCharArray());
     357                key = hextobin(key_string.ToCharArray());
    345358
    346359                GuiLogMessage("length of IV: " + IV.Length, NotificationLevel.Info);
     
    349362                string keystream;
    350363
     364                int keyStreamLength = settings.KeystreamLength;
     365                if ((keyStreamLength % 32) != 0)
     366                {
     367                    GuiLogMessage("Keystream length must be a multiple of 32. " + keyStreamLength + " != 32", NotificationLevel.Error);
     368                    return;
     369                }
     370
    351371                // encryption/decryption
    352372                DateTime startTime = DateTime.Now;
    353373
    354                 if (action == 0)
    355                 {
    356                     GuiLogMessage("Starting encryption [Keysize=80 Bits]", NotificationLevel.Info);
    357                     // init Trivium
    358                     initTrivium(IV, key);
    359 
    360                     // generate keystream with length of inputbytes
    361                     keystream = keystreamTrivium((int)inputbytes);
    362                     char[] charKeystream = keystream.ToCharArray();
    363                     int[] keystreamIntArray = hextobin(charKeystream);
    364                     int[] outputIntArray = new int[keystreamIntArray.Length];
    365 
    366                     char[] keyTemp = bintohex(keystreamIntArray);
    367                     string keyTempstr = null;
    368 
    369                     for (int i = 0; i < keyTemp.Length; i++)
    370                     {
    371                         keyTempstr += keyTemp[i];
    372                     }
    373 
    374                     GuiLogMessage("keystream: " + keyTempstr, NotificationLevel.Info);
    375 
    376                     // compute XOR with input and keystream
    377                     for (int i = 0; i < inputbytes; i++)
    378                     {
    379                         //generate XOR inputs
    380                         int one = inputIntArray[i];
    381                         int two = keystreamIntArray[i];
    382                         //GuiLogMessage("one: " + one + ", two: " + two, NotificationLevel.Info);
    383                         outputIntArray[i] = one ^ two;
    384                     }
    385                     char[] outputCharArray = bintohex(outputIntArray);
    386                     for (int i = 0; i < outputCharArray.Length; i++)
    387                     {
    388                         outputString += outputCharArray[i];
    389                     }
    390                     OnPropertyChanged("OutputString");
    391                 } else if (action == 1) {
    392                    
    393                 }
    394 
     374                GuiLogMessage("Starting encryption [Keysize=80 Bits]", NotificationLevel.Info);
     375
     376
     377
     378                // init Trivium
     379                initTrivium(IV, key);
     380
     381                // generate keystream with given length (TODO: length of inputbytes)
     382                // ACHTUNG, mag keine grossen zahlen als inputs
     383                // EDIT 30.07.09: Jetzt mag er große Zahlen ;)
     384                keystream = keystreamTrivium(settings.KeystreamLength);
     385               
    395386                DateTime stopTime = DateTime.Now;
    396387                TimeSpan duration = stopTime - startTime;
    397388
     389                if (!settings.HexOutput)
     390                {
     391                    outputString = keystream;
     392                    GuiLogMessage("Keystream hex: " + bintohex(keystream), NotificationLevel.Info);
     393                }
     394                else
     395                {
     396                    outputString = bintohex(keystream);
     397                    GuiLogMessage("Keystream binary: " + keystream, NotificationLevel.Info);
     398                }
     399                OnPropertyChanged("OutputString");
     400
    398401                if (!stop)
    399402                {
    400                     if (action == 0)
    401                     {
    402                         //GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    403                     }
    404                     else
    405                     {
    406                         //GuiLogMessage("Decryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    407                     }
     403                    GuiLogMessage("Encryption complete! (keystream length: " + keystream.Length + " bit)", NotificationLevel.Info);
    408404                }
    409405
     
    426422        {
    427423                int i,j;
     424
     425            int[] buffer = new int[8];
     426
     427            if (settings.UseByteSwapping)
     428            {
     429                // Byte-Swapping Key
     430                for (int l = 0; l < 10; l++)
     431                {
     432                    for (int k = 0; k < 8; k++)
     433                        buffer[k] = key[((l * 8) + 7) - k];
     434                    for (int k = 0; k < 8; k++)
     435                        key[(l * 8) + k] = buffer[k];
     436                }
     437
     438                // Byte-Swapping IV
     439                for (int l = 0; l < 10; l++)
     440                {
     441                    for (int k = 0; k < 8; k++)
     442                        buffer[k] = IV[((l * 8) + 7) - k];
     443                    for (int k = 0; k < 8; k++)
     444                        IV[(l * 8) + k] = buffer[k];
     445                }
     446            }
     447
    428448                for (i = 0; i < 80; i++){
    429449                        a[i] = (uint)key[i]; // hier key rein als binär
     
    476496
    477497            string keystreamZ = null;
     498            List<int> keyOutput = new List<int>();
    478499
    479500            for (i = 0; i < nBits; i++)
     
    484505                z = t1 ^ t2 ^ t3;
    485506
    486                 keystreamZ += z;
     507                if (!settings.UseByteSwapping)
     508                    keystreamZ += z;
     509                else
     510                    keyOutput.Add((int)z);
    487511
    488512                t1 = t1 ^ (a[90] & a[91]) ^ b[77];
     
    500524            }
    501525
     526            if (settings.UseByteSwapping)
     527            {
     528                int[] temp = new int[nBits];
     529
     530                // Little-Endian für den Keystream
     531                for (int k = 0; k < nBits; k++)
     532                    temp[k] = keyOutput[k];
     533                for (int l = 0; l < nBits / 32; l++)
     534                {
     535                    for (int k = 0; k < 8; k++)
     536                    {
     537                        keyOutput[(l * 32) + k] = (char)temp[(l * 32) + 24 + k];
     538                        keyOutput[(l * 32) + 8 + k] = (char)temp[(l * 32) + 16 + k];
     539                        keyOutput[(l * 32) + 16 + k] = (char)temp[(l * 32) + 8 + k];
     540                        keyOutput[(l * 32) + 24 + k] = (char)temp[(l * 32) + k];
     541                    }
     542                }
     543                GuiLogMessage(keyOutput.Count.ToString(), NotificationLevel.Info);
     544                foreach (int k in keyOutput)
     545                {
     546                    keystreamZ += k.ToString();
     547                }
     548            }
     549
    502550            return keystreamZ;
    503551        }
  • trunk/CrypPlugins/Trivium/Trivium.csproj

    r371 r410  
    6565  </ItemGroup>
    6666  <ItemGroup>
    67     <Resource Include="Images\decrypt.png" />
    68   </ItemGroup>
    69   <ItemGroup>
    70     <Resource Include="Images\encrypt.png" />
    71   </ItemGroup>
    72   <ItemGroup>
    7367    <Resource Include="icon.png" />
    7468  </ItemGroup>
     
    8478      <SubType>Designer</SubType>
    8579    </Resource>
    86   </ItemGroup>
    87   <ItemGroup>
    88     <Resource Include="Images\decryptX.png" />
    89     <Resource Include="Images\encryptX.png" />
    9080    <Resource Include="Images\Trivium.png" />
    9181  </ItemGroup>
  • trunk/CrypPlugins/Trivium/TriviumSettings.cs

    r371 r410  
    2121
    2222        private bool hasChanges = false;
    23         private int action = 0; //0=encrypt, 1=decrypt
    2423
    25         [ContextMenu("Action","Do you want the input data to be encrypted or decrypted?",1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 1, 2}, "Encrypt","Decrypt")]
    26         [TaskPane("Action", "Do you want the input data to be encrypted or decrypted?", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Encrypt", "Decrypt" })]
    27         public int Action
     24        private int keystreamLength = 32;
     25        [TaskPane("Length of keystream", "How many bits of keystream in bits should be generated? Must be a multiple of 32.", null, 0, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
     26        public int KeystreamLength
    2827        {
    29             get { return this.action; }
    30             set { this.action = (int)value; }
     28            get { return this.keystreamLength; }
     29            set
     30            {
     31                this.keystreamLength = value;
     32                //OnPropertyChanged("KeystreamLength");
     33                HasChanges = true;
     34            }
     35        }
     36
     37        private bool useByteSwapping = false;
     38        [ContextMenu("Use byte swapping", "With this checkbox enabled, output bytes will be swapped.", 1, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Use byte swapping?" })]
     39        [TaskPane("Use byte swapping", "With this checkbox enabled, output bytes will be swapped.", null, 1, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     40        public bool UseByteSwapping
     41        {
     42            get { return this.useByteSwapping; }
     43            set
     44            {
     45                this.useByteSwapping = (bool)value;
     46                //OnPropertyChanged("UseByteSwapping");
     47                HasChanges = true;
     48            }
     49        }
     50
     51        private bool hexOutput = false;
     52        [ContextMenu("Generate Hex output", "With this checkbox enabled, output bytes will be displayed in hex.", 1, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Display as hex?" })]
     53        [TaskPane("Generate Hex output", "With this checkbox enabled, output bytes will be displayed in hex.", null, 1, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     54        public bool HexOutput
     55        {
     56            get { return this.hexOutput; }
     57            set
     58            {
     59                this.hexOutput = (bool)value;
     60                //OnPropertyChanged("HexOutput");
     61                HasChanges = true;
     62            }
    3163        }
    3264
Note: See TracChangeset for help on using the changeset viewer.